如何将类型从const char *转换为char *

Question

I'm trying create simple application in C++. This application has to read from file and displays data. I've written function:

std::vector <AndroidApplication> AndroidApplication::getAllApp(){
    std::vector<AndroidApplication> allApp;
    std::fstream f;

    f.open("freeApps.txt");
    std::string line;
    if(f.is_open()){
        while(getline(f, line)) {
            std::string myLine = "";
            char * line2 = line.c_str();
            myLine = strtok(line2,"\t");

            AndroidApplication * tmpApp = new AndroidApplication(myLine[1], myLine[2], myLine[4]);
            tmpApp->Developer = myLine[0];
            tmpApp->Pop = myLine[3];
            tmpApp->Type = myLine[5];
            allApp->pushBack(tmpApp);
        }
    }
    return allApp;
}

It throws me an error in line:

myLine = strtok(line2,"\t");

An error:

cannot convert from 'const char *' to 'char *'

Could you tell me how can I deal with it?

Answer 1

Don't use strtok . std::string has its own functions for string-scanning, eg, find .

Answer 2

To use strtok, you'll need a writeable copy of the string. c_str() returns a read-only pointer.

Answer 3

You can't just "convert it" and forget about it. The pointer you get from .c_str() is to a read-only buffer . You need to copy it into a new buffer to work with: ideally, by avoiding using antiquated functions like strtok in the first place.

(I'm not quite sure what you're doing with that tokenisation, actually; you're just indexing into characters in the once-tokenised string, not indexing tokens.)

You're also confusing dynamic and automatic storage.

std::vector<AndroidApplication> AndroidApplication::getAllApp()
{

    std::vector<AndroidApplication> allApp;

    // Your use of fstreams can be simplified
    std::fstream f("freeApps.txt");

    if (!f.is_open())
       return allApp;

    std::string line;
    while (getline(f, line)) {

        // This is how you tokenise a string in C++
        std::istringstream split(line);
        std::vector<std::string> tokens;
        for (std::string each;
             std::getline(split, each, '\t');
             tokens.push_back(each));

        // No need for dynamic allocation here,
        // and I'm assuming you wanted tokens ("words"), not characters.
        AndroidApplication tmpApp(tokens[1], tokens[2], tokens[4]);
        tmpApp.Developer = tokens[0];
        tmpApp.Pop = tokens[3];
        tmpApp.Type = tokens[5];

        // The vector contains objects, not pointers
        allApp.push_back(tmpApp);
    }

    return allApp;
}

Answer 4

I suspect the error is actually on the previous line,

char * line2 = line.c_str();

This is because c_str() gives a read-only pointer to the string contents. There is no standard way to get a modifiable C-style string from a C++ string.

The easiest option to read space-separated words from a string (assuming that's what you're tying to do) is to use a string stream:

std::vector<std::string> words;
std::istringstream stream(line);
std::copy(std::istream_iterator<std::string>(stream), 
          std::istream_iterator<std::string>(),
          back_inserter(words));

If you really want to use strtok , then you'll need a writable copy of the string, with a C-style terminator; one way to do this is to copy it into a vector:

std::vector<char> writable(line.c_str(), line.c_str() + line.length() + 1);
std::vector<char *> words;
while (char * word = strtok(words.empty() ? &writable[0] : NULL, " ")) {
    words.push_back(word);
}

Bear in mind that strtok is quite difficult to use correctly; you need to call it once for each token, not once to create an array of tokens, and make sure nothing else (such as another thread) calls it until you've finished with the string. I'm not sure that my code is entirely correct; I haven't tried to use this particular form of evil in a long time.

Answer 5

Since you asked for it:

Theoretically you could use const_cast<char*>(line.c_str()) to get a char* . However giving the result of this to strtok (which modifies its parameter) is IIRC not valid c++ (you may cast away constness, but you may not modify a const object). So it might work for your specific platform/compiler or not (and even if it works it might break anytime).

The other way is to create a copy, which is filled with the contents of the string (and modifyable):

std::vector<char> tmp_str(line.begin(), line.end());
myLine = strtok(&tmp_str[0],"\t");

Of course as the other answers tell you in great detail, you really should avoid using functions like strtok in c++ in favour of functionality working directly on std::string (at least unless you have a firm grasp on c++, high performance requirements and know that using the c-api function is faster in your specific case (through profiling)).