sizeof style: sizeof (tipo) o sizeof variabile?

Ho visto due stili di utilizzo sizeofper operazioni relative alla memoria (come in memseto malloc):

• sizeof(type), e
• sizeof variable o sizeof(variable)

Quale preferiresti o utilizzeresti un mix dei due stili e quando useresti ogni stile? Quali sono i pro e i contro di ogni stile e quando li usi?

Ad esempio, posso vedere la seguente coppia di situazioni in cui uno stile aiuta e l'altro no:

Quando si ottiene il riferimento indiretto del puntatore errato:

type *var;
...
memset(var, 0, sizeof var);    /* oops */

Quando il tipo cambia:

new_type var;    /* changed from old_type to new_type */
...
memset(&var, 0, sizeof(old_type));    /* oops */

I perfer sizeof(variable)sopra sizeof(type). Ritenere:

int a1;
float a2;
memset(&a1,0,sizeof(a1));
memset(&a2,0,sizeof(a2));

vs.

int a1;
float a2;
memset(&a1,0,sizeof(int));
memset(&a2,0,sizeof(float));

Nel primo caso, è facile verificare che vengano passate le dimensioni giuste memset. Nel secondo caso, è necessario rivedere costantemente le sezioni superiore e inferiore per assicurarsi di essere coerenti.

La preferenza (come sempre) è quella di riflettere la tua intenzione il più direttamente possibile.

L'intenzione è di operare contro la memoria di una variabile esistente? Se è così, allora usa sizeof(variable), poiché questo mostra il più vicino possibile che è la memoria della variabile stessa a cui tieni.

L'intenzione è di eseguire alcuni calcoli sul tipo, ad esempio per determinare quanta memoria dovrebbe essere allocata per una nuova istanza? In tal caso, utilizzare sizeof(type).

Cioè, preferisco

struct foo *bar;
bar = (struct foo *) malloc(sizeof(struct foo));

al di sopra di

bar = (struct foo *) malloc(sizeof(*bar));

poiché quest'ultimo caso sembra che tu stia tentando di accedere a una variabile che non esiste ancora.

D'altra parte, preferisco

char Buffer[256];
memset(Buffer, 0, sizeof(Buffer));

al di sopra di

char Buffer[256];
memset(Buffer, 0, 256 * sizeof(char));

poiché l'intenzione è chiaramente di riempire zero il contenuto della variabile, quindi è la variabile contro cui dovremmo operare. Cercare di usare i metadati di tipo confonde le cose, qui.

Avrei di gran lunga preferisco sizeof(type)sopra sizeof variable. Anche se ti costringe a preoccuparsi di più sul tipo e apportare ulteriori modifiche, che consente di evitare errori puntatore indirezione, che si collocano tra la più comune causa di bug in C .

Non mi preoccuperei così tanto dei bug in cui il tipo sizeof(type)viene modificato; ogni volta che cambi il tipo di una variabile, dovresti fare una scansione veloce per vedere dove viene usata quella variabile e se devi cambiare qualche sizeof(type)istruzione. Anche se c'è sempre la possibilità di sbagliare, ha un rischio molto più basso rispetto agli errori di indiretta del puntatore.

Un vantaggio di sizeof variableè per gli array, ma in pratica ho scoperto che il passaggio di array come coppie di first / len è molto più comune (nel qual caso basta usare la lunghezza), inoltre è anche molto facile sbagliare la dimensione a causa di decadimento di array / puntatore, come in questo esempio:

ID_INLINE mat3_t::mat3_t( float src[ 3 ][ 3 ] ) {
  memcpy( mat, src, sizeof( src ) );    /* NOT the same as 3*3*sizeof(float) */
}

L'obiettivo è rimuovere la ridondanza. Se si utilizza sizeof per un'operazione correlata a una variabile, ovviamente si dovrà riflettere tale dimensione. Sì, puoi sbagliare come nel primo esempio, ma la cura non è usare il tipo, ma * var, abbinando correttamente l'obiettivo.

Per mitigare tali problemi è normale utilizzare macro, modelli e strumenti simili addestrati per il caso d'uso piuttosto che dimensioni nude.

Vedi la mia macro CLEAR che viene utilizzata esclusivamente al posto del memset nudo. Mi sono salvato il culo più volte in caso di refuso indiretto o quando un contenuto di una struttura ha raccolto un vettore o una stringa ...

La logica aziendale definisce la tua scelta.

1. Se il tuo codice si riferisce a una particolare variabile e senza questa variabile il tuo codice non ha senso: scegli sizeof(var)

2. Se il codice si occupa di un insieme di variabili con un tipo particolare, scegliere sizeof(type). Di solito questo è necessario se si dispone di una typedefche definisce molte variabili che si elaborano in modo diverso in base al loro tipo (ad esempio serializzazione). Potresti non sapere quale di queste variabili rimarrà nelle future versioni del codice, quindi scegliere il tipo come argomento è logicamente corretto. Anche la modifica di tali typedefnon influirà sulla dimensione della linea.

A seconda dello scopo, la dimensione (variabile) potrebbe essere la soluzione migliore. In tal modo, è possibile modificare il tipo di variabile, se necessario, senza correggere tutte le voci per il tipo. Ma di nuovo, dipende dal tuo obiettivo.