string.Append(

Bonjour à tous,

J'ai des problèmes de performances ds une fct récursive qui écrit ds un string genre:

Code:

---

s+="...";

---

Je me demandais si la méthode:
s.Append("..."); est plus rapide que s+="...";

Ou sinon, existe-t-il une classe genre StringBuilder (C#) qui permet des manips de chaines plus performantes ?

Merci

Append et += sont équivalents je pense, en tout cas il n'y a aucune raison que l'un soit plus rapide que l'autre.

Il y a des méthodes pour optimiser l'utilisation des string (et plus généralement des conteneurs), si tu nous montre ton code je suis sur qu'on pourra te dire comment optimiser tout ça :wink:

Pour optimiser tu peux faire une liste de strings.

Et à la fin tu concatènes une fois le tout.

Merci, c'est un peu compliquer de montrer mon code. Mais en gros ça fait ceci.

Code:

---

1 2 3 4 5 6 7 8

void devNode(node *parentNode, string & ret) { ret += parentNode->GetValue(); for(int i=0;i<parentNode->getNbChildNodes();i++) { devNode(parentNode->getChild(i),ret); } }

---

Et plus mon arbre est grand, plus sa prend de temps. J'ai déja stocker ds une cache toute les valeurs que je récupérais dune DB ds GetValue, mais c'est encore lent.

Citation:

---

Envoyé par Ti-R

Pour optimiser tu peux faire une liste de strings.

Et à la fin tu concatènes une fois le tout.

---

Tu peux expliquer ? Parce que là, j'ai rein compris...

au lieu de faire

Code:

---

ret += parentNode->GetValue();

---

tu peux faire

Code:

---

1 2 3 4

... // Une list a la place d'une string pour ret ret.Add(parentNode->GetValue());

---

à la fin

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

// la tu comptes la taille de la chaîne int t_size(0); ret.Start(); for(int i=ret.Nbe();i--;) { t_size+=(*ret)->size(); ret++; }   // tu créer ta chaîne char *_final=new char[t_size+1]; char *pt_final=_final;   // tu remplis la chaîne via memcpy int t_size_s; ret.Start(); for(int i=ret.Nbe();i--;) { t_size_s=(*ret)->size(); memcpy(pt_final,((char *)(*ret)),t_size_s); pt_final+=t_size_s; ret++; }   // tu indiques que c'est une chaîne, et donc la fin de celle ci. *pt_final='\0';   // ne pas oublier delete [] _final;

---

C'est un speudo algo !!
Bon ok j'avoue je suis fan des char * et du C :roll:

Le probleme c'est que la concaténation fait grossir ta chaine, donc réallocation + recopie à chaque fois, et ça coute cher.
Essaye d'estimer au tout début la longueur de ta chaine, et appelle reserve() avec cette longueur estimée.

Pour cela que je propose ma soluce :)
Même si cela n'était pas explicité sur le pourquoi :)