I am learning C++ from the beginning and I don't get the whole strings topic.
What is the difference between the following three codes?
std::string s = std::string("foo");
std::string s = new std::string("foo");
std::string s = "foo";
Below is the basic syntax for declaring a string. char str_name[size]; In the above syntax str_name is any name given to the string variable and size is used to define the length of the string, i.e the number of characters strings will store.
Overview. The C language does not have a specific "String" data type, the way some other languages such as C++ and Java do. Instead C stores strings of characters as arrays of chars, terminated by a null byte.
char* is a pointer to a character. char is a character. A string is not a character. A string is a sequence of characters.
std::string s = std::string("foo");
This creates a temporary std::string
object containing "foo", then assigns it to s
. (Note that compilers may elide the temporary. The temporary elison in this case is explicitly allowed by the C++ standard.)
std::string s = new std::string("foo");
This is a compiler error. The expression new std::string("foo")
creates an std::string
on the free store and returns a pointer to an std::string
. It then attempts to assign the returned pointer of type std::string*
to s
of type std::string
. The design of the std::string
class prevents that from happening, so the compile fails.
C++ is not Java. This is not how objects are typically created, because if you forget to delete
the returned std::string
object you will leak memory. One of the main benefits of using std::string
is that it manages the underlying string buffer for you automatically, so new
-ing it kind of defeats that purpose.
std::string s = "foo";
This is essentially the same as #1. It technically initializes a new temporary string which will contain "foo", then assigns it to s
. Again, compilers will typically elide the temporary (and in fact pretty much all non-stupid compilers nowadays do in fact eliminate the temporary), so in practice it simply constructs a new object called s
in place.
Specifically it invokes a converting constructor in std::string
that accepts a const char*
argument. In the above code, the converting constructor is required to be non-explicit
, otherwise it's a compiler error. The converting constructor is in fact non-explicit
for std::string
s, so the above does compile.
This is how std::string
s are typically initialized. When s
goes out of scope, the s
object will be destroyed along with the underlying string buffer. Note that the following has the same effect (and is another typical way std::string
s are initialized), in the sense that it also produces an object called s
containing "foo".
std::string s("foo");
However, there's a subtle difference between std::string s = "foo";
and std::string s("foo");
, one of them being that the converting constructor can be either explicit
or non-explicit
in the above case.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With