Thread: Converting C++ string to C style string

Code:

string lineread = "Hello"
char* cstr = lineread.c_str();

Gives an error invalid conversion from 'const char*' to 'char*' [-fpermissive]

I understand this has something to do with immutable vs mutable and that the solution, as the internet gurus say, is to make a copy. This is too Greek to me. Can someone actually add one or two lines of code to the above to make the conversion work?

Wait, why isn't cstr const? You're assigning a pointer to a location in memory, why do you need this to be non-const?

Edit : Also, why not just use strcpy?

Okay I added a const but the following code gives the same error on line 4:

Code:

// A simple tokenizer
string lineread = "Hello how are you"    
const char* cstr = lineread.c_str();
char* wordptr = strtok(cstr," ");

invalid conversion from 'const char*' to 'char*' [-fpermissive]

Originally Posted by Elkvis

you'll need to to use strcpy, because strtok requires a char*, not a const char*. is there a reason why you can't tokenize a string using just the tools provided by C++ for std::string?

Okay I made a copy and it worked:

Code:

// A simple tokenizer
string lineread = "Hello how are you"    
const char* cstr = lineread.c_str();
char* cstringcpy = NULL;
strcpy(cstringcpy,cstr);
char* wordptr = strtok(cstringcpy," ");

That is an absolutely crazy method to simply tokenize a C++ string and I do not wish to undergo five lines of code to do this ridiculously simple task.

Please could you direct me to a simpler direct C++ way? I stress the word simple, because I've seen other solutions online that really go off on a tangent.

And I know it's nitpicky but the thing is to now set pointers equal to nullptr in lieu of NULL.

Originally Posted by Vespasian

Please could you direct me to a simpler direct C++ way? I stress the word simple, because I've seen other solutions online that really go off on a tangent.

You can try Boost Tokenizer (Boost Tokenizer Overview - 1.36.0).

Alternatively, try std::string::find and std::string::substr.

Originally Posted by laserlight

I note that you did not allocate any space for the copy.

Excellent find!

I was just about to post a new thread asking why the tokenizer function returns a SIGSEGV error. So then I did:

Code:

char* tokenizer (string inputstream)
{
    char* cstringcpy;
    const char* cstr = inputstream.c_str();
    strcpy(cstringcpy,cstr);
    char* wordptr = (char*)malloc (50 * sizeof(char));
    wordptr = strtok(cstringcpy,"\t");
    return wordptr;
}

Even though I malloced wordptr, I STILL got a SIGSEGV error even though I passed wordptr on the heap.

Then I realised the thing that wordptr pointed to is in itself was not on the heap. So then I finally did a change on line 3 to allocate the COPY in memory:

Code:

char* tokenizer (string inputstream)
{
    char* cstringcpy = (char*)malloc (50 * sizeof(char));
    const char* cstr = inputstream.c_str();
    strcpy(cstringcpy,cstr);
    char* wordptr = (char*)malloc (50 * sizeof(char));
    wordptr = strtok(cstringcpy,"\t");
    return wordptr;
}

And I finally get no error :-) Is this why you pointed to the dangers of not assigning memory to the copy?

What laserlight is advising is called RAII, and it's one of the fundamental things to learn in C++.