Por que argc não é uma constante?

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

Como Effective C ++ Item # 3 afirma "Use const sempre que possível", eu começo a pensar "por que não fazer esses parâmetros 'constantes' const"?

Existe algum cenário em que o valor de argcé modificado em um programa?

Nesse caso, a história é um fator. C definiu essas entradas como "não constantes" e a compatibilidade com (uma boa parte do) código C existente era um objetivo inicial do C ++.

Algumas APIs do UNIX, como getopt, realmente manipulam argv[], portanto, não podem ser feitas constpor esse motivo também.

^{(À parte: Curiosamente, embora getopto protótipo de sugira que ele não irá modificar, argv[]mas pode modificar as strings apontadas, a página do manual do Linux indica que getoptpermuta seus argumentos, e parece que eles sabem que estão sendo malcriados . A página do manual no Open O grupo não menciona esta permutação.)}

Colocando constem argce argvnão comprar muito, e seria invalidar alguns old-school práticas, tais como a programação:

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

Escrevi esses programas em C e sei que não estou sozinho. Copiei o exemplo de algum lugar .

O padrão C (ISO / IEC 9899: 2011) diz:

5.1.2.2.1 Inicialização do programa

* 1 A função chamada na inicialização do programa é nomeada main. A implementação não declara nenhum protótipo para esta função. Deve ser definido com um tipo de retorno de int e sem parâmetros:

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

ou com dois parâmetros (referidos aqui como argce argv, embora quaisquer nomes possam ser usados, pois são locais para a função na qual são declarados):

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

ou equivalente; ¹⁰⁾ ou de alguma outra maneira definida pela implementação.

§2 Se forem declarados, os parâmetros da mainfunção devem obedecer às seguintes restrições:

• O valor de argcdeve ser não negativo.
• argv[argc] deve ser um ponteiro nulo.
• Se o valor de argcfor maior que zero, os membros da matriz argv[0]até argv[argc-1]inclusive devem conter ponteiros para strings, que recebem valores definidos pela implementação pelo ambiente host antes da inicialização do programa. A intenção é fornecer ao programa as informações determinadas antes da inicialização do programa de outro local no ambiente hospedado. Se o ambiente host não for capaz de fornecer strings com letras maiúsculas e minúsculas, a implementação deve garantir que as strings sejam recebidas em letras minúsculas.
• Se o valor de argcfor maior que zero, a string apontada por argv[0] representa o nome do programa; argv[0][0]deve ser o caractere nulo se o nome do programa não estiver disponível no ambiente do host. Se o valor de argcfor maior que um, as strings apontadas por argv[1]através argv[argc-1] representam os parâmetros do programa.
• Os parâmetros argce argve as cordas apontado pela argvmatriz deve ser modificáveis pelo programa, e mantêm seus valores última armazenados entre inicialização do programa e encerramento do programa.

¹⁰⁾ Assim, intpode ser substituído por um nome de typedef definido como int, ou o tipo de argvpode ser escrito como char **argv, e assim por diante.

Observe o último marcador. Diz que ambos argce argvdevem ser modificáveis. Eles não precisam ser modificados, mas podem ser modificados.

argcnormalmente não é uma constante porque a assinatura da função para main()datas anteriores const.

Visto que argc é uma variável de pilha, alterá-lo não afetará nada além do seu próprio processamento de linha de comando.

Você é, naturalmente, livre para declará-lo, constse quiser.

Um nível superior constem um argumento formal não faz parte do tipo de função. Você pode adicioná-lo ou removê-lo como quiser: isso afeta apenas o que você pode fazer com o argumento na implementação da função.

Portanto, argcvocê pode adicionar livremente um const.

Mas para argvvocê não pode fazer os dados de caractere constsem, portanto, alterar a assinatura da função. O que significa que não é uma das mainassinaturas de função padrão e não terá que ser reconhecida como uma mainfunção. Portanto, não é uma boa ideia.

Um bom motivo para não usar os mainargumentos padrão em programas que não sejam de brinquedo é que no Windows eles não podem representar argumentos de programa reais, como nomes de arquivo com caracteres internacionais. Isso ocorre porque no Windows eles são codificados por convenção muito forte como Windows ANSI. No Windows, você pode implementar algum recurso de acesso de argumento mais portátil em termos da GetCommandLinefunção API.

Resumindo, nada impede que você adicione consta argc, mas a maior utilidade constem argvforneceria uma mainfunção não padrão , muito provavelmente não reconhecida como tal. Felizmente (de uma forma irônica), há boas razões para não usar os mainargumentos padrão para código sério portátil. Simplesmente, para a prática, eles suportam apenas ASCII antigo, com apenas letras do alfabeto inglês.

A assinatura de mainé uma espécie de artefato histórico de C. Historicamente C, não const.

No entanto, você pode declarar seu parâmetro, constpois os efeitos de const são apenas em tempo de compilação.

Porque argcé uma variável local (e, em C ++, não é uma referência ou algo assim), e porque o lugar especial de mainsignifica que as travessuras de compatibilidade com versões anteriores garantem a ele uma grande margem de manobra sem nenhuma razão convincente para forçar os aplicativos a torná-lo constante.

main() {}

int main() {}

main() { return 0; }

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

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

essas e muitas outras variações serão compiladas em uma ampla variedade de compiladores C e C ++.

Portanto, em última análise, não é que argc não seja const, apenas que não precisa ser, mas pode ser, se você quiser.

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

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

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

main(const int argc) {}

Além das razões históricas, uma boa razão para manter argc e argv non- consté que a implementação do compilador não sabe o que você vai fazer com os argumentos de main, ela apenas sabe que deve fornecer esses argumentos.

Quando você está definindo suas próprias funções e protótipos associados, você sabe quais parâmetros pode fazer conste quais sua função irá modificar.

Levado ao extremo, você poderia declarar que todos os parâmetros para todas as funções deveriam ser declarados const, e então se você tivesse uma razão para alterá-los (por exemplo, diminuir um índice para pesquisar em um array), você teria que fazer não constvariáveis locais e copie os constvalores dos argumentos nessas variáveis. Isso torna o trabalho agitado e LOC extra sem nenhum benefício real. Um analisador estático decente pegará se você não estiver modificando o valor de um argumento e recomendará que você faça o parâmetro const.