Por que o argumento principal do C / C ++ é declarado como "char * argv []" em vez de apenas "char * argv"?

Por que é argvdeclarado como "um ponteiro para apontar para o primeiro índice da matriz", em vez de apenas ser "um ponteiro para o primeiro índice da matriz" ( char* argv)?

Por que a noção de "ponteiro para ponteiro" é necessária aqui?

Argv é basicamente assim:

À esquerda, está o argumento em si - o que é realmente passado como argumento para main. Que contém o endereço de uma matriz de ponteiros. Cada um desses pontos aponta para algum lugar na memória que contém o texto do argumento correspondente que foi passado na linha de comando. Então, no final dessa matriz, é garantido que seja um ponteiro nulo.

Observe que o armazenamento real dos argumentos individuais é pelo menos potencialmente alocado separadamente um do outro, portanto, seus endereços na memória podem ser organizados de maneira bastante aleatória (mas, dependendo de como as coisas são escritas, eles também podem estar em um único bloco contíguo de memória - você simplesmente não sabe e não deve se importar).

Porque é isso que o sistema operacional fornece :-)

Sua pergunta é um pouco de inversão de frango / ovo. O problema não é escolher o que você deseja em C ++, o problema é como você diz em C ++ o que o sistema operacional está fornecendo.

O Unix passa uma matriz de "strings", cada uma sendo um argumento de comando. No C / C ++, uma string é um "char *", portanto, uma matriz de strings é char * argv [] ou char ** argv, de acordo com o gosto.

Primeiro, como uma declaração de parâmetro, char **argvé o mesmo que char *argv[]; ambos implicam um ponteiro para (uma matriz ou conjunto de um ou mais possíveis) ponteiros para seqüências de caracteres.

Em seguida, se você tiver apenas "ponteiro para char" - por exemplo, apenas char *-, para acessar o enésimo item, precisará escanear os primeiros itens n-1 para encontrar o início do enésimo item. (E isso também imporia o requisito de que cada uma das seqüências de caracteres seja armazenada contiguamente.)

Com a matriz de ponteiros, você pode indexar diretamente o enésimo item - portanto (embora não seja estritamente necessário - assumindo que as strings são contíguas), geralmente é muito mais conveniente.

Ilustrar:

./program olá mundo

argc = 3
argv[0] --> "./program\0"
argv[1] --> "hello\0"
argv[2] --> "world\0"

É possível que, em uma matriz de caracteres fornecida pelo sistema operacional:

            "./program\0hello\0world\0"
argv[0]      ^
argv[1]                 ^
argv[2]                        ^

se argv fosse apenas um "ponteiro para char", você poderá ver

       "./program\0hello\0world\0"
argv    ^

No entanto (embora provavelmente pelo design do sistema operacional), não há garantia real de que as três strings "./program", "hello" e "world" sejam contíguas. Além disso, esse tipo de "ponteiro único para várias seqüências contíguas" é uma construção de tipo de dados mais incomum (para C), especialmente em comparação com a matriz de ponteiros para sequência.

Por que o argv principal do C / C ++ é declarado como "char * argv []"

Uma resposta possível é porque o padrão C11 n1570 (em §5.1.2.2.1 Inicialização do programa ) e o padrão C ++ 11 n3337 (em §3.6.1 função principal ) exigem que para ambientes hospedados (mas observe que o padrão C menciona também §5.1.2.1 ambientes independentes ) Veja também isso .

A próxima pergunta é por que os padrões C e C ++ optaram mainpor ter essa int main(int argc, char**argv)assinatura? A explicação é amplamente histórica: C foi inventado com o Unix , que possui um shell que faz globbing antes de fazer fork(que é uma chamada do sistema para criar um processo) e execve(que é a chamada do sistema para executar um programa) e que execvetransmite uma matriz dos argumentos do programa de seqüência de caracteres e está relacionado ao mainprograma executado. Leia mais sobre a filosofia Unix e sobre as ABI .

E o C ++ tentou seguir as convenções do C e ser compatível com ele. Não foi possível definir maincomo incompatível com as tradições C.

Se você projetou um sistema operacional a partir do zero (ainda com uma interface de linha de comando) e uma linguagem de programação para ele a partir do zero, você poderá inventar diferentes convenções de início de programa. E outras linguagens de programação (por exemplo, Common Lisp ou Ocaml ou Go) possuem diferentes convenções de início de programa.

Na prática, mainé invocado por algum código crt0 . Observe que no Windows o globbing pode ser realizado por cada programa no equivalente a crt0, e alguns programas do Windows podem iniciar através do ponto de entrada não padrão do WinMain . No Unix, o globbing é feito pelo shell (e crt0está adaptando a ABI e o layout inicial da pilha de chamadas que ele especificou, às convenções de chamada da sua implementação em C).

Em vez de pensar nele como "ponteiro para ponteiro", ajuda pensar nele como "matriz de cadeias", com []denotando matriz e char*denotando cadeia. Quando você executa um programa, pode passar um ou mais argumentos da linha de comando e estes são refletidos nos argumentos para main: argcé a contagem de argumentos e argvpermite acessar argumentos individuais.

Em muitos casos, a resposta é "porque é um padrão". Para citar o padrão C99 :

- Se o valor de argc for maior que zero, os membros da matriz argv [0] a argv [argc-1] inclusive deverão conter ponteiros para as strings , que recebem valores definidos pela implementação pelo ambiente host antes da inicialização do programa.

Obviamente, antes de ser padronizado, ele já estava em uso pelo K&R C nas implementações iniciais do Unix, com o objetivo de armazenar parâmetros de linha de comando (algo que você precisa cuidar no shell do Unix, como /bin/bashou /bin/shnão em sistemas embarcados). Para citar a primeira edição da "The C Programming Language" da K&R (pág. 110) :

O primeiro (convencionalmente chamado argc ) é o número de argumentos da linha de comando com os quais o programa foi chamado; o segundo ( argv ) é um ponteiro para uma matriz de seqüências de caracteres que contêm os argumentos, um por sequência.