Perché argc non è una costante?

int main( const int argc , const char[] const argv)

Poiché l' Effective C ++ Item # 3 afferma "Usa const ogni volta che è possibile", inizio a pensare "perché non rendere questi parametri 'costanti' const"?

C'è qualche scenario in cui il valore di argcviene modificato in un programma?

In questo caso, la storia è un fattore. Il C ha definito questi input come "non costanti" e la compatibilità con (una buona parte del) codice C esistente era uno degli obiettivi iniziali di C ++.

Alcune API UNIX, come getopt, effettivamente manipolano argv[], quindi non possono essere create anche constper questo motivo.

^{(A parte: è interessante notare che, sebbene getoptil prototipo di s suggerisca che non modificherà argv[]ma potrebbe modificare le stringhe a cui punta, la pagina man di Linux indica che getoptpermuta i suoi argomenti e sembra che sappiano che sono cattivi . La pagina man su Open Il gruppo non menziona questa permutazione.)}

Mettere constsu argce argvnon sarebbe comprare molto, e sarebbe invalidare qualche vecchia scuola pratiche, come ad esempio la programmazione:

// print out all the arguments:
while (--argc)
    std::cout << *++argv << std::endl;

Ho scritto programmi del genere in C e so di non essere solo. Ho copiato l'esempio da qualche parte .

Lo standard C (ISO / IEC 9899: 2011) dice:

5.1.2.2.1 Avvio del programma

¶1 Viene denominata la funzione chiamata all'avvio del programma main. L'implementazione non dichiara alcun prototipo per questa funzione. Deve essere definito con un tipo di ritorno int e senza parametri:

int main(void) { /* ... */ }

o con due parametri (qui indicati come argce argv, sebbene sia possibile utilizzare qualsiasi nome, poiché sono locali rispetto alla funzione in cui sono dichiarati):

int main(int argc, char *argv[]) { /* ... */ }

o equivalente; ¹⁰⁾ o in un altro modo definito dall'implementazione.

¶ 2 Se vengono dichiarati, i parametri della mainfunzione devono obbedire ai seguenti vincoli:

• Il valore di argcnon sarà negativo.
• argv[argc] deve essere un puntatore nullo.
• Se il valore di argcè maggiore di zero, i membri dell'array argv[0]tramite argv[argc-1]inclusivo conterranno puntatori a stringhe, a cui vengono forniti valori definiti dall'implementazione dall'ambiente host prima dell'avvio del programma. L'intento è fornire al programma le informazioni determinate prima dell'avvio del programma da altre parti dell'ambiente ospitato. Se l'ambiente host non è in grado di fornire stringhe con lettere sia in maiuscolo che in minuscolo, l'implementazione deve garantire che le stringhe vengano ricevute in minuscolo.
• Se il valore di argcè maggiore di zero, la stringa puntata da argv[0] rappresenta il nome del programma; argv[0][0]deve essere il carattere null se il nome del programma non è disponibile dall'ambiente host. Se il valore di argcè maggiore di uno, le stringhe puntate da argv[1]tramite argv[argc-1] rappresentano i parametri del programma.
• I parametri argce le argve le corde a cui punta la argvmatrice devono essere modificabili dal programma, e mantenere i loro valori dell'ultimo memorizzati tra all'avvio del programma e la terminazione del programma.

¹⁰⁾ Quindi, intpuò essere sostituito da un nome typedef definito come int, oppure il tipo di argvpuò essere scritto come char **argv, e così via.

Nota l'ultimo punto elenco. Dice che entrambi argce argvdovrebbero essere modificabili. Non devono essere modificati, ma possono essere modificati.

argcnormalmente non è una costante perché la firma della funzione per main()le date precedenti const.

Poiché argc è una variabile di stack, modificarla non influenzerà nient'altro che l'elaborazione della riga di comando.

Naturalmente sei libero di dichiararlo constse lo desideri.

Un livello superiore constsu un argomento formale non fa parte del tipo di funzione. Puoi aggiungerlo o rimuoverlo come preferisci: influisce solo su ciò che puoi fare con l'argomento nell'implementazione della funzione.

Quindi per argcte puoi aggiungere liberamente un file const.

Ma argvnon è possibile creare i dati del carattere constsenza modificare la firma della funzione. Ciò significa che non è quindi una delle mainfirme delle funzioni standard e non dovrà essere riconosciuta come mainfunzione. Quindi, non è una buona idea.

Una buona ragione per non utilizzare gli mainargomenti standard in programmi non giocattolo è che in Windows non sono in grado di rappresentare argomenti di programma effettivi come nomi di file con caratteri internazionali. Questo perché in Windows sono codificati per convenzione molto forte come Windows ANSI. In Windows è possibile implementare una funzione di accesso agli argomenti più portabile in termini di GetCommandLinefunzione API.

Riassumendo, nulla ti impedisce di aggiungere consta argc, ma l'utilità più utile constti argvdarebbe una funzione non standard main, molto probabilmente non riconosciuta come tale. Fortunatamente (in modo ironico) ci sono buone ragioni per non usare gli mainargomenti standard per il codice serio portatile. Molto semplicemente, per la pratica supportano solo il vecchio ASCII, con solo lettere dell'alfabeto inglese.

La firma di mainè un po 'un manufatto storico da C. Storicamente Cnon ha avuto const.

Tuttavia, puoi dichiarare il tuo parametro constpoiché gli effetti di const sono solo in fase di compilazione.

Perché argcè una variabile locale (e, in C ++, non un riferimento o qualcosa del genere), e poiché la posizione speciale di mainsignifica che gli shenanigans della compatibilità con le versioni precedenti le garantiscono un enorme margine di manovra senza motivo convincente per forzare le applicazioni a renderlo const.

main() {}

int main() {}

main() { return 0; }

main(int argc, char* argv[]) { return 0; }

int main(const int argc, const char** argv) { /* no return*/ }

queste e molte altre variazioni verranno compilate su un'ampia gamma di compilatori C e C ++.

Quindi alla fine non è che argc non sia const, solo che non deve esserlo, ma può essere se vuoi che lo sia.

http://ideone.com/FKldHF , esempio C:

main(const int argc, const char* argv[]) { return 0; }

http://ideone.com/m1qc9c , esempio C ++

main(const int argc) {}

A parte le ragioni storiche, una buona ragione per mantenere argc e argv non constè che l'implementazione del compilatore non sa cosa farai con gli argomenti di main, sa solo che deve darti quegli argomenti.

Quando si definiscono le proprie funzioni e i prototipi associati, si sa quali parametri è possibile creare conste quali verranno modificati dalla funzione.

Portato all'estremo, potresti dichiarare che tutti i parametri di tutte le funzioni dovrebbero essere dichiarati const, e quindi se avessi un motivo per cambiarli (es. Decrementare un indice per cercare in un array), dovresti rendere non constvariabili locali e copia i constvalori degli argomenti in quelle variabili. Ciò rende il lavoro impegnato e LOC extra senza alcun reale vantaggio. Un analizzatore statico decente rileverà se non stai modificando il valore di un argomento e ti consiglierà di creare il parametro const.