C les arguments Sub

Question

Ce qui est mieux : ou ? Vide, il semble laide et incohérent, mais j’ai dit que c’est bon. Est-ce vrai ?

Edit : Je sais que certains anciens compilateurs choses bizarres, mais si j’utilise juste GCC, est Ok ? Vous alors être accepté ?

Answer 1

<pre><code></code><p>C’est la façon correcte de ne dire « aucuns paramètres » en ut, et ça marche aussi en C++.</p><p>Mais :</p><pre><code></code></pre><p><code></code>.</p><p>Fonctions de liste d’arguments variable sont intrinsèquement ONU-type sécurisé et doivent être évitées si possible.</p></pre>

Answer 2

Il y a deux façons pour la spécification des paramètres dans C. On utilise une liste d'identifiants, et l'autre à l'aide d'un paramètre de type liste. L'identificateur de la liste peut être omis, mais la liste type de ne peut pas. Donc, pour dire qu'une fonction ne prend pas d'arguments dans une définition de fonction-vous faire cela avec un (omis) identificateur de la liste

void f() {
    /* do something ... */
}

Et ce, avec un type de paramètre de la liste:

void f(void) {
    /* do something ... */
}

Si dans la liste type de paramètre le seul type de paramètre est vide (il ne doit pas avoir de nom à l'époque), cela signifie que la fonction ne prend pas d'arguments. Mais ces deux façons de définir une fonction d'une différence quant à ce qu'ils déclarent.

Identificateur de listes

La première définit que la fonction prend un nombre spécifique d'arguments, mais ni le comte est communiquée ni les types de ce qui est nécessaire - comme avec toutes les déclarations de fonction que l'utilisation de l'identificateur de listes. Si l'appelant a savoir les types et le nombre avec précision avant-main. Donc, si l'appelant appelle la fonction en lui donnant un argument, le comportement est indéfini. La pile peut être corrompu par exemple, parce que la fonction appelée prévoit une mise en page différente quand il prend le contrôle.

À l'aide de l'identificateur de listes dans les paramètres de la fonction est obsolète. Il a été utilisé dans les vieux jours et est toujours présent dans beaucoup de code de production. Ils peuvent causer de graves danger à cause de ceux argument promotions (si le promu type d'argument ne correspond pas au type de paramètre de la définition de la fonction, le comportement est indéfini, soit!) et sont beaucoup moins sûr, bien sûr. Il faut donc toujours utiliser l' void "truc" pour les fonctions sans paramètres, dans les deux seules les déclarations et les définitions de fonctions.

Liste type de paramètre

Le second définit que la fonction prend des arguments zéro et communique également que, tout comme dans tous les cas où la fonction est déclarée à l'aide d'un paramètre de type liste, qui est appelé un prototype. Si l'appelant appelle la fonction et lui donne un argument, c'est une erreur et que le compilateur crache une erreur approprié.

La deuxième façon de déclarer une fonction a beaucoup d'avantages. On est bien sûr que la quantité et les types de paramètres sont vérifiés. Une autre différence est que parce que le compilateur connaît les types de paramètres, on peut appliquer les conversions implicites des arguments du type des paramètres. Si aucune liste type de paramètre est présent, qui ne peut pas être fait, et les arguments sont convertis au promu types (qui est appelé la valeur par défaut de l'argument de promotion). char deviendra int, par exemple, alors que float deviendra double.

Type Composite pour les fonctions

Par ailleurs, si un fichier contient à la fois un omis identificateur de la liste et une liste type de paramètre, le paramètre de type de liste "gagne". Le type de la fonction à la fin contient un prototype:

void f();
void f(int a) {
    printf("%d", a);
}

// f has now a prototype.

C'est parce que les deux déclarations ne disent rien contradictoire. La seconde, cependant, avait quelque chose à dire de plus. Qui n'est qu'un argument est accepté. La même chose peut être réalisé en sens inverse

void f(a) 
  int a;
{ 
    printf("%d", a);
}

void f(int);

La première définit une fonction à l'aide d'un identificateur de la liste, tandis que la seconde fournit ensuite un prototype pour elle, à l'aide d'une déclaration contenant un paramètre de type liste.

Answer 3

Ce dernier est meilleur parce qu’il est explicitement dit : aucun paramètre autorisé.

Le premier signifie que vous pouvez (sous certains compilateurs) envoyer des paramètres, au moins si il s’agit de la déclaration de votre fonction, plutôt que sa définition.