Discussion :

[bilb0t]

Bonjour à tous,

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Laurent Gomila]

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

[Ti-R]

Pour optimiser tu peux faire une liste de strings.

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

[bilb0t]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[bilb0t]

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...

[Ti-R]

au lieu de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ret += parentNode->GetValue();

tu peux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

à la fin

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
 
 
// 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

[Aurelien.Regat-Barrel]

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.

[Ti-R]

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