Null pointer assignement

Version imprimable

Bonsoir,

Pouvez vous m'aider à trouver mon erreur ?

voila mon code :

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include "liste.h"
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
 
 
struct skieurs
{
  int matricule;
  char * nom;
  char * prenom;
 
};
 
 
 
void main( void )
{
 
  struct liste * l;
  struct skieurs * s;
  int i = 0;
  char * mat = NULL;
 
  while ( i < 3 )
  {
    s = ( struct skieurs * ) malloc( sizeof( struct skieurs ) );
 
    printf( " entrez matricule \n" ); fflush( stdin ); fgets( mat, sizeof mat, stdin );
    s->matricule = atoi( mat );              // ou strtoi(mat);
    printf( " entrez nom du skieur : \n" ); fflush( stdin ); fgets( s->nom, sizeof s->nom, stdin );
    printf( " entrez prenom du skieur : \n" ); fflush( stdin ); fgets( s->prenom, sizeof s->prenom, stdin );
    add_itemInEnd( l, s );
    free( s );
    i++;
  }
 
  getch();
 
  free( l );
 
 
  l->courant = l->depart->suivant;
 
 
  while ( l )
  {
    s = ( struct skieurs * ) l->courant->data;
    printf( "  %d  -- %s -- %s \n", s->matricule, s->nom, s->prenom );
    free( s );
  }
 
  getch();
 
 
 
 
 
 
}
/* fin prog */

Mon liste.c

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#ifndef _liste_c_
#define _liste_c_
#include <stdlib.h>
#include <stdio.h>
 
 
// Déclaration de mes structures de données
//************************************************************************
typedef struct cellule
{
  void * data; //pointeur sur structure
  struct cellule * precedent;
  struct cellule * suivant;
 
};
 
 
 
typedef struct liste
{
  struct cellule * depart;
  struct cellule * courant;
  struct cellule * fin;
  int size;
};
 
 
 
//Initialisation de la liste
//**************************************************************************
void initList( struct liste * l )
{
  l->depart = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  l->fin = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  l->fin->precedent = l->depart;
  l->depart->suivant = l->fin;
  l->fin->suivant = NULL;
  l->depart->precedent = NULL;
  l->size= 0;
 
 
}
 
// Ajout d'un élement dans la liste
//***************************************************************************
 
 
void add_itemInEnd( struct liste * l, void * data )
{
 
 
 l->courant = l->depart->suivant;
 
 
  while ( l )
  {
    if ( l->courant->suivant == NULL )
    {
      l->courant->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
      l->courant->precedent->suivant = l->courant;
      l->courant->suivant->precedent = l->courant;
      l->courant = l->courant->suivant;
      l->courant->data = data;
      l->fin=l->courant;
      l->fin->precedent=l->courant->precedent;
      l->courant->suivant = NULL;
 
 
    }
 
    else
    {
      l->courant = l->courant->suivant;
 
    }
 
  }
 
}
 
// Suppression d'un élement dans la liste
//*****************************************************************************
 
void delete_item( struct liste * l, void * data )
{
  int * element, * inserted;
  int deleted = 0;
  l->courant = l->depart->suivant;
 
 
  while ( l )
  {
    inserted = ( int * ) data;
 
    element = ( int * ) l->courant->data;
 
 
    if ( * inserted == * element )
    {
      l->courant->precedent->suivant = l->courant->suivant;
 
      l->courant->suivant->precedent = l->courant->precedent;
 
      free( l->courant );
      deleted = 1;
 
    }
    else
    {
      l->courant = l->courant->suivant;
 
    }
 
 
  }
 
  if ( deleted == 1 )
  {
    printf( " Item was deleted successfully\n" );
    getchar();
  }
 
  else
  {
    printf( " Item not found \n" );
    getchar();
  }
 
 
}
 
 
// Vide la liste
//******************************************************************************
 
int empty_list( struct liste * l )
 
{
  return ( l->depart->suivant == NULL && l->fin->precedent == NULL );
 
}
 
 
 
#endif
//***************************************************************************

Et le liste.h (au cas où )

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#ifndef  _liste_h_
#define _liste_h_
 
struct cellule {void *data;struct cellule *precedent;struct cellule *suivant;};
 
struct liste {struct cellule *depart;struct cellule *courant;struct cellule *fin ;};
 
void initList(struct liste *l);
 
void add_itemInEnd( struct liste * l, void * data );
 
void delete_item( struct liste * l, void * data );
 
int empty_list( struct liste * l );
 
#endif

Mon erreur :
***********
Sur C - builerx :arrow: au runtime, il me laisse encoder le 1er matricule , ensuite erreur de type : Access Violation .

Et sur Turbo C :arrow: null pointer assignement . Il encode 2 skieurs ensuite plus rien ! excepté -> Null pointer Exception .

A la compilation , il n'y a aucune erreur .

P.S : j'ai poster tous le code du <liste.c> mais ici , on ne s'intéresse qu'à la fonction "add_itemInEnd " ...

Merci pour votre aide .

15/11/2005, 07h18
Médinoc
Code:

1 2 char *mat = NULL; fgets( mat, sizeof mat, stdin )
(c'est pourtant pas bien compliqué, si j'ai pu le voir alors que je ne suis pas bien réveillé...)
15/11/2005, 10h58
Fredy Kruger

Salut,

si tu ne fais plus que

s = ( struct skieurs * ) malloc( sizeof( struct skieurs ) );

il n'y a pas du tout réserver la place pour tous les deux pointers nom et prenom. Il faut les aussi réserver !!

s->nom = (char*)malloc (20);
etc.

Fredy Kruger
15/11/2005, 18h00
issou

Merci à vous .

Citation:

s = ( struct skieurs * ) malloc( sizeof( struct skieurs ) );

il n'y a pas du tout réserver la place pour tous les deux pointers nom et prenom. Il faut les aussi réserver !!

s->nom = (char*)malloc (20);
etc.

Je pense pas que c'est juste , parce que pourquoi refaire encore un malloc pour le nom et lui réserver 20 octets pour le nom ? Ca ne sert à rien alors de travailler avec des pointeurs, autant déclarer char nom[20] et rester en statique.

Apparemment, le C alloue l'espace nécessaire en allouant directement de la mémoire à toute la structure . Comment il s'y prend, j'ai déja chercher à savoir mais sans rien trouver .

J'ai corrigé 2 ou 3 petites choses qu'on m'a expliqué mais j'ai toujours le probleme . J'ai essayé "d'isoler mon erreur" pour savoir plus ou moins d'où elle provient . Apparemment dans la fonction "AddItemInEnd" .A la sauvegarde en mémoire de ma structure dans ma liste, ca bug .

-> L'erreur est null pointer Assignement .

Merci de votre patience et de votre aide.

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
ifndef _liste_c_
  #define _liste_c_
  #include <stdlib.h>
  #include <stdio.h>
 
 
// Déclaration de mes structures de données
//************************************************************************
typedef struct cellule
{
  void * data; //pointeur sur structure
  struct cellule * precedent;
  struct cellule * suivant;
 
};
 
 
 
typedef struct liste
{
  struct cellule * depart;
  struct cellule * courant;
  struct cellule * fin;
  int size;
};
 
 
 
//Initialisation de la liste
//**************************************************************************
void initList( struct liste * l )
{
  l->depart = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  l->fin = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  l->fin->precedent = l->depart;
  l->depart->suivant = l->fin;
  l->fin->suivant = NULL;
  l->depart->precedent = NULL;
  l->size = 0;
 
 
}
 
// Vide la liste
//******************************************************************************
 
int empty_list( struct liste * l )
{
  if ( l->depart->suivant == l->fin ) return 0; // si vide renvoi 0
 
  else
    return 1;
 
}
 
 
 
 
// Ajout d'un élement dans la liste
//***************************************************************************
 
 
void add_itemInEnd( struct liste * l, void * data )
{
 
 
  l->courant = l->depart->suivant;
 
  if ( empty_list( l ) != 0 )
  {
    while ( l )
    {
      if ( l->courant->suivant == NULL )
      {
        l->courant->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
        l->courant->precedent->suivant = l->courant;
        l->courant->suivant->precedent = l->courant;
        l->courant = l->courant->suivant;
        l->courant->data = data;
        l->fin->precedent = l->courant; //fin->precedent pointe vers le dernier element de la liste
        l->courant->suivant = NULL;
        l->size++;
 
 
      }
 
 
 
      else
      {
        l->courant = l->courant->suivant;
 
      }
 
    }
 
  }
 
  else // If list is empty
  {
    l->depart->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
    l->depart->suivant->data = data;
    l->depart->suivant->suivant = l->fin;
    l->depart->suivant->precedent = l->depart;
    l->fin->precedent = l->depart->suivant;
  }
 
}
 
 
// Suppression d'un élement dans la liste
//*****************************************************************************
 
void delete_item( struct liste * l, void * data )
{
  int * element, * inserted;
  int deleted = 0;
  l->courant = l->depart->suivant;
 
 
  if ( !empty_list( l ) )
  {
 
    while ( l )
    {
      inserted = ( int * ) data;
 
      element = ( int * ) l->courant->data;
 
 
      if ( * inserted == * element )
      {
        l->courant->precedent->suivant = l->courant->suivant;
 
        l->courant->suivant->precedent = l->courant->precedent;
 
        free( l->courant );
        deleted = 1;
        l->size--;
      }
      else
      {
        l->courant = l->courant->suivant;
 
      }
 
 
    }
 
  }
 
  else
  {
    printf( " No item was found, the list is empty\n" );
 
    if ( deleted == 1 )
    {
      printf( " Item was deleted successfully\n" );
      getchar();
    }
 
    else
    {
      printf( "    The item you want delete was not found .Try another Id.\n" );
      getchar();
    }
 
 
  }
 
 
 
 
#endif

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
 
#include "liste.h"
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#include <string.h>
 
 
struct skieurs
{
  int matricule;
  char * nom;
  char * prenom;
 
};
 
 
 
void main( void )
{
 
  struct liste * l;
  struct skieurs * s;
  int i = 0;
 
initList(l);
 
  while ( i < 2 )
  {
    s = ( struct skieurs * ) malloc( sizeof( struct skieurs ) );
 
    printf( " entrez matricule \n" ); fflush( stdin ); scanf( "%i",s->matricule);
    printf( " entrez nom du skieur : \n" ); fflush( stdin ); fgets( s->nom, sizeof s->nom, stdin );
    printf( " entrez prenom du skieur : \n" ); fflush( stdin ); fgets( s->prenom, sizeof s->prenom, stdin );
    add_itemInEnd( l, s );
 
    i++;
  }
 
  getch();
 
 
 
 
  l->courant = l->depart->suivant;
 
 
  while ( l )
  {
    s = ( struct skieurs * ) l->courant->data;
    printf( "  %d  -- %s -- %s \n", s->matricule, s->nom, s->prenom );
 
  }
 
  getch();
 
 
 
 
}
/* fin prog */

16/11/2005, 18h57
DaZumba

Citation:

Envoyé par issou

Je pense pas que c'est juste , parce que pourquoi refaire encore un malloc pour le nom et lui réserver 20 octets pour le nom ? Ca ne sert à rien alors de travailler avec des pointeurs, autant déclarer char nom[20] et rester en statique.

Ben oui, en effet, si tu es certain que le nom ne dépassera pas 20 caractères.
Mais il n'en reste pas moins qu'après avoir alloué s, il faut allouer de l'espace pointé par les pointeurs membres nom et prenom. Ils ne vont pas s'allouer tout seul magiquement. Du coup, tu utilises des pointeurs non initialisés ou NULL, et crac...

Sinon, les trucs classiques:
- le cast avant malloc() c'est du C++
- vérifier le retour de malloc() qui peut échouer
- fflush(stdin) n'est pas valide
- scanf() est dangeureux pour les saisies
- getch() n'est pas standard, et conio ne sert à rien ici
- main retourne un int, jamais un void...
16/11/2005, 19h04
diogene
Code:

1 2 3 4 void main( void ) { .... scanf( "%i",s->matricule);
Tu dois passer l'ADRESSE de s->matricule

Code:

fgets( s->nom, sizeof s->nom, stdin );

Mais nom est un pointeur, pas une zone où mettre des char. Typiquement ( pour un pointeur sur 4 bytes), le nom ne peut dépasser 3 caractères. Idem pou prénom

Citation:

e pense pas que c'est juste , parce que pourquoi refaire encore un malloc pour le nom et lui réserver 20 octets pour le nom ? Ca ne sert à rien alors de travailler avec des pointeurs, autant déclarer char nom[20] et rester en statique.

En tout cas pour l'instant, rien n'est réservé: En l'état actuel des choses, les deux champs sont déclarés en char * et rien n'est alloué...

Donc, deux choix:
* Soit tu limites le nom et le prénom à un certain nombre de caractères et tu les déclares en tableau dans la structure

* Soit tu alloues la structure APRÈS avoir lu le nom et le prénom dans un grand buffer, et pour chaque structure, tu alloues juste la place pour nom et prénom
Code:

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 #define GRANDE_TAILLE 160 struct skieurs *newSkieur() { char buf1[GRANDE_TAILLE], buf2[GRANDE_TAILLE]; size_t taille1, taille2, tailleTotale; struct skieurs *pt_retour = NULL; printf("Nom : "); fflush(stdout); fgets(butf1, GRANDE_TAILLE, stdin); printf("Prénom : "); fflush(stdout); fgets(butf2, GRANDE_TAILLE, stdin); taille1 = strlen(buf1)+1; taille2 = strlen(buf2)+1; tailleTotale = sizeof(*pt_retour) + taille1 + taille2; pt_retour = malloc(tailleTotale); if(pt_retour) { struct skieurs *pt_apresRetour = pt_retour+1; char *pt_apresNom; pt_retour->nom = (char *)pt_apresRetour; pt_apresNom = pt_retour->nom + taille1; pt_retour->prenom = pt_apresNom; strncpy(pt_retour->nom, buf1, taille1); strncpy(pt_retour->prenom, buf2, taille2); } return pt_retour; }
PS: J'ai même pas essayé de le compiler, mais c'est l"idée générale.

16/11/2005, 22h51
issou

Merci beaucoup pour vos explications !! :wink:
17/11/2005, 00h57
issou

J'ai modifié tout ce qui a été dit , mais toujours une erreur au runtime

:arrow: null pointer assignement

Apparemment, dans ma fonction additemInEnd, j'essaierai d'allouer à une variable un pointeur "Null" ...Mais où je ne vois pas .... :!: :!:
17/11/2005, 08h25
Trap D
Problème ici:
Code:

1 2 3 l->courant = l->depart->suivant; if ( empty_list( l ) != 0 )
Tu ne crois pas que tu devrais tester empty_list avant de faire l->courant = l->depart->suivant ?

En fait j'ai modifié mon code, en combinant les conseils du forum et de mon prof ... Le premier element de la liste est inséré apparemment, mais une fois que le programme constate que la liste n'est plus vide , il bloque à la sauvegarde du deuxieme .

J'ai shématiser et mon dessin me semble correct , mais le résultat lui ne l'est pas :cry: .

Voila le code :

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
#include "liste.h" 
#include <stdlib.h> 
#include <conio.h> 
#include <ctype.h> 
#include <stdio.h> 
#include <string.h> 
 
 
struct skieurs 
{ 
  int matricule; 
  char nom[20]; 
  char prenom[20]; 
 
}; 
 
 
 
int main( void ) 
{ 
 
  struct liste * l; 
  struct skieurs * s; 
  struct cellule * courant; 
  int i = 0; 
  char mat[5]; 
 
  initList( & l ); 
 
  while ( i < 3 ) 
  { 
    clrscr(); 
    s = ( struct skieurs * ) malloc( sizeof( struct skieurs ) ); 
    printf( " entrez matricule \n" ); fflush( stdin ); fgets( mat, sizeof mat, stdin ); 
    s->matricule = atoi( mat ); 
    printf( " entrez nom du skieur : \n" ); fflush( stdin ); fgets( s->nom, sizeof s->nom, stdin ); 
    printf( " entrez prenom du skieur : \n" ); fflush( stdin ); fgets( s->prenom, sizeof s->prenom, stdin ); 
    add_itemInEnd( & l, s ); 
 
    i++; 
  } 
 
  getch(); 
 
  clrscr(); 
 
  courant = l->depart->suivant; 
 
  while ( courant->suivant != NULL ) 
  { 
    s = ( struct skieurs * ) courant->data; 
    printf( "  %i  -> %s --> %s \n", s->matricule, s->nom, s->prenom ); 
    courant = courant->suivant; 
  } 
 
 
 getchar(); 
 
 
 
  return 0; 
} 
/* fin prog */

Et le liste.C

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
: 
#ifndef _liste_c_
  #define _liste_c_
  #include <stdlib.h>
  #include <stdio.h>
 
 
// Déclaration de mes structures de données
//************************************************************************
typedef struct cellule
{
  void * data; //pointeur sur structure
  struct cellule * precedent;
  struct cellule * suivant;
 
};
 
 
 
typedef struct liste
{
  struct cellule * depart;
  struct cellule * fin;
 
};
 
 
 
//Initialisation de la liste
//**************************************************************************
void initList( struct liste * * l )
{
  ( * l )->depart = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  ( * l )->fin = ( struct cellule * ) malloc( sizeof( struct cellule ) );
  ( * l )->fin->precedent = ( * l )->depart;
  ( * l )->depart->suivant = ( * l )->fin;
  ( * l )->fin->suivant = NULL;
  ( * l )->depart->precedent = NULL;
 
 
 
}
 
// Vide la liste
//******************************************************************************
 
int empty_list( struct liste * l )
{
  int test = 1;
  if ( l->depart->suivant == l->fin )
  {
    test = 0; // si vide renvoi 0
  }
  return test;
 
}
 
// Ajout d'un élement dans la liste
//***************************************************************************
 
void add_itemInEnd( struct liste * * l, void * data )
{
  struct cellule * courant;
 
  if ( empty_list( * l ) != 0 )
  {
    courant = ( * l )->depart->suivant;
 
    while ( courant )
    {
      if ( courant->suivant == NULL )
      {
        courant->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
        courant->precedent->suivant = courant;
        courant->suivant->precedent = courant;
        courant->suivant->data=data;
        ( * l )->fin->precedent = courant->suivant;
      }
 
      else
      {
        courant = courant->suivant;
 
      }
 
    }
 
  }
 
  else // If list is empty
  {
    ( * l )->depart->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
    ( * l )->depart->suivant->data = data;
    ( * l )->depart->suivant->precedent = ( * l )->depart;
    ( * l )->depart->suivant->suivant = ( * l )->fin;
    ( * l )->fin->precedent = ( * l )->depart->suivant;
 
  }
}

Merci encore pour votre aide, apres promis je vous laisse tranquille :wink:

Salut

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
  if ( empty_list( * l ) != 0 )
  {
    courant = ( * l )->depart->suivant;
 
    while ( courant )
    {
      if ( courant->suivant == NULL )
      {
        courant->suivant = ( struct cellule * ) malloc( sizeof( struct cellule ) );
        courant->precedent->suivant = courant;
        courant->suivant->precedent = courant;
        courant->suivant->data=data;
        ( * l )->fin->precedent = courant->suivant;
      }
 
      else
      {
        courant = courant->suivant;
 
      }
 
    }
 
  }

Tu n'aurais pas un problème ici ??
Que se passe-t-il si courant = ( * l )->depart->suivant; est NULL d'entrée ??