How can I create a string from a single character?

Question

I have a single char value, and I need to cast/convert it to a std::string. How can I do this?

I know how to go the opposite way, to retrieve a char from a std::string object: you just need to index the string at the appropriate location. For example: str[0] will retrieve the first character in the string.

But how do I go the other way? I want something like:

char c = 34;
std::string s(c);

…but this doesn't work (the string is always empty).

Answer 1

You can use any/all of the following to create a std::string from a single character:

• std::string s(1, c);
  
  std::cout << s << std::endl;
  

• std::string s{c};
  
  std::cout << s << std::endl;
  

• std::string s;
  s.push_back(c);
  
  std::cout << s << std::endl;
  

Answer 2

std::string has a constructor that takes a number and a character. The character will repeat for the given number of times. Thus, you should use:

std::string str(1, ch);

Answer 3

You can try stringstream. An example is below:

#include <sstream>
#include <string>

std::stringstream ss;
std::string target;
char mychar = 'a';
ss << mychar;
ss >> target;

Answer 4

This solution will work regardless of the number of char variables you have:

char c1 = 'z';
char c2 = 'w';
std::string s1{c1};
std::string s12{c1, c2};

Answer 5

You still can use the string constructor taking two iterators:

char c = 'x';
std::string(&c, &c + 1);

Update:

Good question James and GMan. Just searched freely downloadable "The New C Standard" by Derek M. Jones for "pointer past" and my first hit was:

If the expression P points to an element of an array object and the expression Q points to the last element of the same array object, the pointer expression Q+1 compares greater than P... even though Q+1 does not point to an element of the array object...

On segmented architectures incrementing a pointer past the end of a segment causes the address to wrap segmented architecture around to the beginning of that segment (usually address zero). If an array is allocated within such a segment, either the implementation must ensure that there is room after the array for there to be a one past the end address, or it uses some other implementation technique to handle this case (e.g., if the segment used is part of a pointer’s representation, a special one past the end segment value might be assigned)...

The C relational operator model enables pointers to objects to be treated in the same way as indexes into array objects. Relational comparisons between indexes into two different array objects (that are not both subobjects of a larger object) rarely have any meaning and the standard does not define such support for pointers. Some applications do need to make use of information on the relative locations of different objects in storage. However, this usage was not considered to be of sufficient general utility for the Committee to specify a model defining the behavior...

Most implementations perform no checks prior to any operation on values having pointer type. Most processors use the same instructions for performing relational comparisons involving pointer types as they use for arithmetic types. For processors that use a segmented memory architecture, a pointer value is often represented using two components, a segment number and an offset within that segment. A consequence of this representation is that there are many benefits in allocating storage for objects such that it fits within a single segment (i.e., storage for an object does not span a segment boundary). One benefit is an optimization involving the generated machine code for some of the relational operators, which only needs to check the segment offset component. This can lead to the situation where p >= q is false but p > q is true, when p and q point to different objects.

Answer 6

This works on gcc C++ 4.9.2 (http://ideone.com/f3qhTe)

#include <iostream>
using namespace std;

int main() {
    // your code goes here
    std::string test;

    test = (char) 76;
    test += (char) 77;
    test += (char) 78;
    test += (char) 79;

    std::cout << "test contains: " << test << std::endl;
    return 0;
}

Answer 7

In most cases you can just use {ch}.

std::string s = {ch}; // works
infix.push({ch}); // works

This utilises the std::initializer_list constructor of std::string.

Answer 8

I don't know Java that much, but the closest in C++ to your ch + "" is probably std::string{} + ch. Note, that "" is not a std::string, and you cannot overload operators for fundamental types, hence ch+"" cannot possibly result in a std::string.

However, std::string{} + ch involves 2 strings. I suppose the temporary can be optimized away by the compiler, though to construct a string from one character this is perfectly fine: std::string(1,ch).

For other constructors of std::string I refer you to https://en.cppreference.com/w/cpp/string/basic_string/basic_string.

Answer 9

You can set a string equal to a char.

#include <iostream>
#include <string>

using namespace std;

int main()
{
   string s;
   char one = '1';
   char two = '2';
   s = one;
   s += two;
   cout << s << endl;
}

./test
12