Discussion :

[khaled_prg]

Salut à tous :-)

Bon voilà, je veux écrire une fonction en C qui reçoit un pointeur de type int et l’initialise :

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
#include <stdio.h>
#include <stdlib.h>
 
int init(int* x) {
    x = (int*) malloc(sizeof (int));
    if (x == NULL) return 0;
    else {
        *x = 90;
        return 1;
    }
}
 
int main() {
    int *r;
    init(r);
    if (!init(r)) printf("Memoire insufisante");
    else
        printf("%d", *r);
    return 0;
}

Mais le problème c'est que le programme plante lors de l'exécution.
Où est-il le Bug ?

Merci d'avance.

[Invité]

Bonsoir,

Je t'invite à regarder cette discussion où IsraGab a rencontré le même problème. Avec en particulier les messages #5 et #7.

[khaled_prg]

Merci beaucoup de m'avoir répondu si rapidement.
En ce qui concerne le lien, je vois que le problème de IsraGab été avec la copie du string au lieu de l'affectation directe et je parle pas de cela :-)

D'autre part, j'ai remarqué que la fonction marche si on lui passe la référence du pointeur :

int init(int* &x) {
...
}

Qu'en vous pensez ?

[Invité]

Non tu ne parles pas de string mais de pointeur sur int, mais le principe est exactement le même que celui expliqué dans les messages vers lesquels je t'ai dirigé.
À savoir que tu manipules au sein de ta fonction init() une copie du pointeur original r. Autrement-dit une assignation du type x = ... n'aura aucune influence sur r contrairement à *x = ... qui modifiera bien le contenu pointé. Il faut ainsi utiliser un pointeur de pointeur pour effectivement répercuter le changement imposé par malloc().

L'utilisation de la référence est correcte, sauf que (comme aussi indiqué dans la discussion...) c'est du C++ et non du C.

[khaled_prg]

À savoir que tu manipules au sein de ta fonction init() une copie du pointeur original

Mais si on passe un pointeur d'une variable, alors les modifications effectués sur la copie seront aussi effectuer sur l'originale, car l'adresse du variable est "unique", n'est-ce pas ?
Donc pourquoi a-t-on besoin de passer un pointeur de pointeur ?

L'utilisation de la référence est correcte, sauf que c'est du C++ et non du C.

Et si je veux écrire un Code C "pure", Que dois-je faire ?

[Neckara]

Mais si on passe un pointeur d'une variable, alors les modifications effectués sur la copie seront aussi effectuer sur l'originale, car l'adresse du variable est "unique", n'est-ce pas ?
Donc pourquoi a-t-on besoin de passer un pointeur de pointeur ?

Un pointeur est aussi une variable. Si tu souhaites modifier l'objet vers lequel il pointe, il faut modifier sa valeur et donc passer par un pointeur.
D'où l'utilisation de pointeurs de pointeur.

Et si je veux écrire un Code C "pure", Que dois-je faire ?

En C, on utilise des pointeurs constants à la place de références.

[khaled_prg]

Un pointeur est aussi une variable. Si tu souhaites modifier l'objet vers lequel il pointe, il faut modifier sa valeur et donc passer par un pointeur.
D'où l'utilisation de pointeurs de pointeur.

J'ai bien compris l'idée, c'est claire.
Merci.

En C, on utilise des pointeurs constants à la place de références.

Mais si le pointeur (passé en paramètre) ne sera pas "constant", aura-t-il une confusion ?

[Neckara]

Quand une fonction prend un paramètre en constant (ex : const int) ceci ne signifie pas grand chose pour l'utilisateur car le paramètre sera passé par copie, donc tu peux lui transmettre un paramètre constant ou non.

Par contre dans le cas où tu met en paramètre un const int * ptr donc un pointeur sur un objet "considéré comme constant".
C'est à dire que tu ne pourras pas modifier l'objet pointé via ce pointeur. ( Ce qui n'est pas tout à fait vrai en C ).
Dans ce cas là tu pourras lui transmettre int * ptr; ou
const int * ptr;.
Par contre pour une fonction prenant un int * ptr tu ne devrait pas pouvoir lui donner un const int * ptr;.

A ne pas confondre avec un pointeur constant qui ne peut pas modifier sa valeur : int * const ptr

[Kirilenko]

Mais si le pointeur (passé en paramètre) ne sera pas "constant", aura-t-il une confusion ?

Tu peux utiliser un pointeur de type T quand un pointeur de type const T est attendu (mais pas l'inverse, évidemment). Il y a bien l'exception bien connue de la conversion T** vers const T** qui n'est pas implicite du fait de la non-récursivité de cette règle, mais la solution est alors de passer par un transtypage malpropre.

Code :

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

1
2
3
4
5
6
7
8
/* L'Exception qui confirme la règle */
void f(const int **p) { /* ... */ }
 
int main(void) {
	int *x;
	f((const int **)&x);
	return 0;
}

[khaled_prg]

Je m'excuse du retard :-(
Je vous remercie vivement pour l'intérêt que vous avez porté à cette discussion.

=> Résolu.

[Médinoc]

Il y a bien l'exception bien connue de la conversion T** vers const T** qui n'est pas implicite du fait de la non-récursivité de cette règle, mais la solution est alors de passer par un transtypage malpropre.

Correction, c'est la conversion T** vers const T * const * qui est correcte mais nécessite un transtypage en C (elle est d'ailleurs acceptée en C++).

La conversion T** vers const T** est toujours malpropre et doit être évitée.

En effet, elle permet de convertir silencieusement un pointeur const en pointeur non-const! Exemple:

Code C :

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
28
29
30
int GetString(char const **ps, int num)
{
	char const * sret; /*Notez que ce pointeur est const*/
	switch(num)
	{
	case 1: sret = "toto"; break;
	case 2: sret = "tata"; break;
	default: sret = NULL; break;
	}
 
	*ps = sret;
	return (sret==NULL ? 0 : strlen(sret));
}
 
int main(void)
{
	/*Code correct*/
	{
		char const *s;
		int len = GetString(&s, 1);
		puts(s);
	}
	/*Code faux*/
	{
		char *s;
		int len = GetString((char const **)&s, 1); /*On place sret dans un pointeur non-const!*/
		s[0] = 'A'; /*BOUM.*/
	}
	return 0;
}

[Kirilenko]

Correction, c'est la conversion T** vers const T * const * qui est correcte mais nécessite un transtypage en C (elle est d'ailleurs acceptée en C++).

La conversion T** vers const T** est toujours malpropre et doit être évitée.

En effet, elle permet de convertir silencieusement un pointeur const en pointeur non-const! Exemple:

Code C :

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
28
29
30
int GetString(char const **ps, int num)
{
	char const * sret; /*Notez que ce pointeur est const*/
	switch(num)
	{
	case 1: sret = "toto"; break;
	case 2: sret = "tata"; break;
	default: sret = NULL; break;
	}
 
	*ps = sret;
	return (sret==NULL ? 0 : strlen(sret));
}
 
int main(void)
{
	/*Code correct*/
	{
		char const *s;
		int len = GetString(&s, 1);
		puts(s);
	}
	/*Code faux*/
	{
		char *s;
		int len = GetString((char const **)&s, 1); /*On place sret dans un pointeur non-const!*/
		s[0] = 'A'; /*BOUM.*/
	}
	return 0;
}

Au temps pour moi, je me suis emmêlé les pinceaux avec le transtypage (qui, lui, est bien const t **, du fait de l'inutilité de la qualification du pointeur constant dans ce cas).