C++中string成员函数与全局函数的区别及使用场景判断

Great question! This is a super common point of confusion when getting comfortable with C++'s object-oriented and generic programming features. Let's break down the differences clearly, using your examples as anchors.

1. Ownership & Access Rights #

• Member functions (like string.length()) are part of the class itself (in this case, std::string). They have direct access to the class's private/protected internal data—think the underlying character array or the stored length variable. This means they're often more efficient, since they don't need to jump through public interfaces to get what they need.
• Non-member functions (like std::reverse(string.begin(), string.end())) exist independently of the class, usually in a namespace like std. They can only interact with the object via its public API. For reverse, that means using the iterators returned by begin() and end()—it has no clue how std::string stores data under the hood.

2. Implicit vs. Explicit Arguments #

• When you call a member function, the object itself is passed implicitly via the this pointer. Writing my_string.length() is shorthand for something like std::string::length(&my_string) (the compiler handles this for you).
• Non-member functions require you to explicitly pass the target of the operation. reverse needs a range defined by iterators, and it's not tied to any specific type—you could use the same function on a std::vector<int> or std::list<char> just as easily.

3. Purpose & Design Philosophy #

• Member functions handle operations that are intrinsic to the object's identity. Things like checking if it's empty (empty()), adding characters (push_back()), or getting its size (length()) are actions the object "does to itself"—they're core to what the class is designed to do.
• Non-member functions (especially STL algorithms) are for generic, cross-container operations. Reversing, sorting, or searching are actions that make sense for many different data structures, not just strings. This follows C++'s generic programming ethos: write once, use anywhere.

How to Choose Which to Use? #

Here are some practical rules of thumb:

• Use a member function if the operation is tied directly to the object's internal state or is a core behavior of the class. For example, always use my_str.length() to get a string's size—it's optimized and built into the class's design.
• Use a non-member function if the operation is generic and can work across multiple types. std::reverse is perfect here because it works with any container that provides iterators, not just strings.
• Remember C++'s design principle: prefer non-member functions over member functions when possible (unless you need access to private data). This reduces coupling between the class and the operation. For example, std::string's operator+ is a non-member function—this lets you write "hello" + my_str, which wouldn't be possible if it were a member (since the left operand isn't a std::string object).

Quick Example Comparison #

• Want to get a string's length? Go with my_str.length() (member function, direct, efficient).
• Want to reverse the string? Use std::reverse(my_str.begin(), my_str.end()) (non-member, generic, reusable across containers).

内容的提问来源于stack exchange，提问作者blastoise