Discussion :

[corent2]

Salut !
Je ne comprends pas pourquoi dans ce code, la fonction allouer ne fonctionne pas :

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>
 
void allouer(int* ptr){
  ptr = malloc(10*sizeof(int));
}
 
void ptrEstIlNull(int* ptr){
  if(ptr==NULL)
    printf("tab est null\n");
  else
    printf("tab n'est pas null\n");
}
 
 
int main(){
  int* tab;
  ptrEstIlNull(tab);
 
  allouer(tab);
  ptrEstIlNull(tab);
 
  tab = malloc(10*sizeof(int));
  ptrEstIlNull(tab);
 
  return 0;
}

Le résultat obtenu à la console est :

Code :

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

1
2
3
tab est null
tab est null
tab n'est pas null

Mais j'aurais imaginé que le résultat serait :

Code :

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

1
2
3
tab est null
tab n'est pas null
tab n'est pas null

La solution, c'est de modifier la fonction allouer pour qu'elle renvoie le pointeur. Mais la solution je m'en moque, je veux juste comprendre.

[foetus]

Erreur de débutant ou

Il faut passer un double pointeur, parce que sinon le pointeur retourné par malloc est mis dans la copie du pointeur (les joyeusetés du passage par copie )

Sinon n'oublie pas le free

Édit: Un petit schéma

Pointeur simple: | tab |-> NULL / Passage de paramètre * / | ptr - copie de tab |-> X - retour de la fonction malloc.
Double Pointeur: | tab |-> NULL / Passage de paramètre ** / | ptr | -> | tab |-> X - retour de la fonction malloc.

[corent2]

Ah d'accord. Je trouvais ça compliqué d'utiliser un double pointeur juste pour faire un simple malloc. C'est limite contre-intuitif.
Déjà que les pointeurs, ça se comprend pas tout de suite, alors les double pointeurs...

J'ai modifié le code et ça donne ça :

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
28
#include<stdio.h>
#include<stdlib.h>
 
void allouer(int** ptr){
  (*ptr) = malloc(10*sizeof(int));
}
 
void ptrEstIlNull(int* ptr){
  if(ptr==NULL)
    printf("tab est null\n");
  else
    printf("tab n'est pas null\n");
}
 
 
int main(){
  int* tab;
  ptrEstIlNull(tab);
 
  allouer(&tab);
  ptrEstIlNull(tab);
 
  tab = malloc(10*sizeof(int));
  ptrEstIlNull(tab);
 
  free(tab);
  return 0;
}

[foetus]

Il te manque un free à la ligne 22

[corent2]

Oh tu m'embêtes, c'était juste pour l'exemple.

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
28
29
#include<stdio.h>
#include<stdlib.h>
 
void allouer(int** ptr){
  (*ptr) = malloc(10*sizeof(int));
}
 
void ptrEstIlNull(int* ptr){
  if(ptr==NULL)
    printf("tab est null\n");
  else
    printf("tab n'est pas null\n");
}
 
 
int main(){
  int* tab;
  ptrEstIlNull(tab);
 
  allouer(&tab);
  ptrEstIlNull(tab);
  free(tab);
 
  tab = malloc(10*sizeof(int));
  ptrEstIlNull(tab); 
  free(tab);
 
  return 0;
}

[imperio]

C'est pour ton bien.

[sambia39]

Bonjour

Oh tu m'embêtes, c'était juste pour l'exemple.

Ce qui a été dit est pour ton bien, mais si tu comptes ne pas utiliser les doubles pointeurs, tu peux toujours écrire une fonction qui te retourne un pointeur sur la zone qui a été allouer 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
 
int *f_AllocPtr( size_t size ){
 
	int *ptr = NULL;
	size = ( size <= 0 ? 10 : size );
	ptr = (int*)malloc( size *sizeof(int) );
	if( ptr == NULL ){
		fprintf(stderr, "Erreur d'allocation\n" );
		exit( EXIT_FAILURE );
	}
	return( ptr );
}
int *f_Alloc2Ptr( size_t size ){
 
	int *ptr = NULL;
	size = ( size <= 0 ? 10 : size );
	ptr = (int*)calloc( size, sizeof(int) );
	if( ptr == NULL ){
		fprintf(stderr, "Erreur Allocation\n" );
		exit( EXIT_FAILURE );
	}
	return ( ptr );
}

à bientôt

[gangsoleil]

Bonjour,

Je sais que tu vas dire qu'on est tatillon, mais :

Le résultat obtenu à la console est :

Code :

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

1
2
3
tab est null
tab est null
tab n'est pas null

Mais j'aurais imaginé que le résultat serait :

Code :

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

1
2
3
tab est null
tab n'est pas null
tab n'est pas null

Le résultat auquel tu aurais dû t'attendre est :

Code :

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

1
2
3
tab n'est pas null
tab n'est pas null
tab n'est pas null

En effet, lorsque tu écris int * tab;, tu déclares bien un pointeur "tab" sur un int, mais tu ne l'initialises pas, et il n'y a donc aucune raison qu'il vaille NULL plus qu'autre chose. A ce stade, ton pointeur vaut "quelque chose", et pointe sur une zone que tu n'as pas allouée, et donc dans laquelle tu n'as pas le droit d'écrire.

Si je reprends ton code :

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
28
29
30
31
32
33
34
#include<stdio.h>
#include<stdlib.h>
 
void allouer(int** ptr){
  (*ptr) = malloc(10*sizeof(int));
}
 
void ptrEstIlNull(int* ptr){
  if(ptr==NULL)
    printf("tab est null\n");
  else
    printf("tab n'est pas null\n");
}
 
 
int main(){
  int* tab;

/* Initialisations */
tab = NULL;

  ptrEstIlNull(tab);
 
  allouer(&tab); /* Tu ne traites pas le cas où l'allocation échoue, ce qui peut faire crasher ton programme */
  ptrEstIlNull(tab);
  free(tab); /* Non symétrique : tu as une fonction pour allouer, mais pas pour désallouer, ce qui n'est pas une bonne habitude */
 
  tab = malloc(10*sizeof(int));
  ptrEstIlNull(tab); 
  free(tab);
 
  return 0;
}