Malloc ne m'aime plus..... sig sig
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
-
2 déc. 2007 à 20:23
le père - 3 déc. 2007 à 00:56
le père - 3 déc. 2007 à 00:56
A voir également:
- Malloc ne m'aime plus..... sig sig
- Capcut sig - Télécharger - Montage & Édition
- [C] malloc et sa librairie "standard" ✓ - Forum C
9 réponses
fiddy
Messages postés
11069
Date d'inscription
samedi 5 mai 2007
Statut
Contributeur
Dernière intervention
23 avril 2022
1 845
2 déc. 2007 à 20:34
2 déc. 2007 à 20:34
Salut,
Déjà, on évite le langage texto, ensuite on évite les insultes.
Et si tu veux de l'aide, poste-nous ton programme, qui doit certainement contenir une erreur de programmation.
Cdt
Déjà, on évite le langage texto, ensuite on évite les insultes.
Et si tu veux de l'aide, poste-nous ton programme, qui doit certainement contenir une erreur de programmation.
Cdt
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
2 déc. 2007 à 20:55
2 déc. 2007 à 20:55
désolé d'avoir insulté une fonction (et quel fonction!!!:-)), je comprend que ce n'est pas jolie et je m'excuse.
voici les deux fonctions:
The FIRST
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Structures.cpp"
#include "Constantes.cpp"
#include "protyp_fctions.h"
// Cette fonction charge le fichier des clients en memoire celon un arbre rouge
// et noir.
noeud *Arbre_NR_Clients(void)
{
// Declaration des variables.
noeud *ClientRacine;
StructClient *Client;
noeud *ClientTest;
FILE *FichierClient;
int compt=0;
char ligne[255];
char *p;
p= (char*)malloc(2);
// Ouverture du fichier.
FichierClient = fopen("FOURNISSEURS.CSV","r+");
// La construction de l'arbre ce fera par lecture sequentielle du fichier qui
// repertorie les clients.
while(fgets(ligne,sizeof ligne,FichierClient), !feof(FichierClient))
{
printf("%d:%s\n",compt,ligne);
char *debut;
// Il faut ensuite replacer la ligne lue dans la structure.
debut = strtok (ligne,";");
//printf("%s\n",debut);
if(compt!=0)
printf("%s\n",ClientRacine->InfoClient->CodeClient);
Client->CodeClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->CodeClient , debut);
debut = strtok (NULL,";");
Client->NomClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->NomClient , debut);
debut = strtok (NULL,";");
Client->MDP = (char*) malloc(strlen(debut)+1);
strcpy(Client->MDP , debut);
debut = strtok (NULL,";");
Client->SoldeCompteClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->SoldeCompteClient , debut);
// Le premier client lu est provisoirement inséré comme etant
// la racine de l'arbre. Mais les loies de l'arbre noir et rouge peuvent
// si necessaire modifier ce noeud pour garder l'arbre equilibré.
if (compt==0)
{
ClientRacine = NouveauNoeud(NULL,Client);
printf("%s:%s\n","Premier client enregistre en memoire",
ClientRacine->InfoClient->NomClient);
compt++;
}
else
{
ClientTest = insersion(ClientRacine,Client);
}
free(Client->CodeClient);
free(Client->NomClient);
free(Client->MDP);
free(Client->SoldeCompteClient);
}
fclose(FichierClient);
printf("%s\n"," Chargement de l'arbre binaire rouge et noir effectué.");
free (p);
return ClientRacine;
}
and the SECOND (ou malloc debloque (un jeu de mot tout en finesse..))
// Cette fonction crée un nouveau noeud et retourne l'adresse du noeud crée
noeud *NouveauNoeud(noeud *papa,StructClient *Client)
{
noeud *N;
printf("%s\n", "Creation d'un nouveau noeud:");
printf("%s->%s\n"," Code",Client->CodeClient);
printf("%s->%s\n"," Nom",Client->NomClient);
printf("%s->%s\n"," MotDePasse",Client->MDP);
printf("%s->%s\n"," Solde",Client->SoldeCompteClient);
N->FilsDroite = (noeud*) malloc(sizeof (noeud));
N->FilsGauche = (noeud*) malloc(sizeof (noeud));
N->pere = (noeud*) malloc(sizeof (noeud));
N->couleur = (int*) malloc(sizeof(ROUGE));
//************************************************************************************
// ce print m'affiche que l'adresse de Client->NomClient et N->couleur est la meme...*
//************************************************************************************
printf("%s:%d:%d:%d\n",Client->NomClient,&Client->NomClient,&N->couleur,&Client->SoldeCompteClient);
N->InfoClient->CodeClient = (char*) malloc(strlen (Client->CodeClient)+1);
N->InfoClient->MDP = (char*) malloc(strlen(Client->MDP)+1);
N->InfoClient->NomClient = (char*) malloc(strlen(Client->NomClient)+1);
N->InfoClient->SoldeCompteClient = (char*) malloc(strlen(Client->SoldeCompteClient)+1);
N->FilsGauche = NULL;
N->FilsDroite = NULL;
N->pere = papa;
*N->couleur = ROUGE;// Le noeud inseré est initialement toujours de couleur rouge.
strcpy(N->InfoClient->CodeClient , Client->CodeClient);
strcpy(N->InfoClient->NomClient , Client->NomClient);
strcpy(N->InfoClient->MDP , Client->MDP);
strcpy(N->InfoClient->SoldeCompteClient , Client->SoldeCompteClient);
return N;
}
Et encore merci au valeureux paladins du c. J'esper pouvoir en devenir un moi aussi pour aider a mon tour.
voici les deux fonctions:
The FIRST
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Structures.cpp"
#include "Constantes.cpp"
#include "protyp_fctions.h"
// Cette fonction charge le fichier des clients en memoire celon un arbre rouge
// et noir.
noeud *Arbre_NR_Clients(void)
{
// Declaration des variables.
noeud *ClientRacine;
StructClient *Client;
noeud *ClientTest;
FILE *FichierClient;
int compt=0;
char ligne[255];
char *p;
p= (char*)malloc(2);
// Ouverture du fichier.
FichierClient = fopen("FOURNISSEURS.CSV","r+");
// La construction de l'arbre ce fera par lecture sequentielle du fichier qui
// repertorie les clients.
while(fgets(ligne,sizeof ligne,FichierClient), !feof(FichierClient))
{
printf("%d:%s\n",compt,ligne);
char *debut;
// Il faut ensuite replacer la ligne lue dans la structure.
debut = strtok (ligne,";");
//printf("%s\n",debut);
if(compt!=0)
printf("%s\n",ClientRacine->InfoClient->CodeClient);
Client->CodeClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->CodeClient , debut);
debut = strtok (NULL,";");
Client->NomClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->NomClient , debut);
debut = strtok (NULL,";");
Client->MDP = (char*) malloc(strlen(debut)+1);
strcpy(Client->MDP , debut);
debut = strtok (NULL,";");
Client->SoldeCompteClient = (char*) malloc(strlen(debut)+1);
strcpy(Client->SoldeCompteClient , debut);
// Le premier client lu est provisoirement inséré comme etant
// la racine de l'arbre. Mais les loies de l'arbre noir et rouge peuvent
// si necessaire modifier ce noeud pour garder l'arbre equilibré.
if (compt==0)
{
ClientRacine = NouveauNoeud(NULL,Client);
printf("%s:%s\n","Premier client enregistre en memoire",
ClientRacine->InfoClient->NomClient);
compt++;
}
else
{
ClientTest = insersion(ClientRacine,Client);
}
free(Client->CodeClient);
free(Client->NomClient);
free(Client->MDP);
free(Client->SoldeCompteClient);
}
fclose(FichierClient);
printf("%s\n"," Chargement de l'arbre binaire rouge et noir effectué.");
free (p);
return ClientRacine;
}
and the SECOND (ou malloc debloque (un jeu de mot tout en finesse..))
// Cette fonction crée un nouveau noeud et retourne l'adresse du noeud crée
noeud *NouveauNoeud(noeud *papa,StructClient *Client)
{
noeud *N;
printf("%s\n", "Creation d'un nouveau noeud:");
printf("%s->%s\n"," Code",Client->CodeClient);
printf("%s->%s\n"," Nom",Client->NomClient);
printf("%s->%s\n"," MotDePasse",Client->MDP);
printf("%s->%s\n"," Solde",Client->SoldeCompteClient);
N->FilsDroite = (noeud*) malloc(sizeof (noeud));
N->FilsGauche = (noeud*) malloc(sizeof (noeud));
N->pere = (noeud*) malloc(sizeof (noeud));
N->couleur = (int*) malloc(sizeof(ROUGE));
//************************************************************************************
// ce print m'affiche que l'adresse de Client->NomClient et N->couleur est la meme...*
//************************************************************************************
printf("%s:%d:%d:%d\n",Client->NomClient,&Client->NomClient,&N->couleur,&Client->SoldeCompteClient);
N->InfoClient->CodeClient = (char*) malloc(strlen (Client->CodeClient)+1);
N->InfoClient->MDP = (char*) malloc(strlen(Client->MDP)+1);
N->InfoClient->NomClient = (char*) malloc(strlen(Client->NomClient)+1);
N->InfoClient->SoldeCompteClient = (char*) malloc(strlen(Client->SoldeCompteClient)+1);
N->FilsGauche = NULL;
N->FilsDroite = NULL;
N->pere = papa;
*N->couleur = ROUGE;// Le noeud inseré est initialement toujours de couleur rouge.
strcpy(N->InfoClient->CodeClient , Client->CodeClient);
strcpy(N->InfoClient->NomClient , Client->NomClient);
strcpy(N->InfoClient->MDP , Client->MDP);
strcpy(N->InfoClient->SoldeCompteClient , Client->SoldeCompteClient);
return N;
}
Et encore merci au valeureux paladins du c. J'esper pouvoir en devenir un moi aussi pour aider a mon tour.
Bonsoir,
Il a raison, fiddy, c'est pas bien du tout les gros mots.
Tu dis que malloc ne t'aime plus, je crois que le vrai problème c'est que tu ne l'as pas comprise. Situation classique :-D
Deux choses qui ne collent pas dans ton programme :
la série de
Tu désalloues la mémoire qui contient des données enregsitrées dans ton arbre ! Tu ne pourras pas les récupérer
Tu utilises le pointeur N . Quand a-t-il été initialisé ?
Prière de ne pas répondre que c'est cette ligne qui sert à l'initialiser. Cette ligne initialise un champ d'un noeud dont l'adresse serait dans N. Le problème c'est que N n'a jamais été initialisé à aucune adresse
D'autre part :
D'après la première ce des lignes, couleur serait un int. D'après la seconde, ce serait un int *. Alors c'est quoi finalement ?
Il a raison, fiddy, c'est pas bien du tout les gros mots.
Tu dis que malloc ne t'aime plus, je crois que le vrai problème c'est que tu ne l'as pas comprise. Situation classique :-D
Deux choses qui ne collent pas dans ton programme :
la série de
free(Client->CodeClient); free(Client->NomClient); free(Client->MDP); free(Client->SoldeCompteClient);
Tu désalloues la mémoire qui contient des données enregsitrées dans ton arbre ! Tu ne pourras pas les récupérer
N->FilsDroite = (noeud*) malloc(sizeof (noeud));
Tu utilises le pointeur N . Quand a-t-il été initialisé ?
Prière de ne pas répondre que c'est cette ligne qui sert à l'initialiser. Cette ligne initialise un champ d'un noeud dont l'adresse serait dans N. Le problème c'est que N n'a jamais été initialisé à aucune adresse
D'autre part :
N->couleur = (int*) malloc(sizeof(ROUGE)); *N->couleur = ROUGE;
D'après la première ce des lignes, couleur serait un int. D'après la seconde, ce serait un int *. Alors c'est quoi finalement ?
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
2 déc. 2007 à 22:17
2 déc. 2007 à 22:17
je considere Client comme une structure "bateau" qui lie les donne est ensuite est copier dans la structure d'un noeud fesant partie de l'arbre, ceci dans NouveauNoeud. Cette meme fonction renvoie le pointeur vers ce noeud crée....qui est utilisé dans mon prog d'insersion ci dessous (enfaite c ce pointeur qui initialise le noeud...):
// Cette fonction parcour l'arbre et insere un nouveau noeud. Si le noeud a inserer
// est deja present il retourne sa valeur sinon un ponteur nul
noeud *insersion (noeud *N, StructClient *Client)
{
// Dans la structure client que nous utilisons, l'element de comparaison sera
// le code du client.
if ( N->InfoClient->CodeClient == Client->CodeClient)
return N;
else if (strcmp(N->InfoClient->CodeClient,Client->CodeClient)< 0 )
{
if (N->FilsGauche != NULL)
insersion (N->FilsGauche, Client);
else
{
N->FilsGauche = NouveauNoeud(N,Client);
// Inserer un noeud dans un arbre binaire noir et rouge necessite de controler
// qu'a chaque insertion les prorpiétées de l'arbre ne sont pas modifiées.
InsersionCas1(N->FilsGauche);
}
return NULL;
}
else
{
if (N->FilsDroite != NULL)
insersion (N->FilsDroite, Client);
else
{
N->FilsDroite = NouveauNoeud(N,Client);
// Inserer un noeud dans un arbre binaire noir et rouge necessite de controler
// qu'a chaque insertion les prorpiétées de l'arbre ne sont pas modifiées.
InsersionCas1(N->FilsDroite);
}
return NULL;
}
}
Donc voila sa m'a l'air logique...
Puis pour la structure:
N->couleur = (int*) malloc(sizeof(ROUGE));
*N->couleur = ROUGE;
je ne vois pas ou est le pb
N->couleu est bien un pointeur
et la valeur kil pointe(*N->couleur) c'est bien la constante ROUGE.
// Cette fonction parcour l'arbre et insere un nouveau noeud. Si le noeud a inserer
// est deja present il retourne sa valeur sinon un ponteur nul
noeud *insersion (noeud *N, StructClient *Client)
{
// Dans la structure client que nous utilisons, l'element de comparaison sera
// le code du client.
if ( N->InfoClient->CodeClient == Client->CodeClient)
return N;
else if (strcmp(N->InfoClient->CodeClient,Client->CodeClient)< 0 )
{
if (N->FilsGauche != NULL)
insersion (N->FilsGauche, Client);
else
{
N->FilsGauche = NouveauNoeud(N,Client);
// Inserer un noeud dans un arbre binaire noir et rouge necessite de controler
// qu'a chaque insertion les prorpiétées de l'arbre ne sont pas modifiées.
InsersionCas1(N->FilsGauche);
}
return NULL;
}
else
{
if (N->FilsDroite != NULL)
insersion (N->FilsDroite, Client);
else
{
N->FilsDroite = NouveauNoeud(N,Client);
// Inserer un noeud dans un arbre binaire noir et rouge necessite de controler
// qu'a chaque insertion les prorpiétées de l'arbre ne sont pas modifiées.
InsersionCas1(N->FilsDroite);
}
return NULL;
}
}
Donc voila sa m'a l'air logique...
Puis pour la structure:
N->couleur = (int*) malloc(sizeof(ROUGE));
*N->couleur = ROUGE;
je ne vois pas ou est le pb
N->couleu est bien un pointeur
et la valeur kil pointe(*N->couleur) c'est bien la constante ROUGE.
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
2 déc. 2007 à 22:26
2 déc. 2007 à 22:26
En plus sa n'enleve pas le pb de mon malloc qui m'allou deux fois la meme adresse, pour deux donnée differentes et de type different!!!!
D'apres les derniers test sa devien carement de la teologie tout sa...
J'ai efface le malloc de Client->NomClient et je l'ai remplace par un malloc vers un autre pointeur p, ensuite j'initialise Client->NomClient = p ET IL ME RETOURNE TJ L'ADRESSE D'AVANT quand j'avais fait un malloc pour Client->NomClient...ya un truc qui ne vas pas avec mon compilateur la....
D'apres les derniers test sa devien carement de la teologie tout sa...
J'ai efface le malloc de Client->NomClient et je l'ai remplace par un malloc vers un autre pointeur p, ensuite j'initialise Client->NomClient = p ET IL ME RETOURNE TJ L'ADRESSE D'AVANT quand j'avais fait un malloc pour Client->NomClient...ya un truc qui ne vas pas avec mon compilateur la....
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
2 déc. 2007 à 22:40
2 déc. 2007 à 22:40
naturellement il va sans dire que le pointeur que malloc me donne pour p n'est pas le meme( je le print)...
p = (char*) malloc(strlen(debut)+1);
strcpy(p , debut);
Client->NomClient = p; printf("adr_nom_client:%d\n",&Client->NomClient);printf("adr_p:%d\n",&p);
Je sais pas si vous vous rendez compte mais sa m'affiche deux adresse differente...
Je vien peut'etre de donner la preuve mformel que les ordinateur on une conscience!!!!??
p = (char*) malloc(strlen(debut)+1);
strcpy(p , debut);
Client->NomClient = p; printf("adr_nom_client:%d\n",&Client->NomClient);printf("adr_p:%d\n",&p);
Je sais pas si vous vous rendez compte mais sa m'affiche deux adresse differente...
Je vien peut'etre de donner la preuve mformel que les ordinateur on une conscience!!!!??
1
je ne vois pas ou est le pb
N->couleu est bien un pointeur
et la valeur kil pointe(*N->couleur) c'est bien la constante ROUGE
Oups, tu as raison, là c'est moi qui fatigue.
2
je considere Client comme une structure "bateau" qui lie les donne ...etc
Si ceci répond à ma remarque sur tes "free", je maintiens cette remarque. Dans ton arbre, tu gardes une copie d'un pointeur sur un StructClient. Jusque là ça va. Mais cette StrucClient contient des pointeurs sur des zones que tu as désallouées : ils ne sont plus utilisables !
3
Tu n'as toujours pas dit où tu initialisais ton pointeur N de la fonction NouveauNoeud de ton post de 20h55. Pas dans les lignes en gras, j'espère. Quand tu fais N->champ=qqchose, tu initialises N->champ, pas N
En relisant, j''ai l'impression que tu n'initialises pas non plus Client dans Arbre_NR_Clients ???
je ne vois pas ou est le pb
N->couleu est bien un pointeur
et la valeur kil pointe(*N->couleur) c'est bien la constante ROUGE
Oups, tu as raison, là c'est moi qui fatigue.
2
je considere Client comme une structure "bateau" qui lie les donne ...etc
Si ceci répond à ma remarque sur tes "free", je maintiens cette remarque. Dans ton arbre, tu gardes une copie d'un pointeur sur un StructClient. Jusque là ça va. Mais cette StrucClient contient des pointeurs sur des zones que tu as désallouées : ils ne sont plus utilisables !
3
Tu n'as toujours pas dit où tu initialisais ton pointeur N de la fonction NouveauNoeud de ton post de 20h55. Pas dans les lignes en gras, j'espère. Quand tu fais N->champ=qqchose, tu initialises N->champ, pas N
En relisant, j''ai l'impression que tu n'initialises pas non plus Client dans Arbre_NR_Clients ???
casers
Messages postés
49
Date d'inscription
dimanche 18 novembre 2007
Statut
Membre
Dernière intervention
3 juin 2008
2 déc. 2007 à 23:36
2 déc. 2007 à 23:36
c vrai que c'est un peu complexe a comprendre. (v vous payé une touné a la fin...c le minimum)
Mais le N a deja ete initialise precedament car il est le fils d'un autre N . On initialise d'abort la racine et ses fils. Ensuite on insere les fils des fils de racine. ki s'initialise grace a NouveauNoeud qui renvoi un pointeur avec les fils initialisés...
Pour ce qui regarde la structure client elle doit ce reinitialiser a chaque fin de traitement afin de permetre le traitement du prochain enregistrement. Si vous remarquez, dans NouveauNoeud je copy les string dans de nouveau pointeur qui sont de nouveau noeud. Donc je n'ais plus besoin de la structure Client... elle est reinitialiser pour traiter la nouvelle lecture dans le fichier, qui sera elle meme ensuite copier dans de nouveaux noeuds, avec des nouveaux malloc, donc une adresse diferente.
Chai pas si je suis clair? ou si dans le fond je me goure completement?
En tout cas v me coucher( demain matin cour avec mon dirlo, tot) et vteste a l'ecole a paritr de 10h30.
Merci encore "le père"
Mais le N a deja ete initialise precedament car il est le fils d'un autre N . On initialise d'abort la racine et ses fils. Ensuite on insere les fils des fils de racine. ki s'initialise grace a NouveauNoeud qui renvoi un pointeur avec les fils initialisés...
Pour ce qui regarde la structure client elle doit ce reinitialiser a chaque fin de traitement afin de permetre le traitement du prochain enregistrement. Si vous remarquez, dans NouveauNoeud je copy les string dans de nouveau pointeur qui sont de nouveau noeud. Donc je n'ais plus besoin de la structure Client... elle est reinitialiser pour traiter la nouvelle lecture dans le fichier, qui sera elle meme ensuite copier dans de nouveaux noeuds, avec des nouveaux malloc, donc une adresse diferente.
Chai pas si je suis clair? ou si dans le fond je me goure completement?
En tout cas v me coucher( demain matin cour avec mon dirlo, tot) et vteste a l'ecole a paritr de 10h30.
Merci encore "le père"
Si vous remarquez, dans NouveauNoeud je copy les string dans de nouveau pointeur qui sont de nouveau noeud
re-oups ! non, je n'avais pas vu. Un autre point pour toi. Je devrais être couché depuis longtemps.
Mais ces malloc et strcopy sont inutiles : tu n'as qu'à recopier les pointeurs N->InfoClient->CodeClient= Client->CodeClient; etc et ne plus faire de free dans ta fonction arbre_NR_Clients.
Toujours (au moins) 2 pointeurs que tu n'initialises pas : Client dans arbre_NR_Clients et N dans insersion. Mais le N a deja ete initialise precedament car il est le fils d'un autre N. Je continuerai de dire que N n'est pas initialisé tant que tu ne me montreras pas une ligne avec N=...
(pour les pros du C qui passeraient par là, je sais qu'on pourrait aussi le faire par un pointeur sur un pointeur, mais ça m'étonnerait que casers le fasse)
S'il te plaît, donne-moi les copies des lignes d'initialisation de ces pointeurs, c'est à dire commençant par N= et Client=
Client->NomClient = p; printf("adr_nom_client:%d\n",&Client->NomClient);printf("adr_p:%d\n" ;,&p);
Je sais pas si vous vous rendez compte mais sa m'affiche deux adresse differente...
Ben oui, et heureusement !
Ce que tu affiches, ce sont les adresses des deux variables Client->NomClient et p. Ce sont deux variables différentes, elles n'ont aucune raison d'avoir la même adresse. Par contre, elles ont le même contenu puisque tu as fait NomClient = p. Pour voir ce contenu il faut imprimer NomClient et p, mais pas &NomClient et &p. Aurais-tu eu l'idée d'imprimer &x et &y pour voir si deux entiers ont la même valeur ? Non, tu aurais simplement imprimé x et y. Il n'y a pas de raison que ce soit différent pour les pointeurs.
Au passage, imprimer un pointeur avec un %d, c'est très gonflé. Un pointeur n'est pas un entier et s'il faisait une taille différente, ce qui est certainement le cas sur certaines machines, tu risques d'avoir des affichages aberrants.
re-oups ! non, je n'avais pas vu. Un autre point pour toi. Je devrais être couché depuis longtemps.
Mais ces malloc et strcopy sont inutiles : tu n'as qu'à recopier les pointeurs N->InfoClient->CodeClient= Client->CodeClient; etc et ne plus faire de free dans ta fonction arbre_NR_Clients.
Toujours (au moins) 2 pointeurs que tu n'initialises pas : Client dans arbre_NR_Clients et N dans insersion. Mais le N a deja ete initialise precedament car il est le fils d'un autre N. Je continuerai de dire que N n'est pas initialisé tant que tu ne me montreras pas une ligne avec N=...
(pour les pros du C qui passeraient par là, je sais qu'on pourrait aussi le faire par un pointeur sur un pointeur, mais ça m'étonnerait que casers le fasse)
S'il te plaît, donne-moi les copies des lignes d'initialisation de ces pointeurs, c'est à dire commençant par N= et Client=
Client->NomClient = p; printf("adr_nom_client:%d\n",&Client->NomClient);printf("adr_p:%d\n" ;,&p);
Je sais pas si vous vous rendez compte mais sa m'affiche deux adresse differente...
Ben oui, et heureusement !
Ce que tu affiches, ce sont les adresses des deux variables Client->NomClient et p. Ce sont deux variables différentes, elles n'ont aucune raison d'avoir la même adresse. Par contre, elles ont le même contenu puisque tu as fait NomClient = p. Pour voir ce contenu il faut imprimer NomClient et p, mais pas &NomClient et &p. Aurais-tu eu l'idée d'imprimer &x et &y pour voir si deux entiers ont la même valeur ? Non, tu aurais simplement imprimé x et y. Il n'y a pas de raison que ce soit différent pour les pointeurs.
Au passage, imprimer un pointeur avec un %d, c'est très gonflé. Un pointeur n'est pas un entier et s'il faisait une taille différente, ce qui est certainement le cas sur certaines machines, tu risques d'avoir des affichages aberrants.
