Why does char* refer to strings?

Question

I was reading on errors, where it said that it's common to use concatenation of strings to describe a process, example:

void error(string s1, string s2)
{
throw runtime_error(s1+s2);
}

This led me to play around with just adding strings together, where I found an error in my code and discovered pointers:

int main()
{
    string func = "function";
    string mesg = "Testing" + " new" + func;
    cout << mesg;
}

I looked up the error and a few sources said that "Testing" + " new" was being seen as char* + char* which can't just be added together. My main question is, why doesn't it come off as string* + string*? A minor question I had also, is about the error() function. Why bother to concatenate the strings at all when you can just make a singular string?

Answer 1

The behavior in C++ is inherited from its C roots, and both in C and C++ a literal string is actually an array of char, and as all arrays it decays to a pointer to the first element, which in the case of an array of (read-only) characters will be char const*.

---

The const part is important when dealing with string literals, as all string literals are read-only.

If you define an explicit array, like

char my_string[] = "foobar";

then it's not read-only and so decays to a pointer to char, i.e. char*.

---

As noted by DevSolar, in C string literals are actually plain arrays of char so they decay to char*. However, they are still read-only so using e.g. const char * is still a good idea when dealing with string literals.

References for the C behavior: The C11 standard §6.4.5/6 says

For character string literals, the array elements have type char

and in /7 it says:

If the program attempts to modify such an array, the behavior is undefined.

For C++ (C++11 more specifically as that's the only one I have) the relevant part is §2.14.5 [lex.string], where /8 says

A narrow string literal has type “array of n const char”

Answer 2

Why does char* refer to strings?

Well, it doesn't. It is just a convention; in C it is idiomatic to consider a string (as in a piece of twine) of characters that ends with a NUL character ('\0') as a string. You can have it point to a single character too.

char c = 'a';
char *p = &c;

One of the constructors of std::string takes char* as an argument, hence the implicit conversion makes you think they are interchangeable, but they are not.

why doesn't it come off as string* + string*?

In the sub-expression "Testing" + " new", it needs to implicitly convert both character arrays to std::string to perform what you want, while " new" + func works as you expect since one of them is already a std::string the other is converted, since we have an operator+ function that takes a char* (to which the character array decays into) and std::string. While there's no operator function or a rule in the language which talks about two char arrays.

Why bother to concatenate the strings at all when you can just make a singular string?

If the error function is just what you have shown it to be, then yes, having it take a single std::string makes more sense.

Answer 3

The char* data type is a carry-over from plain C in which a "string" is conventionally expressed as a character array in which the end is the nul character (value zero in ASCII).

What you have written is not additions of two char* variables but instead calling operator+ to concatenate two instances of string objects.

C++ has a way to re-define built-in operators to work with class instances. This is called operator overloading. One common use is for string classes (plural since there are a few known common implementations of string in C++) to define operator+ to concatenate strings together.