converting const char to string isn't working [duplicate] - c++

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