Having char * and its int length how to deep copy it into stringstream?
Use std::stringstream::write(s, length);.
Note if the char* is null terminated operator<<() can be used instead and the length does not need to be supplied:
std::stringstream s;
const char* buf = "hello";
s << buf;
Shouldn't write fullfil your requirements?
http://www.cplusplus.com/reference/ostream/ostream/write/
You should read the doc and this one
For any function that is declared to take a char* output parameter, is there a way to specify the "char" part of s std::string as the function's output?
I began with:
// EDIT: ADDED THESE TWO LINES FOR CLARITY
sprintf(buf, "top -n 1 -p %s" , commaSeparatedListOfPIDs.c_str() );
fp = popen(buf, "r");
std::string replyStr;
char reply[100];
rc = scanf( fp, "%s", reply );
replyStr = reply;
but that seems a bit, well, clumsy.
So, is there a way to say:
rc = scanf( fp, "%s", &replyStr.c_str() );
or something like that?
Thanks!
Yes this is possible:
std::string replyStr(100, '\0');
//Requires C++11 (to guarantee that strings hold their characters
//in contiguous memory), and some way to ensure that the string in the file
//is less than 100 characters long.
rc = fscanf( fp, "%s", &reply.front() );
replyStr.erase(replyStr.find('\0'));
The second condition is very difficult to satisfy, and if it is not satisfied this program has undefined behaviour.
Up until c++0x, &str[0] wasn't required to return a pointer to contiguous storage. The conventional way would be to use std::vector, which is guaranteed to have contiguous storage even before c++0x:
std::vector<char> reply(100);
rc = scanf(fp, "%s", &reply[0]);
In c++0x, however, std::string is also guaranteed to work instead of std::vector.
If you want to use strings, why not use the C++ way of i/o as well? Take a look at this link
std::string replyStr(reply); will make a string of your char array.
EDIT:
but... that doesn't do anything different.
Use the c++ style in/out to not have to use char*.
cin >> replyStr; will get the next string until whitespace.
getline(cin,reply); will set the string to an entire line of input
The char* that comes from std::String is only valid as long as the string is valid. If the std::String goes out of scope then the it is no longer a valid char pointer.
const char* bar;
{
std::String foo = "Hello";
bar = foo.c_str();
printf("%s", bar); //SAFE since the String foo is still in scope
}
printf("%s", bar); //UNSAFE String foo is no longer in scope
As long as the std::String variable exists you can use the const char* if it goes out of scope the memory is released and the const char* pointer becomes a dangling pointer that is no longer safe to use.
if you need it to exist after the std::String foo has gone out of scope then you must copy the string into a char*
char bar[100];
{
std::String foo = "Hello";
strncpy(bar, foo.c_str(), 100);
bar[100] = '\0'; //make sure string is null-terminated
printf("%s", bar); //SAFE
}
printf("%s", bar); //SAFE even though the std::String has gone out of scope.
If your string is inside a function it will not exist when the function returns.
I want to convert a std::string into a char* or char[] data type.
std::string str = "string";
char* chr = str;
Results in: “error: cannot convert ‘std::string’ to ‘char’ ...”.
What methods are there available to do this?
It won't automatically convert (thank god). You'll have to use the method c_str() to get the C string version.
std::string str = "string";
const char *cstr = str.c_str();
Note that it returns a const char *; you aren't allowed to change the C-style string returned by c_str(). If you want to process it you'll have to copy it first:
std::string str = "string";
char *cstr = new char[str.length() + 1];
strcpy(cstr, str.c_str());
// do stuff
delete [] cstr;
Or in modern C++:
std::vector<char> cstr(str.c_str(), str.c_str() + str.size() + 1);
More details here, and here but you can use
string str = "some string" ;
char *cstr = &str[0];
As of C++11, you can also use the str.data() member function, which returns char *
string str = "some string" ;
char *cstr = str.data();
If I'd need a mutable raw copy of a c++'s string contents, then I'd do this:
std::string str = "string";
char* chr = strdup(str.c_str());
and later:
free(chr);
So why don't I fiddle with std::vector or new[] like anyone else? Because when I need a mutable C-style raw char* string, then because I want to call C code which changes the string and C code deallocates stuff with free() and allocates with malloc() (strdup uses malloc). So if I pass my raw string to some function X written in C it might have a constraint on it's argument that it has to allocated on the heap (for example if the function might want to call realloc on the parameter). But it is highly unlikely that it would expect an argument allocated with (some user-redefined) new[]!
(This answer applies to C++98 only.)
Please, don't use a raw char*.
std::string str = "string";
std::vector<char> chars(str.c_str(), str.c_str() + str.size() + 1u);
// use &chars[0] as a char*
If you just want a C-style string representing the same content:
char const* ca = str.c_str();
If you want a C-style string with new contents, one way (given that you don't know the string size at compile-time) is dynamic allocation:
char* ca = new char[str.size()+1];
std::copy(str.begin(), str.end(), ca);
ca[str.size()] = '\0';
Don't forget to delete[] it later.
If you want a statically-allocated, limited-length array instead:
size_t const MAX = 80; // maximum number of chars
char ca[MAX] = {};
std::copy(str.begin(), (str.size() >= MAX ? str.begin() + MAX : str.end()), ca);
std::string doesn't implicitly convert to these types for the simple reason that needing to do this is usually a design smell. Make sure that you really need it.
If you definitely need a char*, the best way is probably:
vector<char> v(str.begin(), str.end());
char* ca = &v[0]; // pointer to start of vector
This would be better as a comment on bobobobo's answer, but I don't have the rep for that. It accomplishes the same thing but with better practices.
Although the other answers are useful, if you ever need to convert std::string to char* explicitly without const, const_cast is your friend.
std::string str = "string";
char* chr = const_cast<char*>(str.c_str());
Note that this will not give you a copy of the data; it will give you a pointer to the string. Thus, if you modify an element of chr, you'll modify str.
Assuming you just need a C-style string to pass as input:
std::string str = "string";
const char* chr = str.c_str();
To obtain a const char * from an std::string use the c_str() member function :
std::string str = "string";
const char* chr = str.c_str();
To obtain a non-const char * from an std::string you can use the data() member function which returns a non-const pointer since C++17 :
std::string str = "string";
char* chr = str.data();
For older versions of the language, you can use range construction to copy the string into a vector from which a non-const pointer can be obtained :
std::string str = "string";
std::vector<char> str_copy(str.c_str(), str.c_str() + str.size() + 1);
char* chr = str_copy.data();
But beware that this won't let you modify the string contained in str, only the copy's data can be changed this way. Note that it's specially important in older versions of the language to use c_str() here because back then std::string wasn't guaranteed to be null terminated until c_str() was called.
To be strictly pedantic, you cannot "convert a std::string into a char* or char[] data type."
As the other answers have shown, you can copy the content of the std::string to a char array, or make a const char* to the content of the std::string so that you can access it in a "C style".
If you're trying to change the content of the std::string, the std::string type has all of the methods to do anything you could possibly need to do to it.
If you're trying to pass it to some function which takes a char*, there's std::string::c_str().
Here is one more robust version from Protocol Buffer
char* string_as_array(string* str)
{
return str->empty() ? NULL : &*str->begin();
}
// test codes
std::string mystr("you are here");
char* pstr = string_as_array(&mystr);
cout << pstr << endl; // you are here
Conversion in OOP style
converter.hpp
class StringConverter {
public: static char * strToChar(std::string str);
};
converter.cpp
char * StringConverter::strToChar(std::string str)
{
return (char*)str.c_str();
}
usage
StringConverter::strToChar("converted string")
For completeness' sake, don't forget std::string::copy().
std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];
str.copy(chrs, MAX);
std::string::copy() doesn't NUL terminate. If you need to ensure a NUL terminator for use in C string functions:
std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];
memset(chrs, '\0', MAX);
str.copy(chrs, MAX-1);
You can make it using iterator.
std::string str = "string";
std::string::iterator p=str.begin();
char* chr = &(*p);
Good luck.
A safe version of orlp's char* answer using unique_ptr:
std::string str = "string";
auto cstr = std::make_unique<char[]>(str.length() + 1);
strcpy(cstr.get(), str.c_str());
char* result = strcpy((char*)malloc(str.length()+1), str.c_str());
Alternatively , you can use vectors to get a writable char* as demonstrated below;
//this handles memory manipulations and is more convenient
string str;
vector <char> writable (str.begin (), str.end) ;
writable .push_back ('\0');
char* cstring = &writable[0] //or &*writable.begin ()
//Goodluck
This will also work
std::string s;
std::cout<<"Enter the String";
std::getline(std::cin, s);
char *a=new char[s.size()+1];
a[s.size()]=0;
memcpy(a,s.c_str(),s.size());
std::cout<<a;
No body ever mentioned sprintf?
std::string s;
char * c;
sprintf(c, "%s", s.c_str());
I can't do this in C++
string temp = "123";
int t = atoi(temp);
why????
That is because atoi is expecting a raw const char* pointer. Since there is no implicit conversion from std::string to const char* you get a compiler error. Use c_str() method of std::string to get a c-style const char* for a std::string object. BTW, in C++ you can use streams to do this conversion instead of using these C-style APIs.
atoi(temp.c_str())
See these questions:
C atoi() string to int: Points out that atoi() is deprecated.
Why doesn't C++ reimplement C standard functions with C++ elements style?: Gives alternate ways to do what you've listed above.
Well, you passed a std::string (presumably) to atoi, which takes a const char*. Try:
atoi(temp.c_str());
which was previously mentioned. Instead, you could use boost's lexical_cast:
std::string temp = "123";
try {
int foo = boost::lexical_cast<int>(temp);
} catch (boost::bad_lexical_cast e) {
//handle error here
}
You could wrap the try/catch into a template function that handles the exceptions in the event that you do not already have exception handling in place.
std::string is not the same as a character pointer (like in C).
int i = 12345;
std::string s;
std::stringstream sstream;
sstream << i;
sstream >> s;
Is there a simple way of creating a std::string out of an const char[] ?
I mean something simpler then:
std::stringstream stream;
stream << const_char;
std::string string = stream.str();
std::string has multiple constructors, one of which is string( const char* str );.
You can use it like this:
std::string myString(const_char);
You could also use assignment, if you need to set the value at some time later than when the variable is declared:
myString = const_char;
std::string has a constructor that takes a const char*, so you can just do:
const char* charArray;
std::string str(charArray);
std::string str = const_char;
Just use the std::string constructor. You can pass it a char*:
char* charArray = "My String";
std::string stdstr( charArray );