C++ Wie könnte ich richtig Array von Char * vordefiniert?

Question

ich es so mache:

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

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

aber ich benachrichtigt werden, dass es veraltet ist. Was ist besser?

Answer 1

Sie müssen entweder konst machen:

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

... oder nicht die konstanten Stringliterale:

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

Answer 2

Verwenden Sie const, um anzugeben, dass die Zeichenfolgen 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 auch automatisch bei der Kompilierung berechnet werden, um eine geringere Chance auf Fehler gibt es (danke für die Anregung zu Goz).

Answer 3

Neben dem Problem der für etwas anderes als ein konstanter Ausdruck mit Ihrem Array-Größe ...

Die Sache, die veraltet ist, ist die stille Umwandlung von String-Literalen zu char*. Dies wird verwendet, um in Ordnung sein:

char * hello = "hello"; 

Jetzt muss es sein:

char const* hello = "hello"; 

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

Answer 4

Lassen Sie 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 oben beschrieben zu tun, was ich versuchen. 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 5

+1 für Vlad.

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

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

"asdf" 

hat jetzt const char* geben, nicht char*. Und Zeichenfolgenliterale können in char* konvertiert werden, um etwas Kompatibilität mit den älteren Konventionen beizubehalten, wenn const nicht so streng war. Die Konvertierung eines Zeichenfolgenliterals in char* von ist jedoch veraltet, und Sie sollten sich nicht darauf verlassen.

Warum? String Literal ist ein Zeiger auf konstanten Speicher, deshalb muss es const char* sein.

Answer 6

Anders als alle anderen darauf hingewiesen haben, dass Const-String-Literale nichtkonstanten Zeichen-Zeigern zugewiesen sind und die Sonderzeichen argv und argc außerhalb der Parameterliste von main() deklarieren, gibt es ein zusätzliches Problem mit dieser Zeile hier:

char* argv[argc];

Sie nur ganzzahlige konstante Ausdrücke für Feldgrößen in C verwenden können ++; ein Integer-Konstantenausdruck ist eine literale Ganzzahl in der Quelle Ihres Programms (wie "5" oder "10"), ein Aufzählungswert (wie "rot" aus "Aufzählungsfarben {rot, grün, blau};"), eine Größe von Ausdruck oder ein int-Variable mit const deklariert:

// 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 Arrays variabler Länge C99-Stil zu implementieren, so dass Sie keine Beschwerde erhalten können, wenn Sie sie verwenden, aber sie immer noch am besten vermieden werden, wenn Sie wollen um tragbaren Code zu schreiben.