Comment bien désallouer un vector reservé ?

Hmm autant pour moi, meme sans .reserve() ca me met des leak.

"Alex" <rdpdo2002@yahoo.fr> a écrit dans le message de news:
4207e8c6$0$25782$8fcfb975@news.wanadoo.fr...

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et
pour cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace
n'est pas contigue et a chaque ajout il me change les adresses
// et dans mon prog il
me faut des adresses qui ne changent pas a chaque ajout

// J'ajoute kk string
for (int i=0;i<100;i++)
{
string temp = "toto";
MesString.push-back(temp);
}

Ensuite, pour désallouer l'espace je fais :
MesString.clear();

Mon compilateur (vc++) me dit que j'ai des fuites. J'ai noté que si je ne
reserve pas d'espace au debut, je n'ai pas ces memory-leak.

Quelqu'un peut-il m'expliquer le pourquoi du comment ???
Merci !

--
---------------------------------------------------------------------------
Envie de déco ? http://www.decoetalage.net

Bonsoir,

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et pour
cela je fais :

juste par curiosité, on peut savoir pourquoi ?
ça m'intrigue.

David.

Alex wrote:

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et
pour cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace
n'est pas contigue et a chaque ajout il me change les adresses
// et dans mon prog il
me faut des adresses qui ne changent pas a chaque ajout

Logiquement ça doit pas être à chaque coup. Quand il ne suffit pas, il doit
te réserver une vingtaine d'éléments d'un coup pour laisser la marge.

En fait, ce que tu appelles l'espace contiguë n'est que l'espace pour
stocker la classe de string, tu vois ce que je vais dire ?
A l'intérieur de celle-ci il y a cependant un ou plusieurs new pour alouer
les tableaux de char où la classe string va stocker ces caractères. Et ça
c'est ton système qui va le faire sur le Heap, quoique si tu développes ton
propre gestionnaire de mémoire qui va placer toutes tes chaînes dans
l'espace contiguë...

Les fuites sont peut-être dues à "un bug" dans STL. C'est que reserve 1000
fait marcher 1000 fois le constructeur de string, qui fait new. Derrière à
la destruction de ton vector il parcours pour détruire que les éléments
vraiment affectés ensuite.

si tu remplis MesStrings jusqu'à 100, le destructor fait un truc d'en genre

for(int iElem = 0; iElem < m_nSize; iElem++)
{
delete ...[iElem]; // un tableau où j'sais pas comment il stocke ses trucs
}

où m_nSize égale à la taille réelle du vecteur et non de la mémoire réservée

Alex wrote:

Alex wrote:

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et
pour cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace
n'est pas contigue et a chaque ajout il me change les adresses
// et dans mon prog il
me faut des adresses qui ne changent pas a chaque ajout

Logiquement ça doit pas être à chaque coup. Quand il ne suffit pas, il doit
te réserver une vingtaine d'éléments d'un coup pour laisser la marge.

Non, l'allocation supplémentaire n'a pas le droit d'être constante, il
faut qu'elle soit multiple de la taille courante. Sinon, on a une
complexitée amortie en O(n) pour l'insertion, au lieu de O(1).

Les fuites sont peut-être dues à "un bug" dans STL. C'est que reserve 1000
fait marcher 1000 fois le constructeur de string, qui fait new.

Reserve n'appelle pas de constructeurs. Tu confonds avec resize.


--
Loïc

Merci pour ta reponse, mais en fait je viens de m'appercevoir que c'est un
autre vector dans mon prog qui etait mal désalloué... Je m'excuse pour le
"spam", j'aurais du chercher un peu plus avant de poster ici (j'avais cru
avoir cherché assez... mais non !)



"Alex" <no@email.adresse> a écrit dans le message de news:
cu8tql$idi$1@apollon.grec.isp.9tel.net...

Alex wrote:

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et
pour cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace
n'est pas contigue et a chaque ajout il me change les adresses
// et dans mon prog
il
me faut des adresses qui ne changent pas a chaque ajout

Logiquement ça doit pas être à chaque coup. Quand il ne suffit pas, il
doit
te réserver une vingtaine d'éléments d'un coup pour laisser la marge.

En fait, ce que tu appelles l'espace contiguë n'est que l'espace pour
stocker la classe de string, tu vois ce que je vais dire ?
A l'intérieur de celle-ci il y a cependant un ou plusieurs new pour alouer
les tableaux de char où la classe string va stocker ces caractères. Et ça
c'est ton système qui va le faire sur le Heap, quoique si tu développes
ton
propre gestionnaire de mémoire qui va placer toutes tes chaînes dans
l'espace contiguë...

Les fuites sont peut-être dues à "un bug" dans STL. C'est que reserve 1000
fait marcher 1000 fois le constructeur de string, qui fait new. Derrière à
la destruction de ton vector il parcours pour détruire que les éléments
vraiment affectés ensuite.

si tu remplis MesStrings jusqu'à 100, le destructor fait un truc d'en
genre

for(int iElem = 0; iElem < m_nSize; iElem++)
{
delete ...[iElem]; // un tableau où j'sais pas comment il stocke ses trucs
}

où m_nSize égale à la taille réelle du vecteur et non de la mémoire
réservée

Alex wrote:

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et pour
cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace n'est
pas contigue et a chaque ajout il me change les adresses
// et dans mon prog il
me faut des adresses qui ne changent pas a chaque ajout

// J'ajoute kk string
for (int i=0;i<100;i++)
{
string temp = "toto";
MesString.push-back(temp);
}

Ensuite, pour désallouer l'espace je fais :
MesString.clear();

Mon compilateur (vc++) me dit que j'ai des fuites. J'ai noté que si je ne
reserve pas d'espace au debut, je n'ai pas ces memory-leak.

Le bout de code ne me semble pas faux (sauf le push-back au lieu de
push_back, et le fait qu'on réserve 10 fois trop de mémoire). Pour
désallouer, le seul moyen de vraiment faire ça c'est à la destruction de
la variable MesString et il n'y a rien de spécial à faire pour ça (c'est
l'un des intérets de la STL). Donc le code suivant est suffisant et ne
fait pas de fuite mémoire :

int f()
{
std::vector<string> MesStrings;
// Juste de l'optimisation, inutile au niveau fonctionnel
// MesString.reserve(1000);
for (int i=0;i<100;i++)
{
string temp = "toto";
MesString.push-back(temp);
}
}


Par contre, ta contrainte de ne pas avoir de réallocation me semble
suspecte, peux-tu développer ?

--
Loïc

"Loïc Joly" <loic.actarus.joly@wanadoo.fr> a écrit dans le message de news:
4207feb8$0$17290$8fcfb975@news.wanadoo.fr...

Alex wrote:

Bonjour,
Dans mon programme, j'ai besoin d'avoir un espace contigue de string et
pour cela je fais :

std::vector<string> MesStrings;
MesString.reserve(1000); // <= Si je reserve pas, l'espace
n'est pas contigue et a chaque ajout il me change les adresses
// et dans mon prog
il me faut des adresses qui ne changent pas a chaque ajout

// J'ajoute kk string
for (int i=0;i<100;i++)
{
string temp = "toto";
MesString.push-back(temp);
}

Ensuite, pour désallouer l'espace je fais :
MesString.clear();

Mon compilateur (vc++) me dit que j'ai des fuites. J'ai noté que si je ne
reserve pas d'espace au debut, je n'ai pas ces memory-leak.

Le bout de code ne me semble pas faux (sauf le push-back au lieu de
push_back, et le fait qu'on réserve 10 fois trop de mémoire). Pour
désallouer, le seul moyen de vraiment faire ça c'est à la destruction de
la variable MesString et il n'y a rien de spécial à faire pour ça (c'est
l'un des intérets de la STL). Donc le code suivant est suffisant et ne
fait pas de fuite mémoire :

int f()
{
std::vector<string> MesStrings;
// Juste de l'optimisation, inutile au niveau fonctionnel
// MesString.reserve(1000);
for (int i=0;i<100;i++)
{
string temp = "toto";
MesString.push-back(temp);
}
}


Par contre, ta contrainte de ne pas avoir de réallocation me semble
suspecte, peux-tu développer ?

--
Loïc

Le programme que j'essaie de faire est une DLL. Le programme qui appelle
cette DLL n'enregistre que les pointeurs (en fait c'est un pointeur void*
donc je peux lui passer l'adresse du type que je veux, pour d'autres données
précises comme des char* ou des int je n'ai pas ce probleme - il s'alloue
son espace). Lorsque ma DLL doit donner au prog qui l'apelle une chaine de
caractere, elle lui envoi un pointeur, mais la DLL ne sauve pas dans son
espace la string (comme c'est un void*) et n'enregsitre que le pointeur.
C'est pour cela qu'il me faut un espace contigue, pour qu'a chaque ajout
d'une string, les adresses des strings precedentes (adresses sauvées dans le
prog principal) ne changent pas...

Enfin, j'ai pas trop d'experience en programmation, mais c'est ce que j'ai
compris :)

On Mon, 7 Feb 2005 23:16:49 +0100, "Alex" <rdpdo2002@yahoo.fr>:

MesString.reserve(1000);

Deux remarques en passant :

- évite les "magic values" :

static unsigned const TAILLE_CANONIQUE_TABLEAU= 1000;
MesString.reserve (TAILLE_CANONIQUE_TABLEAU);

- Il me semble que reserve() peut être une no-op (quelqu'un peut
confirmer ?)
De toute façon, si un appel à reserve() change le fonctionnement du
programme (à part bien sûr la vitesse d'exécution), tu as un bug
quelque part.


--
;-)

Fabien LE LEZ wrote:

On Mon, 7 Feb 2005 23:16:49 +0100, "Alex" <rdpdo2002@yahoo.fr>:

MesString.reserve(1000);

Deux remarques en passant :

- évite les "magic values" :

static unsigned const TAILLE_CANONIQUE_TABLEAU= 1000;
MesString.reserve (TAILLE_CANONIQUE_TABLEAU);

- Il me semble que reserve() peut être une no-op (quelqu'un peut
confirmer ?)

Ce n'est pas autorisé par la norme.

23.2.4.2
It is guaranteed that no reallocation takes place during insertions that happen after a call to
reserve() until the time when an insertion would make the size of the vector greater than the size
specified in the most recent call to reserve().

--
Loïc

It is guaranteed that no reallocation takes place during insertions that
happen after a call to
reserve() until the time when an insertion would make the size of the
vector greater than the size
specified in the most recent call to reserve().

Une petite question en passant... Si pendant l'execution du prog on se rend
compte que le reserve initial etait trop juste, y-a-til une maniere
d'allouer plus d'espace en gardant la mémoire contigue ? (enfin, disons en
"forcant" l'allocation a etre contigue; quitte a emmettre un message
d'erreur, ou ajuster e programme si cela n'a pas été possible)
Merci