Initializing strings as null vs. empty string

Question

Would it matter if my C++ code (as shown below) has a string initialized as an empty string:

std::string myStr = ""; ....some code to optionally populate 'myStr'... if (myStr != "") { // do something }

vs. no/null initialization:

std::string myStr; ....some code to optionally populate 'myStr'... if (myStr != NULL) { // do something }

Are there any concerns here?

NULL (conceptually) is a pointer, and should only be used as such. A std::string isn't a pointer, so it shouldn't be combined. PS. the initializations are the same: the ctor of std::string sets it to the empty string. — MSalters
– MSalters, Commented Jul 19, 2012 at 8:58
@MSalters hi I agree to your point but then if the types seems to be incompatible why does the compiler doesn't throw an error. I have VS 2010 and it silently initialize the std::string with NULL. — Krishna
– Krishna, Commented Sep 1, 2014 at 10:23
@Surfing_SO: There's a string constructor which takes a pointer to an array of characters, terminated by a zero char.. You incorrectly did not pass such a pointer (NULL doesn't point to an array of characters, or anything else). This is Undefined Behavior and anything may happen in that case. — MSalters
– MSalters, Commented Sep 1, 2014 at 10:29
As both mentioned "NULL" is not exactly the way it is being initialized. The reason your if works is probably because compiler is implicitly converting both sides to bool and then performs the comparison, which is not what you really wanted. — CommanderHK
– CommanderHK, Commented Oct 21, 2014 at 10:04
Possible duplicate of How to allow a std:string parameter to be NULL? — krlmlr
– krlmlr, Commented Apr 4, 2016 at 13:38

SingerOfTheFall · Accepted Answer · 2012-07-19 08:03:27Z

There's a function empty() ready for you in std::string:

std::string a; if(a.empty()) { //do stuff. You will enter this block if the string is declared like this }

or

std::string a; if(!a.empty()) { //You will not enter this block now } a = "42"; if(!a.empty()) { //And now you will enter this block. }

juanchopanza · Accepted Answer · 2012-07-19 08:03:38Z

30

There are no gotchas. The default construction of std::string is "". But you cannot compare a string to NULL. The closest you can get is to check whether the string is empty or not, using the std::string::empty method..

answered Jul 19, 2012 at 8:03

juanchopanza

228k35 gold badges421 silver badges493 bronze badges

3 Comments

vladon Over a year ago

There is extra temporary when constructing std::string and assigning "" to it.

juanchopanza Over a year ago

@vladon I'm not really sure what temporary you're referring to, or how assignment is relevant. I can't see a temporary in a = ""; when a is std::string, but the question isn't about that.

underscore_d Over a year ago

The default construction of std::string is not ""; it is {}. Default-constructing avoids having to check the char const*, find it is an empty string, and eventually do nothing. That's better.

Luchian Grigore · Accepted Answer · 2012-07-19 08:05:53Z

28

Best:

 std::string subCondition;

This creates an empty string.

This:

std::string myStr = "";

does a copy initialization - creates a temporary string from "", and then uses the copy constructor to create myStr.

Bonus:

std::string myStr("");

does a direct initialization and uses the string(const char*) constructor.

To check if a string is empty, just use empty().

answered Jul 19, 2012 at 8:05

Luchian Grigore

260k68 gold badges465 silver badges634 bronze badges

5 Comments

Andrew Over a year ago

would not std::string myStr = ""; invoke a string(const char*) constructor? Why do you think a temporary will be created?

Luchian Grigore Over a year ago

@Andrew weird, right? stackoverflow.com/questions/11223285/…

James Kanze Over a year ago

@Andrew It almost certainly won't be created, since the standard gives the implementations explicit leave not to create it. On the other hand, the code must be legal even if the temporary was constructed; i.e., there must be an accessible copy constructor.

Luchian Grigore Over a year ago

@JamesKanze yes, but that's an optimization. You can't rely on it. Theoretically, a temp is created.

Andreas Over a year ago

Great hint about the empty string initialisation, which is done nearly all the time when people create a new CString. ;)

Andrew · Accepted Answer · 2012-07-19 08:13:46Z

I would prefere

if (!myStr.empty()) { //do something }

Also you don't have to write std::string a = "";. You can just write std::string a; - it will be empty by default

Adam Romanek · Accepted Answer · 2015-02-05 14:36:21Z

Empty-ness and "NULL-ness" are two different concepts. As others mentioned the former can be achieved via std::string::empty(), the latter can be achieved with boost::optional<std::string>, e.g.:

boost::optional<string> myStr; if (myStr) { // myStr != NULL // ... }

Jirka Hanika · Accepted Answer · 2012-07-19 08:06:35Z

The default constructor initializes the string to the empty string. This is the more economic way of saying the same thing.

However, the comparison to NULL stinks. That is an older syntax still in common use that means something else; a null pointer. It means that there is no string around.

If you want to check whether a string (that does exist) is empty, use the empty method instead:

if (myStr.empty()) ...

Collectives™ on Stack Overflow

Initializing strings as null vs. empty string

6 Answers 6

Comments

3 Comments

5 Comments

Comments

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

3 Comments

5 Comments

Comments

Comments

Comments

Linked

Related