Discussion :

[orfix]

Salut,

Laquelle des deux écritures est la plus juste ou celle à préférer ? Et pourquoi ?

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
18
19
20
21
22
23
24
25
26
27
 
#include <stdio.h>
#include <stdlib.h>
 
typedef int pf_t ( void );
 
int foo( void );
 
int main( void )
{
	pf_t *pf_foo;
 
	pf_foo = &foo;
	/* OU */
	pf_foo = foo;
 
	pf_foo();
	/* OU */
	(*pf_foo)();
 
	return 0;
}
 
int foo( void )
{
	return 1;
}

Merci.

[Lucien63]

La plus simple pour des raisons de clareté de lecture.

Code :

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

1
2
	pf_t *pf_foo  = foo; 
	pf_foo();

[diogene]

La plus simple pour des raisons de clareté de lecture.

Code :

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

1
2
	pf_t *pf_foo  = foo; 
	pf_foo();

Pas d'accord. Pour mon compte, je préfère de beaucoup

Code :

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

(*pf_foo)();

pour des raisons de clarté : le codage

Code :

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

pf_foo();

peut laisser supposer au lecteur du code l'existence d'une fonction pf_foo qu'il cherchera vainement, alors que l'autre notation exprime clairement la nature de pf_foo

[Vincent Rogier]

Pas d'accord. Pour mon compte, je préfère de beaucoup

Code :

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

(*pf_foo)();

+1. Au moins, c'est sans ambiguïté !

La forme pf_foo() n'est pas la forme originelle.

C'est juste une tolérance que permet la norme pour raison de simplification mais qui a mon avis a du pertuber pas mal de débutants... et ne les a pas aidé à bien comprendre les pointeurs de fonction.

[Melem]

Extrait de mon tutoriel de langage C : Pointer sur une fonction. Je suis d'accord avec Lucien63, mais ça n'est rien de plus qu'un avis personnel.

[orfix]

Merci 'Melem' pour ce tuto je crois que je vais adopter cette écriture :

Code :

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

1
2
3
 
 pf_foo = ******&*&*&*&foo;
 (******&*&*&*pf_foo)();

C'est drôle de voir que l'on peut écrire des choses de ce genre , mais en y réfléchissons c'est vrai que puisque le nom de la fonction représente son adresse on pourras déréférencer ce pauvre petit pointeur à l'infini le résultat sera le même ...

Merci pour vos avis à tous !

[supersnail]

Perso,je préfère

Code :

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

1
2
3
pf_foo = foo;
 
	pf_foo();

c'est plus facile à comprendre...

[nicolas.sitbon]

Pas d'accord. Pour mon compte, je préfère de beaucoup

Code :

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

(*pf_foo)();

pour des raisons de clarté : le codage

Code :

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

pf_foo();

peut laisser supposer au lecteur du code l'existence d'une fonction pf_foo qu'il cherchera vainement, alors que l'autre notation exprime clairement la nature de pf_foo

Pas d'accord :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
 
static void aff (void)
{
   puts ("Hello world");
}
 
int main (void)
{
   (*aff)();
   return 0;
}

ce code est valide selon la norme et pourtant la notation laisse penser à un pointeur de fonction bien que aff soit une fonction. S'il y a des règles de conversions implicites ça n'est pas pour rien. Dans tous les cas cet argument n'est pas valable.

[diogene]

Pas d'accord :
[CODE]
void aff (void)...
...
(*aff)();
CODE]
ce code est valide selon la norme et pourtant la notation laisse penser à un pointeur de fonction bien que aff soit une fonction. ...

Qui écrit des choses déplaisantes comme ça ?
Je n'ai pas dit qu'on ne pouvait pas faire du codage volontairement abscons ou trompeur tout en suivant la norme.
Sinon, on peut aussi adopter la manière décrite par ssmario2 un peu plus haut

Dans tous les cas cet argument n'est pas valable.

Il explique pourtant bien le pourquoi de ma réponse selon la demande du posteur.

[Vincent Rogier]

L'argument de diogene est pourtant le plus valable de tous ceux mentionnés...

La norme prévoit effectivement les deux formes. La première originelle est bien (*pf_foo)();

La deuxième a été introduite, pour faire "plus simple" et l'identificateur pf_foo est implicitement converti en pointeur sur la fonction pf_foo.

Les deux formes sont donc ok et définies par la normes.

Donc, pourquoi Diogène recommande (et pour ma part, il a entièrement raison) la première ?

D'une part, c'est la forme la plus logique.. Mais çà, à la rigueur on s'en fout.

D'autre part, quand on bosse sur des gros projets et des dizaines milliers de lignes de code, cela permet lors du premier coup d'œil de savoir que l'on manipule un pointeur sur une fonction et pas un appel direct à une fonction.

Identifier simplement ce qu'on manipule permet de faire du code plus robuste que du code peut être plus light mais plus source de bug...

@nicolas.sibton : ton raisonnement se vaut, certes, mais cela reste du pinnaillage intellectuel et de la prêche de l'absurde qui reste bien stérile dans la pratique...

Dun point de vue empirisme et qaulité de code, je persiste à dire que la forme initiale de la norme et recommandée par Diogene reste la meilleure solution pour produire du code de qualité

[3DArchi]

Je partage les avis de Vincenzo et Diogène. Le C est tellement permissif qu'il est souhaitable de se donner quelques règles. L'écriture (*pf_foo)() démontre clairement la volonté de l'auteur du code d'utiliser un pointeur de fonction.

[Melem]

Je partage les avis de Vincenzo et Diogène ... L'écriture (*pf_foo)() démontre clairement la volonté de l'auteur du code d'utiliser un pointeur de fonction.

Bah dans ce cas il faut également toujours écrire int * p = &(t[0]); - t étant un tableau - au lieu de int * p = t; car cela laisse penser que t est un int * ...

[muad'dib]

Bah dans ce cas il faut également toujours écrire int * p = &(t[0]); - t étant un tableau - au lieu de int * p = t; car cela laisse penser que t est un int * ...

On utilise quand même plus fréquemment les pointeurs sur tableaux que sur fonction, on est plus habitués du coup à jeter un oeil à la variable t pour savoir ce que c'est. En revanche, si je tombe sur une instruction pf_foo(), je ne vais pas imaginer instinctivement qu'il s'agit d'un pointeur sur fonction et non d'une fonction.

[homeostasie]

En revanche, si je tombe sur une instruction pf_foo(), je ne vais pas imaginer instinctivement qu'il s'agit d'un pointeur sur fonction et non d'une fonction.

C'est dans ces moments où l'on s'aperçoit que respecter une convention de nommage est important ("pf_" pour variable de type pointeur de fonction)!

Mais j'avoue aussi préférer la forme originelle pour les mêmes raisons déjà formulées.