c ++ Wie könnte ich Array von char * richtig vorgegeben?

Question

Ich bin es auf diese Weise tun:

int argc = 9;
char* argv[argc];

argv[0] = "c:/prog.exe";

aber ich bemerkt, dass es veraltet ist. Was ist besser Weg?

Answer 1

Sie müssen entweder machen const:

const char *argv[] = { "Arg1", "Arg2", "..." };

... oder auch nicht verwenden, die konstanten Stringliterale:

int argc = 9;
char* argv[argc];
char prog_name[] = "c:/prog.exe";
argv[0] = prog_name;

Answer 2

Neben dem Problem von etwas anderes als ein konstanten Ausdruck für Array-Größe mit ...

Die Sache, die veraltet ist, ist die stille Gießen von Stringliterale zu char*. Dies wird verwendet, um in Ordnung sein:

char * hello = "hello";

Jetzt muss es sein:

char const* hello = "hello";

Dieses deprecation ist eigentlich in einem Anhang in C ++ 03.

Answer 3

Lassen Sie uns analysieren, was machst du hier:

// Create an int with value 9.
int argc = 9;

// Create an array of char* pointers of size 9
char* argv[argc];

// Assign the the first pointer to the global data string "C:\prog.exe"
argv[0] = "c:/prog.exe";

Meine Vermutung ist, dass Sie nicht versuchen zu tun, was ich oben beschrieben. Probieren Sie etwas wie folgt aus:

// create an array of characters
char argv[] = "C:/prog.exe";

// argc in now the length of the string
int argc = sizeof argv;

-oder -

// create an array of strings
char* argv[] = {"C:/prog.exe"};
// argc is now the number of strings in the array
int argc = 1;

Answer 4

Versuchen const mit, um anzuzeigen, dass die Saiten nicht geändert werden.

const char* argv[] = { "c:/prog.exe" };
const int argc = sizeof(argv) / sizeof(argv[0]);

int main()
{
    for(int i = 0; i < argc; ++i)
    {
        ::printf("%s\n", argv[i]);
    }
}

Hier argc wird automatisch auch so bei der Kompilierung berechnet werden gibt es eine geringere Chance auf Fehler (dank Goz für den Vorschlag).

Answer 5

1 für Vlad.

Einige weitere Erklärung von mir auf, was passiert hier:

Sie erhalten die "veraltet" Warnung, weil ein solcher Code:

"asdf"

hat jetzt Typ const char*, nicht char*. Und Stringliterale können char* umgewandelt werden, eine gewisse Kompatibilität mit den älteren Konventionen zu halten, wenn const nicht so streng war. Aber Umwandlung eines Stringliteral zu char* von const char* ist veraltet und Sie sollten nicht auf sie verlassen.

Warum? Stringliteral ist ein Zeiger auf konstante Erinnerung, deshalb braucht es const char* zu sein.

Answer 6

Andere als das, was alle anderen über const Stringliterale hingewiesen hat zu nicht-const char Zeiger und die Seltsamkeit zu erklären argv und argc außerhalb von main () 's Parameterliste, dort zugewiesen wird, ist ein zusätzliches Problem mit dieser Linie hier :

char* argv[argc];

Sie können nur ganzzahlige Konstante Ausdrücke für Feldgrößen in C ++ verwenden; ein ganze Zahl konstanter Ausdruck eine wörtliche ganze Zahl in der Quelle des Programms (wie „5“ oder „10“) ist, ein Aufzählung Wert (wie „red“ von „ENUM Farben {rot, grün, blau};“), ein sizeof Ausdruck oder eine int Variable deklariert mit const:

// can hold 30 ints
int myarray1[30];

// can hold as many ints as myarray1 is wide in bytes
int myarray2[sizeof(myarray1)];

// C++ does not support variable-length arrays like C99 does, so if an int
// variable is used to specify array size, it must be marked const:
const int myarray3_size = 42;
int myarray3[myarray3];

Viele C ++ Compiler implementieren C99-Stil Arrays variabler Länge, so dass Sie keine Beschwerde erhalten können, wenn Sie sie verwenden, aber sie sind immer noch am besten vermieden werden, wenn Sie portablen Code schreiben möchten.