c++ when to return a const char* instead of a std:string

Question

In the class below is there any benefit or reason why speak() returns a const char* instead of a std::string?

class Animal
{
protected:
    std::string m_name;

    Animal(std::string name)
    : m_name(name)
    {
    }

public:
    std::string getName() { return m_name; }
    const char* speak() { return "???"; }
};

it doesn't create a new copy of the string when you return a pointer to the string literal. When you return a std::string it needs to copy the memory. — PeterT, Apr 24 '18 at 09:25
You need `const char*`, e.g., when interacting with libraries written in C. An example would be sending a string by MPI library. — Daniel Langr, Apr 24 '18 at 09:41
I would say *never* return `const char*` given that you have a `std::string`. Return `const std::string&` and let the caller decide if he wants the `const std::string&` or a `const char*` derived from it. — Galik, Apr 24 '18 at 10:36
@Galik returning by ref is not appropriate in many cases and is quite dangerous. Personally I would advise the OP to just return a std::string by copy. The compiler optimises a lot. — Kakalokia, Apr 24 '18 at 11:39
@AliAlamiri Ah re-reading the question it seems they only want to return a string literal. I think I misunderstood their intent. — Galik, Apr 24 '18 at 11:43

hegel5000 · Answer 1 · 2018-04-24T11:02:30.377

What a string literal such as "???" does is it tells the compiler to include a piece of global memory containing that particular sequence of characters (plus the character '\0' at the end). The string literal expression has a value of type const char* pointing to that piece of global memory.

What that means is that in this very particular circumstance, it's safe to pass around the pointer. Note that the following function

std::string speak() { return "???"; }

has the same function body but a rather different code path. The string literal expression (the global memory, the pointer) is still there, but it is used as an argument to the constructor for std::string; it is implicitly converted to std::string.

That constructor for std::string dynamically allocates some memory (well not in this case with the short string optimization, probably) and copies from the pointer you give it.

So in this very particular case, where you have a string literal and nothing else, you can return a const char*. It will probably get implicitly converted to std::string when passed to another function which expects it, so const char* isn't all that much of an optimization.

since C++17 there is another option, namely to return a `std::string_view`. This also will not allocate memory and additionally will provide the length of the compile-time string. This should be the preferred variant as this also tells the callers that there is a correct bound to the string, a plain char * might point to something that's not zero-terminated or a string that contains multiple zero-bytes. — Norbert Lange, Apr 24 '18 at 12:20

score 5 · Answer 2 · answered Apr 24 '18 at 09:55

std::string comes with a lot of maybe unwanted and also unused features. If you do not want all that features you should think about the cost of the usage. Passing around std::string needs at minimum a first copy from the literal to the internal storage of the string. Maybe you get some additional copies if you pass the string to other functions and back. If small string optimization is present, you can not simply move the string, so the cost becomes higher in that case.

If you do not want the cost but get all features for a constant string, you should take a look for std::string_view. The implementation typically contains only a pointer to the underlying data and a value for size. So it comes with less cost and is very feature rich.

And indeed there is nothing wrong with passing const char* if it fits to your needs.

Use always std::string for constant strings is a very common pattern but not a good one.

score 1 · Answer 3 · answered Apr 24 '18 at 11:50

In addition to the other answers, returning a const char* may be needed if you need to call your functions from a different library that is written in a different C++ compiler. For example your Animal class may be compiled with Visual Studio 2013, but the library where you use the Animal class from may be compiled with Visual Studio 2015.

For more info: How do I safely pass objects, especially STL objects, to and from a DLL?

c++ when to return a const char* instead of a std:string

3 Answers3