Discussion :

[lynaranya]

Bonsoir;
je voudrais savoir si c'est possible d'écrire une fonction ou bien une procédure(void) en langage c qui ne contiennent aucun paramètres en entrée

[Bayard]

Oui.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
int function_qui_ne_retourne_rien(void)
{
  return 47;
}

On peut bien sur remonter plein d'autres choses qu'un int...
Un pointeur, une structure...

Bonne soirée

[edgarjacobs]

Pour le fun

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main(void) {
    printf("Hello world");
 
    return(0);
}

[lynaranya]

merci pour vos réponses,
par exemple si j'avais une procédure qui calcule la moyenne, mais avant de calculer la moyenne j'ai d'autres calcules, comme la lecture du fichier csv, ensuite le calcule de la distance euclidienne du fichier csv qui donne une matrice , et enfin le calcule de la moyenne de la distance euclidienne

le tout regroupé dans une procédure de la façon suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void moyenne()
{
.....
 
 
printf("moy=%g",moy);
return;
 
}
 
int main(int argc, char *argv[])
{
     moyenne;    
  system("PAUSE");	
  return 0;
}
}

[Bousk]

Un bon code découpe normalement les opérations dans des fonctions spécialisées pour 1 actions.
Ça permet entre autre de les réutiliser.
Mais rien n'empêche de faire une super fonction qui regroupe tout..

[Corluk]

D'ailleurs fais attention aux parenthèses vides. Alors que foo() exprime un nombre d'arguments arbitraire, foo(void) signifie qu'aucun argument ne peut être passé. Cette nuance ne reste dans le langage que pour des raisons de compatibilité avec des versions anciennes du C. C++ l'a abandonné et foo() a le même effet que foo(void).

[Bousk]

C++ l'a abandonné et interdit foo(void).

Euh... non
Mettre void n'a aucun effet en C++ mais la syntaxe n'est pas du tout interdite.

[Sve@r]

Bonjour

merci pour vos réponses,
par exemple si j'avais une procédure qui calcule la moyenne, mais avant de calculer la moyenne j'ai d'autres calcules, comme la lecture du fichier csv, ensuite le calcule de la distance euclidienne du fichier csv qui donne une matrice , et enfin le calcule de la moyenne de la distance euclidienne

le tout regroupé dans une procédure de la façon suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
void moyenne()
{
.....
 
 
printf("moy=%g",moy);
return;
 
}

Ben sans parler de ton return final totalement inutile pour une fonction ne retournant rien, les paramètres d'une fonction servent justement à la rendre universelle. Grace aux paramètres justement elle pourra faire ses calculs de la même façon quelle que soit la valeur reçue. C'est le pendant informatique de la notation mathématique f(x)=... permettant d'exprimer un calcul sans avoir à se préoccuper de la valeur à calculer qui sera donnée plus tard.
Une fonction sans paramètre reste donc très limitée (cf premier exemple de Bayard qui crée une fonction retournant en tout et pour tout le nombre 47 et tant pis si l'utilisateur a besoin de 48).
Pour ta moyenne par exemple je ne vois pas trop comment elle pourra calculer la moyenne des éléments sans les connaitre. Ou alors tu envisages de passer par des variables globales ce qui est la pire des mauvaises idées de conception...

Alors que foo() exprime un nombre d'arguments arbitraire

Non. C'est la notation foo(...) qui exprime des arguments arbitraires. foo() exprime bien une fonction sans argument.

C++ l'a abandonné et interdit foo(void).

Ah bon ? Je suis pas un pro du C++ mais il me semble avoir vu quand-même foo(void). Il me semble même que justement c'est la seule syntaxe autorisée en C++...

[Corluk]

Mettre void n'a aucun effet en C++ mais la syntaxe n'est pas du tout interdite.

C'est bien, je me suis mal souvenu, foo() et foo(void) sont équivalents en C++. Mais la difference, c'est ce qui a été abandonné. Je l'ai corrigé dans mon dernier post.

Je me suis renseigné un peu plus. Pour clarifier, référons au standard même. L'ébauche N1570 du standard C11 contient le nécessaire.

§6.7.6.3/14:

The empty list in a function declarator that is not part of a
definition of that function specifies that no information about the number or types of the
parameters is supplied. ¹⁴⁵⁾

C'est-à-dire, une déclaration avec des paramètres vides exprime que le programmeur ne fournit aucune information sur les paramètres. Donc, du code comme le suivant est tout à fait possible :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void foo();
void foo(int a) { }

La citation dessus est précédée par cette phrase-ci :

An empty list in a function declarator that is part of a definition of that function specifies that the
function has no parameters.

Donc, en principe, Sve@r est correct en disant que des parenthèses vides expriment qu'il n'y a pas d'arguments. Mais fais très attention, parce qu'il y a encore §6.5.2.2/6 :

If the expression that denotes the called function has a type that does not include a
prototype [...] If the number of arguments does not equal the number of parameters, the
behavior is undefined.

Si l'on appelait une fonction qui manque un prototype et le nombre d'arguments n'est pas le nombre de paramètres, alors on obtiendrait du comportement indéfini, ce dont un compilateur peut ou ne peut pas avertir ! Le suivant cause du comportement indéfini et mon compilateur de choix, gcc, n'en avertit pas, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void foo() { }
int main(void) { foo(1); }

En bref :
Une déclaration comme void foo(); sert à exprimer que le nombre de paramètres est inconnu.
Une définition comme void foo() { } sert à exprimer que le nombre de paramètres est zéro.
foo(void) effectue la même chose au niveau du compilateur : Non seulement du comportement indéfini, mais une erreur.

[foetus]

En bref :
Une déclaration comme void foo(); sert à exprimer que le nombre de paramètres est inconnu.
Une définition comme void foo() { } sert à exprimer que le nombre de paramètres est zéro.
foo(void) effectue la même chose au niveau du compilateur : Non seulement du comportement indéfini, mais une erreur.

Je pense que tu ne comprends pas le problème qui est très subtil

Lorsque tu codes foo(), tu peux appeler cette fonction avec n'importe quel argument foo(array, 5, 97.4f);.
Alors qu'avec foo(void) tu auras l'erreur "Error: trop d'arguments pour la fonction «*foo*»"

Le problème est un débordement de pile (cela va dépendre de la convention d'appel, lien wiki en anglais) et tu pourras aller modifier/ dumper/ ... les variables locales (qui sont empilées sur la pile)

[Corluk]

Lorsque tu codes foo(), tu peux appeler cette fonction avec n'importe quel argument foo(array, 5, 97.4f);.
Alors qu'avec foo(void) tu auras l'erreur "Error: trop d'arguments pour la fonction «*foo*»"

Je suis entièrement d'accord avec toi. Mais quoi donc ?

Le problème est un débordement de pile (cela va dépendre de la convention d'appel, lien wiki en anglais) et tu pourras aller modifier/ dumper/ ... les variables locales (qui sont empilées sur la pile)

Dans mon post, "le problème" est un bon style de programmation en C. Et pour ça, il faut se conformer au standard.

Le standard ne connaît pas une pile. Selon le standard, l'implémentation n'est pas requise d'en avoir une. Tu fais toi-même mention des conventions d'appel différentes mais dis en même temps que le "problème est un débordement de pile". Si les arguments ne sont passés qu'en registres, pas de pile, pas de débordement.

Si l'on programme en C, il s'agit de se conformer au standard. Celui ne connaît que des termes comme "conforming behavior" (comportement conformant), "undefined behavior" (comportement indéfini), etc. C'est à quoi j'adresse ma réponse, rien d'autre.

[lynaranya]

Bonjour;
j'ai essailler de créer un prgramme avec une seul procédure qui ne contient aucun paramétres d'entrée, mais le probléme c'est que j'ai une erreur au niveau de l'éxecution:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void moyenne()
{
.....
 
 
printf("moy=%g",moy);
return;
 
}
 
int main(int argc, char *argv[])
{
     moyenne;    
  system("PAUSE");	
  return 0;
}
}

[Linker error] undefined reference to `WinMain@16'

[lynaranya]

merci pour vos aides, j'ai réussi à exécuter le programme, c'été juste une faute de création de projet, merci pour vous tous

[Bousk]

L'intérêt est tellement nul qu'il en devient négatif...
Si tu veux une unique fonction dans ton programme, elle existe déjà et s’appelle main

[Sve@r]

c'été juste une faute de création de projet

Ben il n'y en n'a pas qu'une !!!

1. appel de la fonction "moyenne" sans mettre de parenthèses indiquant l'appel de fonction (ça devient donc une simple adresse, ou mieux un simple nombre, qui est présent sans être traité; exactement comme si tu avais écrit 123;)
2. une accolade fermante en trop ligne 17
3. une fonction qui va calculer une moyenne de valeurs qu'elle ne connait pas (conceptuellement )

L'intérêt est tellement nul qu'il en devient négatif...

Ca c'est de la métaphore !!!

Si tu veux une unique fonction dans ton programme, elle existe déjà et s’appelle main

Et en plus ça éviterait de passer par des variables globales

[sambia39]

Bonjour ;

Je pense que tu ne comprends pas le problème qui est très subtil

Lorsque tu codes foo(), tu peux appeler cette fonction avec n'importe quel argument foo(array, 5, 97.4f);.
Alors qu'avec foo(void) tu auras l'erreur "Error: trop d'arguments pour la fonction «*foo*»"

Le problème est un débordement de pile (cela va dépendre de la convention d'appel, lien wiki en anglais) et tu pourras aller modifier/ dumper/ ... les variables locales (qui sont empilées sur la pile)

Attention. Le message d'erreur n'est pas uniquement dans un cas précis et ce n'est pas forcément une question de convention d'appel.

Pour faire simple les fonctions qui n'acceptent aucun argument doivent explicitement déclarer un paramètre/argument vide donc void foo(void) . Cela est également valable tant pour la déclaration que pour la définition. Plus précisément; dans le cas void foo(void); le compilateur comprend que la fonction ne prend aucun argument/paramètre et donc, si l'on tente de passer un argument (foo(arg) au moment de la compilation il y a erreur; non pas pour dire qu'il y a trop d'argument, mais plus pour dire que la fonction a été déclarer comme étant une fonction n'admettant pas d'argument/paramètre, mais moi compilateur je détecte un argument donc c'est une erreur. Il faut alors clairement annoncer vos intentions.

Cas contraire, void foo(), le compilateur comprend que cette fonction fournit aucune précision/information sur le nombre ou les types de paramètres/argument. En terme plus clair, c'est une fonction susceptible d'avoir un argument/un certain nombre d'arguments non spécifié. Le compilateur va donc absolument pas vérifier si la fonction est appelée avec des paramètres. Par conséquent, l'appel de fonctions avec des paramètres arbitraires sera accepté sans avertissement au moment de la compilation.

Dans certains cas (exemple pour moi: Apple clang version 11.0.3) le compilateur émet tout de même un avertissement comme quoi, il y a trop d'argument/ou argument détecté, mais ne abort pas (sauf si par -Werror activé) ce n'est donc, pas que dans un cas précis que vous aurez ce genre de message(ceci dit tout dépend du compilateur a mon avis GCC passera sous silence).

Le problème est un débordement de pile (cela va dépendre de la convention d'appel, lien wiki en anglais) et tu pourras aller modifier/ dumper/ ... les variables locales (qui sont empilées sur la pile)

Attention là aussi; le débordement n'est pas une justification à tout. Un débordement se fait dans un contexte précis et c'est plus une erreur dite de programmation et rarement une erreur de compilations.

à bientôt.