Discussion :

[Ouaibou]

Bonjour,

Je suis en train de faire quelques révisions pour passer un examen de programmation impérative. J'ai donc récupéré certains sujets de l'année dernière dont notamment un que j'ai fait mais dont j'aurais souhaité savoir si mes réponses sont correctes étant donné que j'ai quelques doutes et qu'il n'y a pas de correction.

L'énoncé est le suivant :

Donner le prototype de chacune des fonctions appelées par la fonction main définie ci-dessous.

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
int * g(char); 
int main(int argc, char *argv[]) {
    int i;
    int *pi;
    int a[10];
    int *a2[11];
    int **a3 = a2;
 
    f0('a');
    i = f1(3);
    f2(&i);
    f3(&g);
    f4(&pi);
    pi = f5(a);
    f6(&a3);
    f7(*(&i));
    a3 = f8(&a[0]);
    f9(***(&a2));
    f10(g('a'));
}

Et voici mes réponses :

1) void f0(char);

2) int f1(int);

3) void f2(int *);

4) void f3(int *(*g) (char)) /* Passage de fonction par pointeur */

5) void f4(int **);

6) int *f5(int *);

7) void f6(int ***); /* Gros doute */

8) void f7(int);

9) int **f8(int *);

10) void f9(int);

11) void f10(int *);

Merci.

Cordialement,
Laurent

[diogene]

Je crois que c'est correct.
A noter une ambiguité possible sur les types de retour des fonctions
- La valeur de retour peut ne pas être utilisée
- La valeur de retour peut être automatiquement transtypée avant son assignation à une variable

[gl]

A noter une ambiguité possible sur les types de retour des fonctions
- La valeur de retour peut ne pas être utilisée
- La valeur de retour peut être automatiquement transtypée avant son assignation à une variable

De la meme maniere, avec les promotions et cast implicites, les parametres ne sont pas aussi evident que ca.

* f0('a') : en C, 'a' est de type int. Meme si effectivement, il y a de grandes chances que c soit char la reponse attendue.

* i = f1(3) : 3 peut etre utilise ici pour un signed char, un unsigned char, un int, un unsigned int, un float, un double, etc. Bref n'importe quel type numerique. La encore int est probablement la reponse attendue. Mais les autres ne sont pas reelement fausses.

Je doute vraiment de l'interet de ce type d'exercice.

[Ouaibou]

Je penses pas qu'il faille chercher si loin.

J'ai oublié d'indiquer que la première réponse est celle donnée avec l'énoncé : void f0(char);

En tout cas merci pour vos réponses

[fearyourself]

1) void f0(char);

Aucune preuve que le retour soit void. Mais je suppose que c'est ce qui était demandé.

3) void f2(int *);

Idem.

4) void f3(int *(*g) (char)) /* Passage de fonction par pointeur */

J'aurais mis :

4) void f3(int *(*) (char)) /* Passage de fonction par pointeur */

6) int *f5(int *);

Ou
int *f5(int t[10])

7) void f6(int ***); /* Gros doute */

Juste.


A part que sur les retours on ne peut pas dire si cela est vraiment void, c'est une possibilité et on supposera aussi qu'on ne fait pas de casts implicites...

Jc

[DaZumba]

void f0(char);

Si tu veux etre pedant, puisque 'a' a le type int en C, tu peux mettre alternativement void f0(int);

[Ouaibou]

Ok merci beaucoup pour vos réponses

[Emmanuel Delahaye]

Donner le prototype de chacune des fonctions appelées par la fonction main définie ci-dessous.

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
int * g(char); 
int main(int argc, char *argv[]) {
    int i;
    int *pi;
    int a[10];
    int *a2[11];
    int **a3 = a2;
 
    f0('a');
    i = f1(3);
    f2(&i);
    f3(&g);
    f4(&pi);
    pi = f5(a);
    f6(&a3);
    f7(*(&i));
    a3 = f8(&a[0]);
    f9(***(&a2));
    f10(g('a'));
}

Et voici mes réponses :

1) void f0(char);

Code :

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

void f0(int);

Le type char est promu en int. Inutile de l'utiliser. Mettre int directement. D'ailleurs, le type de 'A' est ... int.

Le type retourné ne peut pas être spécifié.

2) int f1(int);

Un choix parmi d'autres :

Code :

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

1
2
int f1(long);
int f1(unsigned int);

etc.

Cet énoncé n'a aucun sens en C.

<...>