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.