Passer un tableau dynamique en paramètre

Signaler
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005
-
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005
-
Salut tlm! J'aimerais savoir si je peux ou non passer en paramètre un tableau dynamique dont je n'ai pas encore alloué de mémoire(allocation à l'intérieur de la fonction). En gros, voila ce que je veux faire :

//variables globales


CString *tab;
CString *temp;
CString machaine = "test";
int nombre_element = 0;


void SetDynaArray(int &nb_element, CString tab[], CString temp[], CString elt)
{
if (nb_element)
{
tab= new CString[nb_element+1];
for (int i=0; i<nb_element; i++)
tab[i] = temp[i];
temp = tab;
}
else temp = new CString;
{
temp[nb_element++] = elt;
}
}


Appel de la méthode :
SetDynaArray(nombre_element, tab, temp, machaine);

Y a-t-il des erreurs et surtout comment puis-je régler mon probleme de tableau dynamique?

Merci

19 réponses

Messages postés
573
Date d'inscription
samedi 16 novembre 2002
Statut
Membre
Dernière intervention
9 avril 2008
1
Salut,

BYTE *pByte;
AllocateMemoryForpByte(&pByte);
delete [] pByte;

avec:
void AllocateMemoryForpByte(BYTE **ppData)
{
*ppData = new BYTE[256];
}
Messages postés
1536
Date d'inscription
samedi 21 décembre 2002
Statut
Membre
Dernière intervention
24 mai 2009
2
Je ne vois aucun probleme a faire ca. Par contre, si les variables que tu passes en param sont 'globales', il n'y a aucun interet a faire ceci, puis ce que tu pourras acceder a celles-ci a l'interieur de la fonction que tu appelles. C'est ca ton probleme d'allocation dynamique ?

+2(p - n)
Messages postés
28
Date d'inscription
jeudi 5 mai 2005
Statut
Membre
Dernière intervention
31 janvier 2009

Salut,

tu peux passer sans problèmes un tableau dynamique en paramètre, mais il y a
des choses à savoir.

Quand tu crées un tableau dynamique tu crées en fait une zone mémoire pour ton tableau dans la mémoire vive qui est pointée par un pointeur du même type, donc CString* tableau, n'est pas un tableau mais un pointeur sur l'adresse de la première case mémoire de ta zone alloué.

Alors pour passer un tableau dynamique en paramètre tu passes un pointeur sur
la zone mémoire concernée.

Quand tu fais : tableau = new CString [10]; tu crées la zone mémoire pour ton
tableau de 10 de type CString et "new" vas te retourné l'adresse au pointeur tableau.

Attention n'oublie pas de supprimer ta zone mémoire quand tu ne l'utilise plus, car
si tu ne détruits pas les tableaux systématiquement la mémoire vive vas saturée.
Ex : delete [] tableau;

Ex programme :

void creat(char* tab)
{
tab = new char[11];
}

void main()
{
char* tableau = NULL;

creat(tableau);

delete [] tableau;
}

++ et bonne chance.
Messages postés
15096
Date d'inscription
lundi 11 juillet 2005
Statut
Modérateur
Dernière intervention
26 juillet 2021
97
Moi, je passerais les pointeurs, comme ceci:

void SetDynaArray(int &nb_element, CString *tab, CString *temp, CString elt)

Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

Bathof, si ton explication est juste, tu es malheureusement l'auteur d'une belle fuite de mémoire avec ton code donné comme exemple.

Le prototype correct de ta fonction est "void( char * & tab )". Tu vois pourquoi ? Je sais qu'on ne peut pas modifier son post et c'est bien dommage.

Ca rejoint un topic déjà existant et tres récent. Le passage par référence rend l'écriture plus sympathique. La solution proposée par Galmiza est ok si on tient à faire un passage par pointeur (du pointeur [sic!]).
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

Bruno, je crains que tu sois confronté à des fuites....
Messages postés
28
Date d'inscription
jeudi 5 mai 2005
Statut
Membre
Dernière intervention
31 janvier 2009

Je crois que j'ai fais just car :

char* tab;

tab = &tab;

donc j'init le poiteur tab de la fonction par l'adresse de tableau de la
fonction.

char* tab = tableau;

est egale a

char* tab = &tableau;

Mais je retiens, merci et a +
Messages postés
28
Date d'inscription
jeudi 5 mai 2005
Statut
Membre
Dernière intervention
31 janvier 2009

A oui désolé, tu as raison, j'ai fais une gourde. Merci et a plus.

Correction :

void creat(char** tab){
*tab = new char[10];
}

int main()
{
char* tableau;

creat(&tableau);
}
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

J'ai rien compris. Pour t'en convraince, tu remarqueras que dans ton code, apres l'appel de creat(), tableau est tjs égale à 0. Il n'est pas modifié dans le contexte appelant....
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

Amen! ;-)
Messages postés
28
Date d'inscription
jeudi 5 mai 2005
Statut
Membre
Dernière intervention
31 janvier 2009

Comme normalement je fais :

void creat(char*& tab)
{
tab =new char[12];
}

int main()
{
char* tableau;

creat(tableau);

delete [] tableau;
}

Alors je suis me suis trompé.

++ et merci, lol.
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
beh vu que tu n'utilise pas la val de retour,

renvoi simplement le ptr de ton tableau avec une condition d'utilisation:

désallouer absoluement la val de retour...



sinon, la soluce est celle du dbl ptr....

___________________________________________________________
Magicalement
Nono
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

... un std::vector resoud d'un coup tous ces problemes de mémoire.
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005

En fait entre temps j'avais trouvé une sol qui se rapproche de celle de magic_Nono, voila ce que j'ai fai :



//**********Methode************************
CString *SetDynaArray(int &nb_element, CString elt)
{


CString *tab;
CString *temp;


if (nb_element)
{
temp= new CString[nb_element+1];
for (int i=0; i<nb_element; i++)
temp[i] = tab[i];
tab = temp;
}
else tab = new CString;
{
tab[nb_element++] = elt;
}


return tab;
}



//******Attributs de ma classe******
CString *Montab;





//********Appel *****************
Montab = SetDynaArray(nb_elt,"MonElt");






//********Dans mon Destructeur de Classe******
delete [] Montab;



Ai-je oublié de desallouer de la mem, je pense aux variables locales à ma fonction "tab" et "temp"?Si oui, comment faire???
Messages postés
371
Date d'inscription
dimanche 4 janvier 2004
Statut
Membre
Dernière intervention
23 septembre 2009

C'est n'importe quoi le code que tu nous as donné. Sans parler de la classe globale dont tu nous as pas montré le code encore. Je crains le pire.

Déjà un pointeur sur un CString, je trouve ca louche, compte tenu ce que tu en fais.

Précise ce que tu veux faire et on t'aide...

Cordialement,
Xterminhate.
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005

En fait j'ai une classe qui me permet de faire un traitement de données texte. Je parcours un document texte et j'ai un test qui si il est validé appel cette fonction. Ici, ma fonction permet de remplir un tableau de CString avec des données texte situées à une certaine position. Ce tableau est un attributs de ma classe puisqu'il va me servir dans une autre classe.
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005

je sais pas si j'ai été clair ou si cela suffit a me faire comprendre mais bon j'attends......
Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
a défaut d'oublier de la désallouer, tu ne l'a pas alloué du tt ce qui est pire...



sinon,

comme le dit

Xterminhate

précise ce que tu veux....

mais c'est vrai que vu la maniere dont c'est partit, on est pas sur que
tu arrive qq part et encore moins près de ce que tu t'étais fixé comme
objectif



Magicalement, allé du courage, petit scarabé
Nono
Messages postés
49
Date d'inscription
mercredi 20 avril 2005
Statut
Membre
Dernière intervention
15 septembre 2005

mais si je l'ai allouer, et quand je fais : tab = new CString et temp= new CString[nb_element+1]
Ce que je veux c'est juste savoir si je dois désallouer la meme des variables locales tab et temp et comment?

Ma fonction renvoi bien un tableau de CString avec les données voulues.Elle sont stockées dans mon tableau déclaré en global dont je désalloue la mem dans le destructeur de classe. Maintenant, encore une fois, je veux juste savoir comment désallouer la mem des variables locales tab et temp?

Merci