IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

probleme allocation dynamique


Sujet :

C

  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut probleme allocation dynamique
    Bonjour a tous,
    j'ai un problème je suis débutant et j'essaye de faire un gestionnaire de message, mais j'ai un probleme avec l allocation dynamique ou la sauvegarde des donnees je sais pas trop en fait...

    voila le code de mon main :
    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
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    #include "stdafx.h"
    #include "gestionnaire.h"
    #include "stdio.h"
    #include "conio.h"
    #include "ctype.h"
    #include "string.h"
     
     
    int _tmain(int argc, _TCHAR* argv[])
    {
    	int dCode_error = 0 ;
    	int dChoix = 'null';
    	char *pMsg;
    	int dCodeChoix = 0;
     
    	while(dCodeChoix == 0)
    	{
    		printf("\n FAITES VOTRE CHOIX ");
    		printf("\n\n           1 : Initialisation");
    		printf("\n\n           2 : Nouveau message");
    		printf("\n\n           3 : Affichage des erreurs");
    		printf("\n\n           0 : Quitter");
    		printf("\n\n VOTRE CHOIX : ");
    		dChoix = 'null';
    		fflush(stdin);
    		scanf("%d", &dChoix);
     
    		if ((dChoix > -1) && (dChoix < 4))
    		{
    			switch (dChoix)
    			{
    			case 1 :
    				GmInit(&dCode_error);
    				break;
    			case 2 :
    				Req_Msg (&pMsg);
    				gmAdd (pMsg, &dCode_error);
    				break;
    			case 3 :
    				gmDisplay (&dCode_error);
    				break;
    			case 0 :
    				printf(" \n\n APPUYER SUR UNE TOUCHE POUR FERMER CETTE FENETRE ..."); 
    				getche();
    				return 0;
    			}
    		}
    		else
    		{
    			printf("\n\n *** ATTENTION, Vous n'avez pas entrer un choix correct, recommencer \n\n");
    			dCodeChoix = 0;
    		}
    	}
    Ce Code ne dois pas etre modifié,

    ensuite voila le code des fonction.cpp
    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
    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
     
    #include "stdio.h"
    #include "stdafx.h"
    #include "string.h"
    #include "stdlib.h"
    #include "gestionnaire.h"
     
    #define TBLOC 9              // Macro private
     
     
    void Req_Msg (char **pMsg);                      // les prototypes private doivent se trouver dans le fichier .cpp ou ils sont utilisés.
    void AddBloc (char ***ppTabDynamique,int *dPosMax);  // les prototypes private doivent se trouver dans le fichier .cpp ou ils sont utilisés.
     
     
    //static char *(*tTab)[] ;    // Pointeur sur un tableau de pointeur de char
    static char **tTab;
    static int dPosCour = 0 ;
    static int dPosMax = 0 ;
     
     
    // Initialisation du tableau       ***************
     
    void GmInit(int *pRC)
    {
    	if (dPosCour < 1)         //   si le tableau est vide
    	{
    		dPosCour = 0;
    		*pRC = GM_OK;
    		printf("\n                        Fin GmInit, Le tableau etait vide \n");
    		printf("\n                        Le tableau dispose de %d places \n", dPosMax);
    	}
    	else                     // si le tableau n'est pas vide
    	{
    		int dIndex = 0 ;
    		for(dIndex = 0 ; dIndex < dPosCour ; dIndex++)
    		{
    			free(tTab[dIndex]); 
    		}
    		*pRC = GM_ERROR;
    		dPosCour = 0;
    		printf("\n                        Fin GmInit, Le tableau a ete reinitialiser \n");
    		printf("\n                        Le tableau dispose de %d places \n", dPosMax);
    	}
     
    }
     
    // Sous Fonction pour ajout de message, demande le message..
    void Req_Msg (char **pMsg)
    {
    	printf("\n                        on entre dans la fonction Req_Msg");
    	char sChaine[500];
    	int dLChaine ;
    	char *tTabMsg ;
    	printf("\n Entrez votre chaine : \n");
    	fflush(stdin);
    	scanf("%s", sChaine);
    	fflush(stdin);
    	printf("\n                        Votre chaine stocke dans sChaine est : %s", sChaine);
    	dLChaine = strlen(sChaine);
    	tTabMsg = (char *)malloc(dLChaine * sizeof(char));
    	strcpy(tTabMsg, sChaine);
    	*pMsg = tTabMsg ;
    }
     
    // sous fonction pour allocation dynamique du tableau contenant les adresse pTabDynamAdress
    void AddBloc (char ***ppTabDynamique,int *dPosMax)
    {
    	printf("\n                        on entre dans la fonction AddBloc \n");
    	char *pTab ;
    	pTab = (char *)malloc((*dPosMax + TBLOC) * sizeof(char));
    	*ppTabDynamique = &pTab;
    	printf("\n                        *dPosMax + TBLOC-1 = %d \n", *dPosMax + TBLOC - 1);
    	*dPosMax = *dPosMax + TBLOC -1 ;
    	printf("\n   TABLEAU ALLOUE DYNAMIQUEMENT \n");
    	printf("\n   ppTabDynamique = %d \n", ppTabDynamique);
    	if (ppTabDynamique == NULL)
    	{
    		printf("ERREUR ALLOCATION DYNAMIQUE");
    	}
    }
     
    // Ajout d'un message             *****************/
    void gmAdd (char *pMsg, int *pRC)
    {
    	printf("\n                        on entre dans la fonction gmAdd \n");
    	printf("\n                        dPositionCour = %d \n", dPosCour);
    	printf("\n                        dPositionMax = %d \n", dPosMax);
    	printf("\n                 PLACES RESTANTES AVANT INSERTION: %d places", dPosMax-dPosCour);
    	int dLong ;
     
    	if (dPosCour > dPosMax - 1)
    	{
    		printf("\n                        LIGNE avant de rentrer dans AddBlock");
    		AddBloc (&tTab, &dPosMax);
    		printf("\n                        LIGNE apres etre sorti de AddBlock");
    	}
    	dLong = strlen(pMsg);
    	printf("\n                        Position Courante av printf = %d", dPosCour);
    	printf("\n                        Longueur dLong = %d", dLong);
    	printf("\n                        Chaine en utilisant le pointeur msg= %s", pMsg);
    	tTab[dPosCour]= (char *)malloc((dLong + 1) * sizeof(char));
    	strcpy (tTab[dPosCour], pMsg);
    	printf("\n                        Chaine en utilisant le pointeur tTab[dPosCour] = %s", tTab[0]);
    	//printf("\n                        Chaine en utilisant le pointeur tTab[dPosCour] = %s", tTab[0]);
    	printf("\n                        Position Courante apres printf = %d", dPosCour);
    	dPosCour++;
    	printf("\n                 PLACES RESTANTES APRES INSERTION: %d places", dPosMax-dPosCour);
    	printf("\n                        Position Courante apres ++ = %d", dPosCour);
    }
     
    // Affichage des messages         ****************
    void gmDisplay (int *pRC)
    {
    	if(dPosCour > 0)
    	{
    		printf("\n                        Chaine en utilisant le pointeur tTab[dPosCour] = %s", tTab[0]);
    		printf("\n                        on entre dans la fonction GmDisplay \n");
    		printf("\n                        Position Courante = %d", dPosCour);
    		printf("\n ** AFFICHAGE TABLEAU ** \n");
    		printf("\n                        Chaine en utilisant le pointeur tTab[dPosCour] = %s", tTab[0]);
    		int dIndex = 0;
    		for (dIndex = 0 ; dIndex < dPosCour; dIndex++)
    		{
    			printf("\n      %s",tTab[dIndex]); 
    		}
    		*pRC = GM_OK;
    	}
    	else
    	{
    		printf("\n ** LE TABLEAU EST VIDE ** \n");
    	}
    }
    pourquoi cela ne fonctionne pas ?
    pk dans la fonction gmAdd si je fais un printf du tab[0] sa fonctionne et si je répète exactement la meme ligne juste en dessous sa ne fonctionne plus ?

    merci d'avance

  2. #2
    Membre très actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2010
    Messages
    254
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2010
    Messages : 254
    Par défaut
    Ouh de très sales choses dans ce code !

    pour commencer :
    Un conseil, ne dépasse jamais les 2 étoiles. Hésite pas à faire des return dans tes fonctions (pourtant je suis un grand fan du mot void ), ça simplifiera ton code et il sera plus lisible parce que la on se perd dans tes pointeurs.

    Sinon pour ton problème je ne sais pas si c'est ça mais dans ta fonction Req_Msg oublie pas dans le malloc(dlChaine + 1 * sizeof...
    Il est possible aussi que tu te perde dans tes adresses de pointeurs.

    Et quand tu dis ça ne fonctionne plus tu veut dire que le programme plante, boucle infinie ou tout simplement s'arrête?

  3. #3
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    Le programme plante si je répète deux fois un printf du tableau tTab et ce juste un après l'autre je comprend pas..

    et pour le ***ppTabDynamique tu ferais comment alors ?
    cette fonction a pour but d allouer des blocs de cellule supplémentaire, si je veux utiliser un return pour retourner une adresse sa serait possible ?

    merci de ton aide

  4. #4
    Membre très actif
    Homme Profil pro
    Étudiant
    Inscrit en
    Novembre 2010
    Messages
    254
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Novembre 2010
    Messages : 254
    Par défaut
    Voila comment tu fais:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    tTab = AddBloc (tTab, &dPosMax);
    Sinon pour le plantage ca veut dire que la chaine que tu essaye d'afficher ne contient peut être pas de '\0' à la fin. Je te rappelle que la fonction strcpy() ne rajoute pas de NULL à la fin s'il n'existe pas dans la chaine initiale. Donc vérifie bien que tes chaines de caractères soit terminer par un '\0'. Et aussi ton tableau tTag n'est pas alloué il faut que tu fasse un
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    tTab = malloc(taille_que_tu_veut * sizeof(char *));

  5. #5
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    -
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    static char **tTab;
    static int dPosCour = 0 ;
    static int dPosMax = 0 ;
    L'utilisation de variables globales est-elle vraiment nécessaire ? Ce n'est pas cela qui va améliorer la clarté du programme.

    - Erreur Fatale :
    La fonction AddBloc() purgée de ses printf() est
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    void AddBloc (char ***ppTabDynamique,int *dPosMax)
    {
    	char *pTab ;
    	pTab = (char *)malloc((*dPosMax + TBLOC) * sizeof(char));
    	*ppTabDynamique = &pTab;
    	*dPosMax = *dPosMax + TBLOC -1 ;
    }
    Tu renvoies l'adresse d'une variable locale (ici celle de pTab), ce qu'on ne doit jamais faire : la variable locale n'existe plus en sortie de fonction et l'adresse pointe dans les décors.

  6. #6
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    re bonjour,
    je n'aarive toujours pas, j essaye avec un void, sa devrait pas etre si complique mais j arrive pas, j'ai fais le meme exercice avec un tableau de taille fixe et la sa marche sans probleme, ici j veux faire une fonction qui rajoute des blocs mais pas moyen :-( je deviens fou

    Si dans le main de declare un pointeur tTab

    puis que je fais une fonction pour rajouter des blocs dont le prototype est :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    void AddBloc (char *tTab,int *dPosMax);
    et le code :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    void AddBloc (char *tTab,int *dPosMax)
    {
    	char *pTab ;
    	pTab = (char *)malloc((*dPosMax + TBLOC) * sizeof(char));
    	tTab = pTab;
    	*dPosMax = *dPosMax + TBLOC -1 ;
    	if (tTab == NULL)
    	{
    		printf("ERREUR ALLOCATION DYNAMIQUE");
    	}
    }
    cela est il correct jusque la ? aurais je bien un tableau de (*dPosMax + TBLOC) cellules pouvant chacunes contenir l'adresse d'un autre tableau ??

    pour me déplacer de cellule est il correct de faire par exemple tTab[0] = ... ???
    ou plutot tTab + 0 = ... ???

    merci de votre aide

  7. #7
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    1 - Abandonne les variables globales ; tu ne sais pas les utiliser et elles sont plus que probablement inutiles. Utilise le passage par paramètres.

    2 - Le comportement de fflush(stdin) est indéfini et dépend de l'implémentation. Le comportement de fflush() n'est défini que pour des flux de sortie (comme stdout). Si tu veux purger le tampon clavier, tu trouveras ton bonheur dans la FAQ :
    A quoi sert la fonction fflush ?
    Pourquoi ne faut-il pas utiliser fflush(stdin) pour vider le buffer clavier ?
    Comment vider le buffer clavier ?

    3- Dans ta fonction AddBloc(), tTab est une variable locale qui n'a rien à voir avec la variable globale tTab. Quand tu fais tTab = pTab; tu modifies la variable locale et laisse inchangé la variable globale. Du coup, cette instruction ne fait rien du tout au final puisque la variable locale sera détruite en sortie de fonction.
    La façon la plus naturelle est de renvoyer l'adresse du bloc alloué :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    char * AddBloc(int *dPosMax)
    {
       char *pTab = (char*) malloc(*dPosMax + TBLOC);// le cast si C++
       *dPosMax = *dPosMax + TBLOC -1 ;
       if (pTab == NULL)
       {
          printf("ERREUR ALLOCATION DYNAMIQUE");
       }
       return pTab;
    }
    ....
    tTab = AddBloc(&dPosMax);
    4-
    cela est il correct jusque la ? aurais je bien un tableau de (*dPosMax + TBLOC) cellules pouvant chacunes contenir l'adresse d'un autre tableau ??
    Non. Les éléments alloués sont des char. Si tu veux des éléments pouvant contenir des adresses de tableaux de char, il faut allouer des pointeurs sur char , char *
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    char ** AddBloc(int *dPosMax)
    {
       char **pTab = (char**) malloc((*dPosMax + TBLOC)*sizeof (char*);// le cast si C++
    ....
       return pTab;
    }
    pour me déplacer de cellule est il correct de faire par exemple tTab[0] = ... ???
    ou plutot tTab + 0 = ... ???
    On accède aux éléments d'un tableau par tTab[i]. Ceci désigne l'élément à l'adresse tTab+i. On peut donc également accéder à cet élément en écrivant *(tTab+i) ce qui est équivalent à tTab[i].

  8. #8
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    c'est un exercice afin justement d apprendre... je suis une formation et l utilite des variable globale est justement obligatoire....

    Pour la fonction AddBloc tu dis que la variable tTab est une variable locale, t es sur ? car elle est donné via un pointeur en paramètre, pour la variable pTab la c est du local mais tTab ?

  9. #9
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    re bonjour,
    j'arrive tout doucement à ce que je veux, la fonction AddBloc fonctionne, par contre je viens de m'apercevoir qu'elle ne peut allouer qu'un seul bloc étant donné qu'il n'y a pas de réalloc, ce qui fera pas l affaire...

    char ** AddBloc (int *dNbrCelTot); // le prototype

    // La fonction :

    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
     
    char ** AddBloc(int *dNbrCelTot)
    {
    	char **pTab;
     
    	if (*dNbrCelTot == 0 )
    	{
    	    pTab = (char**) malloc((*dNbrCelTot + TBLOC)*sizeof(char *));// le cast si C++
    		*dNbrCelTot = *dNbrCelTot + TBLOC ;
    		if (pTab == NULL)
    		{
    			printf("ERREUR ALLOCATION DYNAMIQUE");
    		}
    		return pTab;
    	}
    }
    // l'appel a la fonction
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    tTab = AddBloc(&dNbrCelTot);
    mon tTab est déclarer comme :
    static char **tTab;

    Perso je pense que la fonction AddBloc doit recevoir en parametre le tTab et le modifier ou lui retourner la nouvelle adresse sa sa change pas grand chose mais comment faire j'ai essayer plusieurs truc mais sans succes..

    merci de votre aide

  10. #10
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    1-
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    Pour la fonction AddBloc tu dis que la variable tTab est une variable locale,
    Oui, puisque tu déclares tTab comme paramètre de la fonction. Cela masque la déclaration de la globale du même nom pour l'ensemble de la fonction

    2- Ta nouvelle fonction présente un défaut : Il manque un return ... lorsque *dNbrCelTot != 0 .

    3-
    Perso je pense que la fonction AddBloc doit recevoir en parametre le tTab et le modifier
    Tu peux faire ce choix, auquel cas, il faut passer l'adresse du tTab en question de façon à ce que la fonction puisse le modifier (suivant le même principe que pour dNbrCelTot)

    4-
    l utilite des variable globale est justement obligatoire
    C'est regrettable et pédagogiquement nul.
    Si tu as l'obligation de passer par des globales et de polluer ainsi ton code, soyons logique. Puisque tTab est global, il n'a pas besoin d'être en paramètre. Puisque dPosMax est global, il n'a pas besoin d'être passé en paramètre (je me réfère à ton tout premier post).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    void AddBloc(void)
    {
      if (dPosMax == 0 )
      {
        tTab = (char**) malloc((dPosMax + TBLOC)*sizeof(char *));// le cast si C++
        dPosMax = dPosMax + TBLOC ;
        if (tTab == NULL) printf("ERREUR ALLOCATION DYNAMIQUE");
      }
    }

  11. #11
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    re,
    je suis biece...
    mon **pTab declaré en static je peux donc l'utiliser dans ma fonction pour le résultat suivant :

    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
     
    char ** AddBloc(int *dNbrCelTot)
    {
    	char **pTab;
     
    	if (*dNbrCelTot == 0 )
    	{
    	    pTab = (char**) malloc((*dNbrCelTot + TBLOC)*sizeof(char *));// le cast si C++
    		*dNbrCelTot = *dNbrCelTot + TBLOC ;
    		if (pTab == NULL)
    		{
    			printf("ERREUR ALLOCATION DYNAMIQUE");
    		}
    		return pTab;
    	}
    	else
    	{
    		pTab = (char**) realloc(tTab,(*dNbrCelTot + TBLOC)*sizeof(char *));
    		*dNbrCelTot = *dNbrCelTot + TBLOC ;
    		if (pTab == NULL)
    		{
    			printf("ERREUR RE-ALLOCATION DYNAMIQUE");
    		}
    		return pTab;
    	}
    }
    et sa marche :-)

    N.B : Si vos réalisation ne sont pas à la hauteur de vos espérances, dites vous que le grand chêne lui aussi, au départ n'était qu'un petit gland :-)

    Merci a touss

  12. #12
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    1- Je crois que tu confonds les choses :
    Dans cette fonction, pTab n'est toujours pas la globale mais la variable locale pTab déclarée ici :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    char ** AddBloc(int *dNbrCelTot)
    {
    	char **pTab;
    Si ça marche, c'est parce que tu retournes la valeur de cette variable locale et que tu copies sa valeur dans la globale pTab :
    Ca marchera aussi bien si dans la fonction, tu remplaces pTab partout par xyz.

    2- realloc() ne s'emploie pas de cette façon : realloc() peut échouer et renvoyer NULL. Si cela se produit, la mémoire précédemment allouée est inchangée. Si tu écris
    en cas d'échec, p devient NULL et il y aura une fuite mémoire avec la mémoire précédemment allouée qui devient inaccessible. On procède plutôt de la façon suivante :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    q = realloc(p,....)
    if(q != NULL)
    {
       p = q;
       ....
    }
    else ... // la mémoire précédemment allouée est toujours accessible par p.
    A noter que p = realloc(NULL,...) est équivalent à p = malloc(....) ce qui peut simplifier le codage.

  13. #13
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2010
    Messages
    28
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Octobre 2010
    Messages : 28
    Par défaut
    merci pour tes explications précise, je m'explique pas toujours très bien mais la je pense que c est bon j vais faire la petit modif pour le realloc en cas d erreur mais sinon sa fonctionne..

    merci

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. probleme allocation dynamique de mémoire
    Par totoscill dans le forum C
    Réponses: 18
    Dernier message: 28/02/2008, 16h44
  2. probleme d'allocation dynamique de mémoire
    Par Blo0d4x3 dans le forum C
    Réponses: 2
    Dernier message: 13/03/2007, 07h53
  3. Probleme d'allocation dynamique
    Par Xav987 dans le forum C++
    Réponses: 6
    Dernier message: 04/03/2007, 13h43
  4. probleme allocation dynamique
    Par ciberju dans le forum C
    Réponses: 2
    Dernier message: 28/08/2006, 09h40
  5. probleme d'allocation dynamique
    Par vince3320 dans le forum C
    Réponses: 10
    Dernier message: 22/04/2004, 16h27

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo