Ottimizzare C++/Scrivere codice C++ efficiente/Costrutti che migliorano le prestazioni: differenze tra le versioni

Per esempio, se hai il seguente array di strutture:

 

struct S {

int a, b;

};

S arr[n_voci];

 

e vuoi ordinarlo in base al campo <code>b</code>, potresti definire la seguente funzione di confronto:

 

bool confronta(const S& s1, const S& s2) {

return s1.b < s2.b;

}

 

e passarla all'algoritmo <code>std::sort</code>:

 

std::sort(arr, arr + n_voci, confronta);

 

Ma probabilmente è più efficiente definire la seguente classe di oggetto-funzione (nota anche come ''funtore''):

 

struct Comparatore {

bool operator()(const S& s1, const S& s2) const {

}

};

 

e passarne un'istanza temporanea all'algoritmo <code>std::sort</code>:

 

std::sort(arr, arr + n_voci, Comparatore());

 

Le funzioni degli oggetti-funzione di solito sono espansi ''inline'', e perciò sono altrettanto efficienti quanto il codice scritto sul posto, mentre le funzioni passate per puntatore vengono raramente espanse ''inline''.

Per esempio, invece del seguente codice:

 

const char* direzioni[] = { "Nord", "Sud", "Est", "Ovest" };

 

scrivi il seguente codice:

 

enum direzioni { Nord, Sud, Est, Ovest };

 

Un enumerato è implementato come un intero.

Per esempio, invece del seguente codice:

 

if (a[i] == 1) f();

else if (a[i] == 2) g();

else if (a[i] == 5) h();

 

scrivi il seguente codice:

 

switch (a[i]) {

case 1: f(); break;

case 5: h(); break;

}

 

I compilatori possono sfruttare la regolarità delle istruzioni <code>switch</code> per applicare alcune ottimizzazioni, in particolare se viene applicata la linea-guida "Valori dei casi di istruzioni <code>switch</code>" di questa sezione.

Per esempio, il seguente codice C++:

 

switch (i) {

case 10:

break;

}

 

probabilmente genera del codice macchina corrispondente al seguente pseudo-codice:

 

// N.B.: Questo non è codice C++

static indirizzo a[] = { caso_a, caso_b, fine, caso_a };

caso_b: funz_b();

fine:

 

Invece, il seguente codice C++:

 

switch (i) {

case 100:

break;

}

 

probabilmente genera del codice macchina corrispondente al seguente codice:

 

if (i == 100) goto caso_a;

if (i == 130) goto caso_a;

caso_b: funz_b();

fine:

 

Per così pochi casi, probabilmente non ci sono molte differenze tra le due situazioni, ma con l'aumentare del numero di casi, il primo codice diventa più efficiente, in quanto esegue un solo ''goto calcolato'' invece di una serie di <code>if</code>.

Esempio: Invece del seguente codice:

 

const int n = 10000;

double a[n], b[n], c[n];

a[i] = b[i] + c[i];

}

 

scrivi il seguente codice:

 

const int n = 10000;

struct { double a, b, c; } s[n];

s[i].a = s[i].b + s[i].c;

}

 

In tal modo, i dati da elaborare insieme sono più vicini tra di loro in memoria, e questo permette di ottimizzare l'uso della cache dei dati, e di indirizzare tali dati con istruzioni più compatte, che quindi ottimizzano anche l'uso della cache del codice.

Per esempio, invece del seguente codice:

 

for (int i = 0; i < 1000; ++i) {

f(i, a1, a2, a3, a4, a5, a6, a7, a8);

}

 

scrivi il seguente codice:

 

struct {

int i;

f(s);

}

 

Se una funzione riceve pochi argomenti, questi vengono posti direttamente nei registri, e quindi il loro passaggio è molto veloce; ma se gli argomenti non sono pochi, devono essere posti nello stack ad ogni chiamata, anche se non sono cambiati dall'iterazione precedente.