在argv主参数中传递const char

Question

I have the following:

int main(int argc, char *argv[])
{    
    char *INPUTFILE_DATABASE = "";
    strcpy(INPUTFILE_DATABASE, argv[1]);    
    if(INPUTFILE_DATABASE[0]=='\0')
    {
        cout << "No input file given" << endl;
        INPUTFILE_DATABASE="File_name.csv";
    }
    cout << "Input file: " << INPUTFILE_DATABASE << endl;

    return 0;

when I compile, I receive:

warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]
  char *INPUTFILE_DATABASE = "";

When I make char *INPUTFILE_DATABASE as const char *INPUTFILE_DATABASE I cannot change it anymore, of course not. What am I doing wrong? Or is my motiviation not doable in general in this way?

Finally, I only want to allow to change the input file name but when no file name is given, a standard file name shall be used.

Answer 1

You never could change it. It's just that, thanks to old C rules, it looked like you could. The change in the rules (deprecation in C++98; actually this is illegal since C++11 and won't compile) is to better remind you of that.

To change the string, copy it to something you own, ideally using a std::string , particularly since your grasp of C-strings doesn't appear to be terribly strong (you have a zero-length string you're trying to copy a potentially-non-zero-length string on top of!).

In fact, I wouldn't copy anything, but re-arrange your logic to conditionally initialise INPUTFILE_DATABASE with something that is still an original constant string, like this:

// Use argv[1] if given and non-empty, otherwise a default path
const char* INPUTFILE_DATABASE = (
   argc > 1 && argv[1][0] != '\0'
   ? argv[1]
   : "File_name.csv"
);

Answer 2

Yes, you shouldn't do this. Instead of this:

char *INPUTFILE_DATABASE = "";

You should do something such as

char INPUTFILE_DATABASE[32]; // or another size that is sufficent

What happens when you do char *INPUTFILE_DATABASE = ""; is that your char* will point to a position that is made to hold just "" (so probably that's just going to be a byte of value 0 somewhere in the program's binary). You can't write to there.

Also, since this is C++, I would recommend:

std::string INPUTFILE_DATABASE = argv[1];

And instead of if(INPUTFILE_DATABASE[0]=='\\0') you could do if (!INPUTFILE_DATABASE.size())

Answer 3

You can use std::string which manages the internal char buffer for you. As an example,

#include <string>

std::string INPUTFILE_DATABASE;

if (argc == 1)
   INPUTFILE_DATABASE = "File_name.csv";
else
   INPUTFILE_DATABASE = argv[1];

Answer 4

那就不应该那么复杂了：

char const* INPUTFILE_DATABASE = argc > 1 ? argv[1] : "File_name.csv";

Answer 5

You shouldn't modify this string either way, making it a char const * prevents you from making a bug.

First of all: don't do this, just use std::string instead. If helps you a lot in reducing the amounts of stupid bugs that appear with C-style strings.

To come back to your issue:

auto i = std::make_unique<char[]>(512); // or more? (Could be calculated at runtime)
std::strcpy(i.get(), argv[1]);
if (i[0]=='\0')
    {
        cout << "No input file given" << endl;
        std::strcpy(i.get(), "filename.csv");
    }
cout << "Input file: " << i.get() << std::endl;

Off course, working directly with char* requires you to know the amount of characters. As mentioned before, std:: string makes things easier:

auto i = std::string(argc[1]);
if (i.empty())
    {
        cout << "No input file given" << endl;
        i = "filename.csv";
    }
cout << "Input file: " << i << std::endl;

For this specific case, std::string_view should also work.

Note that Lightness Races in Orbit posted yet another variant that doesn't require you to potentially allocate memory for this specific case using just char const *