typedefs e #defines

Abbiamo sicuramente usato typedefs e #defines una volta o l'altra. Oggi, mentre lavoravo con loro, ho iniziato a meditare su una cosa.

Considera le 2 situazioni seguenti per utilizzare il inttipo di dati con un altro nome:

typedef int MYINTEGER

e

#define MYINTEGER int

Come sopra, in molte situazioni possiamo fare molto bene qualcosa usando #define, e fare lo stesso usando typedef, anche se i modi in cui facciamo lo stesso possono essere abbastanza diversi. #define può anche eseguire azioni MACRO che un typedef non può.

Sebbene il motivo di base per usarli sia diverso, quanto è diverso il loro funzionamento? Quando uno dovrebbe essere preferito rispetto all'altro quando entrambi possono essere utilizzati? Inoltre, uno è garantito per essere più veloce dell'altro in quali situazioni? (ad es. #define è la direttiva del preprocessore, quindi tutto viene eseguito molto prima rispetto alla compilazione o al runtime).

A typedefè generalmente preferito a meno che non ci sia qualche strana ragione per cui hai specificamente bisogno di una macro.

le macro effettuano una sostituzione testuale, che può causare una notevole violenza alla semantica del codice. Ad esempio, dato:

#define MYINTEGER int

potresti legalmente scrivere:

short MYINTEGER x = 42;

perché si short MYINTEGERespande a short int.

D'altra parte, con un typedef:

typedef int MYINTEGER:

il nome MYINTEGERè un altro nome per il tipo int , non una sostituzione testuale per la parola chiave "int".

Le cose peggiorano ancora con tipi più complicati. Ad esempio, dato questo:

typedef char *char_ptr;
char_ptr a, b;
#define CHAR_PTR char*
CHAR_PTR c, d;

a, bE csono tutti i puntatori, ma dè una char, perché l'ultima riga si espande a:

char* c, d;

che equivale a

char *c;
char d;

(I typedef per i tipi di puntatore di solito non sono una buona idea, ma questo illustra il punto.)

Un altro caso strano:

#define DWORD long
DWORD double x;     /* Huh? */

Di gran lunga, il problema più grande con le macro è che non hanno ambito. Questo da solo garantisce l'uso di typedef. Inoltre, è più chiaro semanticamente. Quando qualcuno che legge il tuo codice vede una definizione, non saprà di cosa si tratta fino a quando non lo legge e comprende l'intera macro. Un typedef dice al lettore che verrà definito un nome di tipo. (Dovrei menzionare che sto parlando di C ++. Non sono sicuro dell'ambito tipedef per C, ma immagino che sia simile).

Il codice sorgente è scritto principalmente per i colleghi sviluppatori. I computer ne usano una versione compilata.

In questa prospettiva typedefha un significato che #definenon lo è.

La risposta di Keith Thompson è ottima e insieme punti aggiuntivi di Tamás Szelei sullo scoping dovrebbe fornire tutto lo sfondo di cui hai bisogno.

Dovresti sempre considerare le macro come l'ultima risorsa del disperato. Ci sono alcune cose che puoi fare solo con le macro. Anche allora, dovresti pensare a lungo e intensamente se vuoi davvero farlo. La quantità di dolore nel debug che può essere causata da macro sottilmente spezzate è considerevole e ti farà guardare attraverso i file preelaborati. Vale la pena farlo una sola volta, per avere un'idea della portata del problema in C ++: solo la dimensione del file preelaborato potrebbe aprire gli occhi.

Oltre a tutte le osservazioni valide sull'ambito e sulla sostituzione del testo già fornite, #define non è completamente compatibile con typedef! Vale a dire quando si tratta del caso dei puntatori a funzione.

typedef void(*fptr_t)(void);

Questo dichiara un tipo fptr_t che è un puntatore a una funzione del tipo void func(void).

Non è possibile dichiarare questo tipo con una macro. #define fptr_t void(*)(void)ovviamente non funzionerà. Dovresti scrivere qualcosa di oscuro #define fptr_t(name) void(*name)(void), che in realtà non ha alcun senso nel linguaggio C, dove non abbiamo costruttori.

I puntatori di matrice non possono essere dichiarati con #define: typedef int(*arr_ptr)[10];

E mentre C non ha alcun supporto linguistico per la sicurezza dei tipi degno di nota, un altro caso in cui typedef e #define non sono compatibili è quando si eseguono conversioni di tipo sospette. Lo strumento compilatore e / o analizzatore astatico potrebbe essere in grado di fornire avvisi per tali conversioni se si utilizza typedef.

Utilizzare lo strumento con la minima potenza che esegue il lavoro e quello con la maggior parte degli avvisi. #define viene valutato nel preprocessore, ci si trova in gran parte lì da soli. typedef è valutato dal compilatore. I controlli sono dati e typedef può solo definire i tipi, come dice il nome. Quindi, nel tuo esempio, scegli sicuramente typedef.

Al di là dei normali argomenti contro define, come scriveresti questa funzione usando i Macro?

template <typename IterType>
typename IterType::value_type Sum(
    const IterType& begin, 
    const IterType& end, 
    const IterType::value_type& initialValue)
{
    typename IterType::value_type result = initialValue;
    for (IterType i = begin; i != end; ++i)
        result += i;

    return result;
}

....

vector<int> values;
int sum = Sum(values.begin(), values.end(), 0);

Questo è ovviamente un esempio banale, ma quella funzione può riassumere qualsiasi sequenza iterabile in avanti di un tipo che implementa l'addizione *. I typedef usati in questo modo sono un elemento importante della programmazione generica .

* Ho appena scritto questo qui, lascio compilarlo come un esercizio per il lettore :-)

MODIFICARE:

Questa risposta sembra essere causa di molta confusione, quindi permettetemi di trarne di più. Se dovessi guardare all'interno della definizione di un vettore STL, vedresti qualcosa di simile al seguente:

template <typename ValueType, typename AllocatorType>
class vector
{
public:
    typedef ValueType value_type;
...
}

L'uso di typedef all'interno dei contenitori standard consente a una funzione generica (come quella che ho creato sopra) di fare riferimento a questi tipi. La funzione "Somma" è basata sul tipo di contenitore ( std::vector<int>), non sul tipo contenuto nel contenitore (int ). Senza typedef non sarebbe possibile fare riferimento a quel tipo interno.

Pertanto, i typedef sono fondamentali per il C ++ moderno e questo non è possibile con i macro.

typedef si adatta alla filosofia C ++: tutti i possibili controlli / asserzioni in fase di compilazione. #defineè solo un trucco del preprocessore che nasconde molto semantico al compilatore. Non dovresti preoccuparti delle prestazioni della compilazione più della correttezza del codice.

Quando crei un nuovo tipo, stai definendo una nuova "cosa" che il dominio del tuo programma manipola. Quindi puoi usare questa "cosa" per comporre funzioni e classi e puoi usare il compilatore a tuo vantaggio per fare controlli statici. Ad ogni modo, poiché C ++ è compatibile con C, ci sono molte conversioni implicite tra inttipi basati su int che non generano avvisi. In questo caso, quindi, non si ottiene la piena potenza dei controlli statici. Tuttavia, potresti sostituire il tuo typedefcon un enumper trovare conversioni implicite. Ad esempio: se lo hai fatto typedef int Age;, puoi sostituirlo con enum Age { };e otterrai tutti i tipi di errori da conversioni implicite tra Agee int.

Un'altra cosa: typedefpuò essere dentro a namespace.

L'uso di definisce invece di typedefs è preoccupante sotto un altro aspetto importante, e cioè il concetto di tratti di tipo. Prendi in considerazione classi diverse (pensa a contenitori standard) che definiscono tutti i loro specifici typedef. Puoi scrivere codice generico facendo riferimento ai typedef. Esempi di questo includono i requisiti generali del contenitore (standard c ++ 23.2.1 [container.requirements.general]) come

X::value_type
X::reference
X::difference_type
X::size_type

Tutto ciò non è espressibile in modo generico con una macro perché non ha ambito.

Non dimenticare le implicazioni di questo nel tuo debugger. Alcuni debugger non gestiscono molto bene #define. Gioca con entrambi nel debugger che usi. Ricorda, passerai più tempo a leggerlo che a scriverlo.

"#define" sostituirà ciò che hai scritto dopo, typedef creerà il tipo. Quindi, se vuoi avere un tipo personalizzato, usa typedef. Se hai bisogno di macro, usa define.