Discussion :

[moldavi]

Voici mon probl�me:

comme tout progammeur qui se respecte, moins j'�cris de code et plus je suis content (�a n'engage que moi...)

Je m'explique: je d�veloppe un logiciel et pour g�rer les erreurs, j'aimerais red�finir des fonctions et des op�rateurs. Exemple:

pour la fonction strcat, j'aimerais utiliser la version de mon compilateur en mode release et une version personnalis�e en mode debug.

mode release: strcat(tab1, tab2);

mode debug: static char* strcat(char*, const char*);
strcat(tab1, tab2);

Cette solution fonctionne sauf que le souci c'est que en mode debug, la fonction strcat personnalis�e devrait prendre un nombre de param�tres diff�rents:

strcat(tab1, tab2, sizeof(tab1), sizeof(tab2), _LINE_, _FILE_);

C'est possible avec une surcharge mais �a m'obligerai � �crire � chaque fois dans mon programme:

#ifdefine _DEBUG
strcat(tab1, tab2, sizeof(tab1), sizeof(tab2), _LINE_, _FILE_);
#else
strcat(tab1, tab2);

sauf que j'aimerais �crire uniquement strcat(tab1, tab2); dans tout le programme.

Est-ce qu'avec un #define ou une macro, ce serait possible?

M�me chose pour l'op�rateur new:

mode debug: pointeur = new (TypePointeur, _LINE_, _FILE_);

mode release: pointeur = new (TypePointeur);

Actuellement j'exp�rimente des solutions, mais votre aide ne sera pas de refus, merci.

[rolkA]

j'aimerais �crire uniquement strcat(tab1, tab2); dans tout le programme.
Est-ce qu'avec un #define ou une macro, ce serait possible?

Oui, tu peux faire cela:

une seule fois (par exemple dans une en-t�te):

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
#ifdef _DEBUG
   #define strcat(x, y) StrcatPersonnelle((x), (y), sizeof(x), sizeof(y), __LINE__, __FILE__)
#endif

Le remplacement pour __LINE__ et __FILE__ sera correct.

[Laurent Gomila]

A part �a, si tu utilisais std::string tu aurais non seulement une meilleure gestion des erreurs et de la m�moire, mais en plus tu �crirais encore moins de code 8)

[moldavi]

Merci rolkA, je vais essayer et s�rement utiliser cette technique.

A part �a, si tu utilisais std::string tu aurais non seulement une meilleure gestion des erreurs et de la m�moire, mais en plus tu �crirais encore moins de code

Je suis d'accord avec toi Loulou24, mais j'ai un souci d'optimisation et je n'ai pas encore tester les diff�rences de vitesse d'ex�cution entre les string et les char. M�me quelques microsecondes sont importantes.

C'est la raison pour laquelle en mode "debug", j'effectue la gestion des erreurs, et en mode "release", j'all�ge au maximum les fonctions. C'est un logiciel multim�dia et les cha�nes de caract�res que je manipule ne demande pas une gestion pouss�e des erreurs en cours d'ex�cution(sauf en cours de d�veloppement ou on a vite fait d'oublier un \\ � la fin d'un r�pertoire par exemple ou un \0). Mais lorsque ces petites erreurs sont r�gl�es, nul besoin de tester en cours d'ex�cution.

[Luc Hermitte]

Je n'ai pas fais de bench, mais j'ai comme un gros doute quant au fait que strcat aurait l'avantage sur std::string::operator+=. Le premier doit recalculer la longueur de la chaine, le second la connait d�j�.
De plus les manips de chaines sont n�gligeables par rapport aux acc�s fichiers.

[moldavi]

Je ne manquerai pas de faire des tests. Merci pour votre aide.

[rolkA]

Je n'ai pas fais de bench

Je l'ai fait et chez moi, strcat est plus rapide que l'op�rateur += pour de petites chaines (par exemple, "chaine" + "chaine" se fait 2 fosi plus rapidement avec strcat qu'avec string::+=), alors que l'op�rateur += est + rapide pour de tr�s grandes chaines.

[Luc Hermitte]

Et si tu anticipes la r�servation ?

[rolkA]

C'est ce que j'ai fait. Je n'ai pris en compte que le temps de concat�nation (sauf erreur de logique de ma part).

[moldavi]

Lisez ce message, il y a des choses int�ressantes:

http://www.developpez.net/forums/viewtopic.php?t=283717

[rolkA]

Je que j'ai fais:

J'ai concat�n� la chaine "chaine " plusieurs fois: la rapport de performance que j'obtiens entre string::+= et strcat passe � l'avantage du string si le nombre de concat�nations est tr�s important.

Par ailleurs j'ai fais une boucle afin d'avoir la meilleure pr�cision possible

Chez moi j'ai ces r�sultats (ratio = (temps avec string) / (temps avec strcat)):
1 concat�nation: ratio 3.92
5 concat�nations: ratio 4.97
10 concat�nations: ration 3.62
50 concat�nations: ratio 2.66
200 concat�nations: ratio 1.22, strcat gagne toujours
500 concat�nations: ratio 0,49

Attention, le nombre de concat�nations n'est pas le nombre de fois que j'ai r�p�t� la m�me concat�nation. En fait il s'agit de concat�nations en s�rie.
Par exemple, pour 5 concat�nations, le programme fait ceci:
((("chaine" + "chaine") + "chaine") + "chaine") +"chaine"

Le probl�me c'est que j'ai pu faire une erreur dans ma fa�on de proc�der. Je poste donc le code que j'ai utilis� (il faut r�gler d'abord "concatenations", puis ajuster "repetitions" afin d'avoir une bonne pr�cision) au cas o� vous ayez des commentaires sur ma fa�on de faire, queqluechose faussant peut-�tre les r�sultats.

J'ai tout allou� dynamiquement (tiens j'avais oubli� les delete d'ailleurs, pffff).

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
 
#include <iostream>
#include <windows.h>
using namespace std;
#pragma hdrstop
 
int main()
{
    //_____Le nombre de répétitions est à choisir assez grand pour une bonne précision
        const int repetitions = 30000;
 
    //_____Nombre de concaténations successives à chaque répétition
        const int concatenations = 5; // avantage à strcat si petite valeur
 
        const char* chaine = "chaine ";
        const unsigned long memoire = (strlen(chaine))*(concatenations+1) + 1;
 
    //_____Benchmark initial de std::string
        string* ss = new string(chaine);
        ss->reserve(memoire);
        DWORD debut = GetTickCount();
        for (int j = 0; j < repetitions; j++)
        {
                ss->clear();
                *ss = chaine;
                for (int i = 0; i < concatenations; i++) *ss += chaine;
        }
        DWORD fin = GetTickCount();
 
    //_____Benchmark supplémentaire de std::string
    // But: calculer le temps pris sans concaténation
        string* ss2 = new string(chaine);
        ss2->reserve(memoire);
        DWORD debut2 = GetTickCount();
        for (int j = 0; j < repetitions; j++)
        {
                // j'ai peur que le compilo optimise trop cette partie
                ss2->clear();
                *ss2 = chaine;
        }
        DWORD fin2 = GetTickCount();
 
    //_____Calcul final de temps de concaténation avec std::string
        cout << ((fin - debut) - (fin2 - debut2)) << endl;
 
    //_____Benchmark initial de strcat
        char* s = new char[memoire];
        s[0] = 0;
        debut = GetTickCount();
        for (int j = 0; j < repetitions; j++)
        {
                s[0] = 0;
                strcpy(s, chaine);
                for (int i = 0; i < concatenations; i++) strcat(s, chaine);
        }
        fin = GetTickCount();
 
    //_____Benchmark supplémentaire de strcat
    // But: calculer le temps pris sans concaténation
        char* s2 = new char[memoire];
        s2[0] = 0;
        debut2 = GetTickCount();
        for (int j = 0; j < repetitions; j++)
        {
                // j'ai peur que le compilo optimise trop cette partie
                s2[0] = 0;
                strcpy(s2, chaine);
        }
        fin2 = GetTickCount();
 
    //_____Calcul final de temps de concaténation avec strcat
        cout << ((fin - debut) - (fin2 - debut2)) << endl;
 
    delete[] s;
    delete[] s2;
    delete ss;
    delete ss2;
    return 0;
}

PS1: J'ai compil� avec BCB6, optimisations maximales.
PS2: ne fonctionne que sous Win (utilisation de GetTickCount).

[Aurelien.Regat-Barrel]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

const int concatenations = 5; // avantage à strcat si petite valeur

ca me fait penser au dicton

Ne fait jamais confiance � un benchmark que tu n'as pas truqu� toi m�me

Le probl�me avec la STL c'est que c'est difficilement g�n�ralisable car chaque compilo a son impl�mentation.
As-tu compil� en debug ?
Car sous VC++ 7.1 en release, avec

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
 
        const int repetitions = 300000; 
        const int concatenations = 50;

avantage std::string:
656ms contre 2156ms...
Mais bon le code m�riterait d'�tre simplifi�.

[rolkA]

J'ai bien compil� en release.

En effet le fait d'attendre autant de concat�nations pour passer l'avantage aux strings me paraissait bizarre, c'est pourquoi j'ai post� le code

Je vais essayer avec Dev C++.
[EDIT]
Avec Dev C++ j'obtiens un croisement (ratio 1) pour 50 concat�nations.
Bref, on dirait bien en effet que les performances changent grandement selon les compilateurs.
[/EDIT]

Quand au code je n'ai pas du tout cherch� � le simplifier, je l'ai fait � l'arrache .

[JolyLoic]

Il faut aussi compter qu'avec ton code, m�me quand tu fais beaucoup de r�p�titions, il y a quand m�me au d�but des r�p�titions des concat�nations de petites cha�nes, ce qui doit rendre le test plus complexe � lire.

J'aurais plut�t pris comme param�tre directement la taille de deux cha�nes � concat�ner.