Ottimizzare C++/Ottimizzazione del codice C++: differenze tra le versioni

=== La funzione ''<code>alloca''</code> ===

'''In funzioni non-ricorsive, per allocare spazio di dimensione variabile ma non grande, usa la funzione "<code>alloca"</code>.'''

=== La funzione ''<code>reserve''</code> ===

'''Prima di aggiungere elementi a oggetti ''<code>vector''</code> o ''<code>string''</code>, chiama ''<code>reserve''</code> con una dimensione sufficiente per la maggior parte dei casi.'''

Se si aggiungono ripetutamente elementi a oggetti ''<code>vector''</code> o ''<code>string''</code>, ogni tanto viene eseguita una costosa operazione di riallocazione del contenuto.

=== Mantenere la capacità dei ''<code>vector''</code> ===

'''Per svuotare un oggetto ''<code>vector<T> x''</code> senza deallocarne la memoria, usa l'istruzione ''<code>x.resize(0);''</code>; per svuotarlo deallocandone la memoria, usa l'istruzione ''<code>vector<T>().swap(x);''</code>.'''

Per svuotare un oggetto ''<code>vector''</code>, esiste anche l'istruzione ''<code>clear()''</code>; tuttavia lo standard non specifica se tale istruzione conserva la capacità (capacity) del ''<code>vector''</code> oppure no.

Se questa istruzione deve essere eseguita spesso, e si vuole essere sicuri di evitare frequenti riallocazioni, si deve chiamare la funzione ''<code>resize''</code>, che, secondo lo standard, conserva sicuramente la capacità.

Se invece si vuole essere sicuri di liberare la memoria usata da tale collezione, in quanto per un po' di tempo tale oggetto non verrà più usato, oppure verrà usato con un numero molto più piccolo di elementi, si deve chiamare la ''funzione <code>swap''</code> su un nuovo oggetto temporaneo vuoto.

=== Ridefinire ''la funzione <code>swap''</code> ===

'''Per ogni classe concreta <code>T</code> che, direttamente o indirettamente, possiede della memoria dinamica, ridefinisci le appropriate funzioni ''<code>swap''</code>.'''

e aggiungi la seguente funzione non-membro nello stesso namespace che contiene la classe <code>T</code>:

e, se la classe non è un template di classe, aggiungi la seguente funzione non-membro nello stesso file in cui è dichiarata la classe <code>T</code>:

Se gli oggetti di una classe non-standard vengono usati in algoritmi della libreria standard, e non viene fornito un overload della funzione ''<code>swap''</code>, viene usata l'implementazione generica.

L'implementazione generica di <code>swap</code> comporta la creazione e distruzione di un oggetto temporaneo e l'esecuzione di due assegnamenti di oggetti. Tali operazioni richiedono molto tempo se applicate ad oggetti che possiedono della memoria dinamica, in quanto tale memoria viene riallocata per tre volte.

Il possesso di memoria dinamica citato nella linea-guida può essere anche solo indiretto. Per esempio, se una variabile membro è un oggetto string o vector, o è un oggetto che contiene un oggetto string o vector, la memoria posseduta da tali oggetti viene riallocata ogni volta che si copia l'oggetto che li contiene. Quindi anche in tali casi si devono ridefinire le funzioni ''<code>swap''</code>.

Se l'oggetto non possiede memoria dinamica, la copia dell'oggetto è molto più veloce, e comunque non sensibilmente più lenta che usando altre tecniche, e quindi non si devono ridefinire funzioni ''<code>swap''</code>.

Se la classe è astratta, la funzione ''<code>swap''</code> non dovrebbe mai essere chiamata sugli oggetti di tale tipo, e quindi anche in questo caso non si devono ridefinire funzioni ''<code>swap''</code>.

Per velocizzare la funzione <code>swap</code>, la si deve specializzare per la propria classe. Ci sono due modi possibili: nel namespace della stessa classe (che può essere quello globale) come overload, o nel namespace std come specializzazione del template standard. È meglio definirla in entrambi i modi, in quanto, in primo luogo, se si tratta di un template di classe solo il primo modo è possibile, e poi alcuni compilatori non accettano o segnalano un avvertimento se è definita solo nel primo modo.

Per consentire di trovare la funzione ''<code>std::swap''</code>, la funzione deve iniziare con la seguente istruzione:

=== L'operatore ''<code>typeid''</code> ===

'''Invece di usare l'operatore ''<code>typeid''</code>, usa una funzione ''<code>virtual''</code>.'''

=== L'operatore ''<code>dynamic_cast''</code> ===

'''Invece dell'operatore ''<code>dynamic_cast''</code>, usa l'operatore ''<code>typeid''</code>, o, ancora meglio, una funzione ''<code>virtual''</code>.'''

Tale operatore può richiedere un tempo notevolmente superiore a quello richiesto da una semplice chiamata a funzione, e maggiore anche a quello richiesto dall’operatore ''<code>typeid''</code>.

'''Usa la specifica di eccezioni vuota (cioè aggiungi "<code>throw()"</code> dopo la dichiarazione) alle funzioni di cui sei certo che non solleveranno eccezioni.'''

=== Il costrutto ''<code>try/catch''</code> ===

'''Sposta prima dei colli di bottiglia le istruzioni ''<code>try''</code>, e dopo i colli di bottiglia le corrispondenti istruzioni ''<code>catch''</code>.'''

L’esecuzione di un blocco <code>try/catch</code> talvolta ha costo zero, ma altre volte comporta un rallentamento. Evita di eseguire tale blocco all’interno dei colli di bottiglia.

'''Per controllare se un numero intero ''<code>i''</code> è compreso tra ''<code>min_i''</code> e ''<code>max_i''</code>, estremi inclusi, usa l'espressione ''<code>unsigned(i – min_i) <= unsigned(max_i – min_i)''</code>.'''

In particolare, per controllare che un numero ''<code>i''</code> sia valido come indice per accedere a un array di ''<code>size''</code> elementi, si può usare la seguente espressione:

Se le espressioni utilizzate sono già tidi un tipo ''<code>unsigned''</code>, le conversioni non sono necessarie.

=== Ordine dei casi di ''istruzioni <code>switch''</code> ===

'''Nelle istruzioni <code>switch</code>, poni i casi in ordine di probabilità decrescente.'''

template <class Derivata> class Base {

public:

void f() { static_cast<Derivata*>(this)->f(); }

void g() { f(); }

};

class Derivata1: public Base<Derivata1> {

public:

void f() { ... }

};

...

Derivata1* p1 = new Derivata1;

p1->g();

In tal modo, si ha binding statico della funzione membro <code>Derivata1::f</code> alla funzione membro <code>Base<Derivata1>::g</code>, cioè la chiamata a tale funzione non è di tipo ''<code>virtual''</code>.

class Derivata1: public Base<Derivata1> {

public:

void f() { ... }

};

non risulterebbe possibile definire un puntatore o riferimento a una classe base comune a <code>Derivata1</code> e <code>Derivata2</code>, in quanto tali classi risultano due tipi senza alcuna relazione; quindi questa soluzione non è adatta se si vuole permettere al codice applicativo di definire un contenitore di oggetti derivati da Base.

* <code>Base</code> è necessariamente un tipo astratto;

* un oggetto di tipo </code>Derivata1</code> non può essere convertito in un oggetto di tipo <code>Derivata2</code> o viceversa;

* per ogni derivazione di <code>Base</code> tutto il codice di <code>Base</code> viene duplicato.

'''Se un oggetto che implementa il pattern ''Strategy'' (dettonoto anche come ''Policy'') è una costante in ogni algoritmo nel codice applicativo, ma il codice di libreria deve poter gestire più strategie, elimina tale oggetto, rendi ''<code>static''</code> tutti i suoi membri, e aggiungi tale classe come parametro di template.'''

class C;

class Strategy {

public:

virtual bool is_valid(const C&) const = 0;

virtual void run(C&) const = 0;

};

class C {

public:

void set_strategy(const Strategy& s): s_(s) { }

void f() { if (s.is_valid(*this)) s.run(*this); }

private:

Strategy s_;

};

class MyStrategy: public Strategy {

public:

virtual bool is_valid(const C& c) const { ... }

virtual void run(C& c) const { ... }

};

...

MyStrategyC sc; // Oggetto checon rappresentastrategia la strategiapersonalizzabile.

C c.set_strategy(s); // OggettoAssegnazione condella strategia personalizzabile.

c.set_strategyf(s); // AssegnazioneEsecuzione dellacon strategia assegnata.

template <class Strategy>

class C {

public:

void f() { if (Strategy::is_valid(*this)) Strategy::run(*this); }

};

class MyStrategy {

public:

static voidbool runis_valid(const C<MyStrategy>& c) { ... }

};

...

C<MyStrategy> c; // Oggetto con strategia preassegnata.

c.f(); // Esecuzione con strategia preassegnata.

In tal modo, si evita l'oggetto-strategia, e si ha il binding statico delle funzioni membro <code>MyStrategy::is_valid</code> e <code>MyStrategy::run</code>, cioè si evitano chiamate a funzioni virtuali<code>virtual</code>.

'''In un overload dell'operatore di assegnamento (operator=), se sei sicuro che non solleverà eccezioni, non usare la tecnica “copy''copy&swap”swap'', che crea una copia temporanea dell’oggetto sorgente, ma copia i singoli membri.'''

Tuttavia, tale tecnica non è “exception''exception-safe”safe'', cioè corre il rischio di non chiamare il distruttore di qualche oggetto nel caso venga sollevata un’eccezione durante la copia. Pertanto, se c’è la possibilità che durante la copia venga sollevata un’eccezione, si deve usare una tecnica “exception''exception-safe”safe'', che tuttavia non avrà prestazioni ottimali. La tecnica di assegnamento “exception-safe” più elegante è quella detta “copy''copy&swap”swap'', esemplificata dal seguente codice:

== 5.5. Come ottimizzare l’uso della pipeline del processore ==

Le istruzioni in linguaggio macchina di salto condizionato (chiamate anche ''branch''), possono essere generate dalla compilazione delle istruzioni C++ <code>if-else</code>, <code>for</code>, <code>while</code>, <code>do-while</code>, <code>switch-case</code>, e dell'operatore di espressione condizionale ("<code>?:"</code>).

<source lang=cpp>a = *++p;</source>

<source lang=cpp>a = *p++;</source>

=== Le ''<code>union''</code> ===

'''In array medi o grandi, usa le ''<code>union''</code>.'''

Le <code>union</code> permettono di risparmiare memoria in strutture di tipi variabili e quindi di renderle più compatte.

Per esempio, per memorizzare un bit e tre numeri che possono essere compresi tra 0 e 1000, puoi usare un campo ''<code>unsigned''</code> di un bit e tre campi ''<code>unsigned''</code> di 10 bit ciascuno (1 + 10 + 10 + 10 = 31, 31 <= 32), mentre per memorizzare cinque numeri che possono essere compresi tra -20 e +20, puoi usare cinque campi ''signed'' di 6 bit ciascuno.

f *= pow(2, n);

if (*(int*)&f & 0x7FFFFFFF) { // se f==0 non fare niente

*(int*)&f += n << 23; // aggiungi n all’esponente

}

'''Se un numero intero ''<code>signed''</code> è sicuramente non-negativo, quando lo dividi per una costante, convertilo in ''<code>unsigned''</code>.