How do you convert a Char Vector to a String Vector in C++?

In C , the string literal, “I love you.” can be coded as follows:

Characters in an array of chars, ending with the nul character, is a string. The array above actually contains the phrases, “I love you.” and “anything else” separated by the character, ‘’.

would print:

ignoring anything else. This is the traditional way of having a string in C . Anything else should be ignored after the ‘’ character if the array content is to be considered a string.

With the pointer, the above string would be coded as:

and

would print:

An array of characters is a constant pointer to characters, ending with ‘’. This explains why const is used in the statement, “const char* ptrStr = “I love you.”;”. The double quotes eliminate the use of the array literal structure and ‘’.

With the string class, a string object for the above phrase would be

and

would print:

The string object could still have been instantiated as,

The indirect question is how to convert an array string literal to a literal double quote and how to convert an array literal or double quote literal to a string object. The direct question is, when these values are elements of the vector, how to do these conversions. This article explains that.

Before getting into the core explanation, remember that ‘E’ is a character, while “E” is a string. In order to use vectors of string objects, the program should begin with:

Article Content

• Introduction – see above
• Vector of Array Chars To Vector Pointer Chars
• Vector of Pointer to Chars To Vector of String Objects
• Conclusion

Vector of Array Chars To Vector of Pointer Chars

This section explains how to convert a vector of character arrays that form strings to a vector of constant-pointer-to-strings.

Now,

and

mean the same thing inside, as the following code shows:

The output is:

All code segments for this article are in the main() function body. For the array, the array name with [i] is used to read all the values in the array. The pointer name with [i] is used to read all the values in the string literal for the pointer. Note that ‘’ is implicit at the end of the literal string. What is constant for both cases is the pointer and not the value. An array name is a constant pointer to the sequence of characters, which should end with ‘’.

So, a vector of arrays of chars, where each array ends with ‘’ or a vector of double-quote string literals, should be declared in the same way, as follows:

Consider the following vector of fruit names, where each fruit name is an array of chars, ending with ‘’.

The vector of fruits has been constructed by writing the array names as elements in the vector. This same vector can be constructed with string literals as follows:

So, there is no need to convert a vector of arrays-of-chars to a vector of const-pointers-to-chars. They are the same thing, underneath. Since they are the same thing, an array string value can be read into a const-pointer-to-chars, as the following code shows:

The output is:

The line,

is where the supposed conversion takes place.

Vector of Pointer to Chars To Vector of String Objects

The question of converting a vector of pointer-to-chars to vector-of-string-objects, is the same as the question of converting a vector of arrays-of-chars to vector-of-string-objects. Consider the following statement:

The following declaration has the above declaration, in string object form:

In this case, “#include ” has to be at the top of the program. Notice the template argument and the string object values.

Now, it is possible to assign a string literal, to become the content of a string object, as the following three code segments show:

With this knowledge, each string literal can be read into a string object variable, as the following code shows:

The output is:

The line that does the conversion from literal to string object is:

If the vector values were array strings, then the following code will do the same thing:

The output is the same:

The line that does the conversion from literal to a string object is still the same:

Vector of String Literals to Vector of String Objects

To really change a vector of string literals to a vector of string objects, the following procedure will have to be followed:

• Create another empty vector, but this time, a vector of string objects.
• Copy each string literal from the vector of const-character-pointers, to the vector of string objects, by pushing.
• Destroy the old vector of literals.

The following code illustrates this:

The output is:

The line for the code that destroys the old vector is:

The content of the vector is destroyed, but not the vector name. However, the old vector name cannot be reused (in the same scope).

Conclusion

An array string literal and a constant pointer to character sequence literal are the same things underneath. An array string literal is an array literal of chars, ending with ‘’. A const-pointer-to-char-sequence literal sequence of consecutive characters delimited by double quotes, e.g., “abc”. ‘’ is implicit at the end of the const-pointer-to-char-sequence literal.

An array string literal or a const-pointer-to-char-sequence literal can be assigned to the identifier of a const-pointer-to-char-sequence, as illustrated in the following code segment:

There is no really need to convert a vector of array strings to a vector of string literals in double-quotes. It suffices to read each array string of the vector to the identifier of a const-pointer-to-char-sequence.

However, if a vector of string objects is really required from a vector of string literals, then the conversion should be done as follows:

• Create another empty vector, but this time, a vector of string objects.
• Copy each string literal from the vector of const character pointers to the vector of string objects by pushing.
• Destroy the old vector of literals.

Destroying a vector means destroying its content (elements), but not the name of the vector.