Argumentos

Os argumentos em uma chamada de função têm esta forma:

expression(expression-list_opt) /* Chamada de função */

Em uma chamada de função, expression-list é uma lista de expressões (separadas por vírgulas). Os valores destas últimas expressões são os argumentos passados para a função. Se a função não usa argumentos, a lista de expressões deve conter a palavra-chavevoid.

Um argumento pode ser qualquer valor com fundamental, estrutura, união ou tipo de ponteiro. Todos os argumentos são passados por valor. Isso significa que uma cópia do argumento é atribuída ao parâmetro correspondente. A função não sabe o local real da memória do argumento passado. A função usa essa cópia sem afetar a variável da qual ela foi originalmente derivada.

Embora não seja possível passar matrizes ou funções como argumentos, você pode passar ponteiros para esses itens. Os ponteiros fornecem uma maneira para uma função acessar um valor por referência. Como um ponteiro para uma variável contém o endereço da variável, a função pode usar esse endereço para acessar o valor da variável. Os argumentos de ponteiro permitem que uma função acesse matrizes e funções, mesmo que matrizes e funções não possam ser passadas como argumentos.

A ordem em que os argumentos são avaliados pode variar sob diferentes compiladores e diferentes níveis de otimização. No entanto, os argumentos e quaisquer efeitos colaterais são completamente avaliados antes da função é inserida. Ver Efeitos secundários para informação sobre efeitos secundários.

A lista de expressões em uma chamada de função é avaliada e as conversões aritméticas usuais são executadas em cada argumento na chamada de função. Se um protótipo estiver disponível, o tipo de argumento resultante será comparado ao parâmetro correspondente do protótipo. Se eles não corresponderem, uma conversão será executada ou uma mensagem de diagnóstico será emitida. Os parâmetros também sofrem as conversões aritméticas usuais.

O número de expressões na lista de expressões deve corresponder ao número de parâmetros, a menos que o protótipo ou a definição da função especifique explicitamente um número variável de argumentos. Nesse caso, o compilador verifica tantos argumentos quantos forem os nomes de tipo na lista de parâmetros e os converte, se necessário, conforme descrito acima. Consulte Chamadas com um número variável de argumentos para obter mais informações.

Se a lista de parâmetros do protótipo contiver apenas a palavra-chave void, o compilador espera zero argumentos na chamada de função e zero parâmetros na definição. Uma mensagem de diagnóstico é emitida se encontrar algum argumento.

Exemplo

Este exemplo usa ponteiros como argumentos:

int main()
{
    /* Function prototype */

    void swap( int *num1, int *num2 );
    int x, y;
    .
    .
    .
    swap( &x, &y );  /* Function call */
}

/* Function definition */

void swap( int *num1, int *num2 )
{
    int t;

    t = *num1;
    *num1 = *num2;
    *num2 = t;
}

Neste exemplo, a função é declarada swap em main ter dois argumentos, representados respectivamente por identificadores num1 e num2, ambos são ponteiros para int valores. Os parâmetros num1 e num2 na definição de estilo protótipo também são declarados como ponteiros para int valores de tipo.

Na chamada de função

swap( &x, &y )

O endereço de x é armazenado em num1 e o endereço de y é armazenado em num2. Agora existem dois nomes, ou "pseudónimos", para o mesmo local. As referências a *num1 e *num2 em swap são efetivamente referências a x e y em main. As atribuições dentro swap realmente trocam o conteúdo de x e y. Por conseguinte, não é necessária qualquer return declaração.

O compilador executa a verificação de tipo nos argumentos para swap porque o protótipo de inclui tipos de swap argumento para cada parâmetro. Os identificadores entre parênteses do protótipo e da definição podem ser iguais ou diferentes. O importante é que os tipos de argumentos correspondam aos das listas de parâmetros no protótipo e na definição.

Ver também

Chamadas de função