Argumentpunkter

Argumenten i ett funktionsanrop har följande formulär:

expression(expression-list_opt) /* Funktionsanrop */

I ett funktionsanrop är uttryckslistan en lista över uttryck (avgränsade med kommatecken). Värdena för dessa senare uttryck är argumenten som skickas till funktionen. Om funktionen inte tar några argument ska uttryckslistan innehålla nyckelordet void.

Ett argument kan vara valfritt värde med grundläggande, struktur, union eller pekartyp. Alla argument skickas efter värde. Det innebär att en kopia av argumentet tilldelas motsvarande parameter. Funktionen känner inte till den faktiska minnesplatsen för argumentet som skickades. Funktionen använder den här kopian utan att påverka variabeln som den ursprungligen härleddes från.

Även om du inte kan skicka matriser eller funktioner som argument kan du skicka pekare till dessa objekt. Pekare är ett sätt för en funktion att komma åt ett värde med referens. Eftersom en pekare till en variabel innehåller variabelns adress kan funktionen använda den här adressen för att komma åt variabelns värde. Pekarargument gör att en funktion kan komma åt matriser och funktioner, även om matriser och funktioner inte kan skickas som argument.

Ordningen i vilken argument utvärderas kan variera under olika kompilatorer och olika optimeringsnivåer. Argumenten och eventuella biverkningar utvärderas dock helt innan funktionen anges. Se Biverkningar för information om biverkningar.

Uttryckslistan i ett funktionsanrop utvärderas och de vanliga aritmetiska konverteringarna utförs på varje argument i funktionsanropet. Om en prototyp är tillgänglig jämförs den resulterande argumenttypen med prototypens motsvarande parameter. Om de inte matchar utförs antingen en konvertering eller så utfärdas ett diagnostikmeddelande. Parametrarna genomgår också de vanliga aritmetiska konverteringarna.

Antalet uttryck i uttryckslistan måste matcha antalet parametrar, såvida inte funktionens prototyp eller definition uttryckligen anger ett variabelt antal argument. I det här fallet kontrollerar kompilatorn så många argument som det finns typnamn i listan över parametrar och konverterar dem, om det behövs, enligt beskrivningen ovan. Mer information finns i Anrop med variabelt antal argument .

Om prototypens parameterlista endast innehåller nyckelordet voidförväntar sig kompilatorn noll argument i funktionsanropet och noll parametrar i definitionen. Ett diagnostikmeddelande utfärdas om det hittar några argument.

Exempel

I det här exemplet används pekare som argument:

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;
}

I det här exemplet swap deklareras funktionen i main för att ha två argument, som representeras av identifierare num1 respektive num2, som båda är pekare till int värden. Parametrarna num1 och num2 i definitionen av prototypstil deklareras också som pekare för att int skriva värden.

I funktionsanropet

swap( &x, &y )

adressen x till lagras i num1 och adressen y till lagras i num2. Nu finns det två namn, eller "alias", för samma plats. Referenser till *num1 och *num2 i swap är i praktiken referenser till x och y i main. Tilldelningarna inom swap utväxlar faktiskt innehållet i x och y. Därför krävs ingen return instruktion.

Kompilatorn utför typkontroll på argumenten eftersom swap prototypen av swap innehåller argumenttyper för varje parameter. Identifierarna inom parenteserna för prototypen och definitionen kan vara samma eller annorlunda. Det viktiga är att argumenttyperna matchar parameterlistornas i både prototypen och definitionen.

Se även

Funktionsanrop