2015-11-04 15 views
11

Quando alla ricerca di una dimensione di un array in un ciclo che ho visto scrivereCome funzionano sizeof (arr)/sizeof (arr [0])? persone

for(int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++){} 

Come è sizeof(arr)/sizeof(arr[0]) la lunghezza della matrice? Come funziona tecnicamente?

+0

Aggiungere la definizione di 'arr' alla domanda altrimenti è ambigua. – jepio

+0

@jepio Dice che è un array, e il codice ottiene la lunghezza dell'array, quindi è sicuro assumere che arr è un array. – juanchopanza

risposta

18

Se si dispone di array, sizeof(array) restituisce il numero di byte occupati dall'array. Poiché ogni elemento può occupare più di 1 byte di spazio, devi dividere il risultato con la dimensione di un elemento (sizeof(array[0])). Questo ti dà il numero di elementi nella matrice.

Esempio:

std::uint32_t array[10]; 

auto sizeOfInt = sizeof(std::uint32_t); // 4 
auto numOfBytes = sizeof(array); // 10*sizeOfInt = 40 
auto sizeOfElement = sizeof(array[0]); // sizeOfInt = 4 
auto numOfElements = sizeof(array)/sizeof(array[0]); // numOfBytes/sizeOfElement = 40/4 = 10 

LIVE EXAMPLE

Si noti che se si passa una matrice a una funzione, quanto sopra non funzionerà in quanto l'array decade a un puntatore e sizeof(array) restituisce la dimensione del puntatore .

std::size_t function(std::uint32_t a[]) // same for void function(std::uint32_t a[10]) 
{ 
    return sizeof(a); // sizeof(std::uint32_t*)! 
} 

std::uint32_t array[10]; 
auto sizeOfArray = function(array); // array decays to a pointer inside function() 

LIVE EXAMPLE #2

3

Funziona solo se arr non è stato decomposto in un puntatore, cioè, è un tipo di matrice, non un tipo di puntatore.

sizeof(arr) è la dimensione totale occupata dall'array.

sizeof(arr[0]) è la dimensione del primo elemento nell'array. (Si noti che gli array di lunghezza zero non sono consentiti in C++, quindi questo elemento esiste sempre se la matrice stessa esiste).

Poiché tutti gli elementi saranno della stessa dimensione, il numero di elementi è sizeof(arr)/sizeof(arr[0]).

1

Quando si ha a che fare con un array (some_type name[some_size]) sizeof(name) indica quanti byte occupa l'array. Dividere la dimensione totale dell'array in base alla dimensione di un elemento (sizeof(name[0])) indica quanti elementi sono presenti nell'array.

3

Come è descritto nella ++ standard C (5.3.3 Sizeof)

1 L'operatore sizeof restituisce il numero di byte nella rappresentazione dell'oggetto del suo operando. L'operando è un'espressione, che è un operando non valutato (clausola 5) o un id-type parentesi.

In questa espressione

sizeof(arr)/sizeof(arr[0]) 

si impiegano due sottoespressioni con l'operatore sizeof.

Questo subexpression

sizeof(arr) 

cede il numero di byte occupati da matrice arr (immagino che arr è un array).

Ad esempio, se si dichiara una matrice come

int arr[10]; 

il compilatore deve riservare la memoria che per contenere 10 elementi di tipo int. Se ad esempio sizeof(int) è uguale a 4 il compilatore riserva 10 * 4 = 40 byte di memoria.

subexpression

sizeof(arr[0]) 

indica il numero di byte occupati da un elemento nella matrice. È possibile utilizzare qualsiasi indice come ad esempio

sizeof(arr[1000]) 

perché l'espressione non è valutata. È importante solo la dimensione in byte dell'oggetto (un elemento dell'array) utilizzata all'interno dell'operatore.

Quindi se si conoscono i byte totali che sono stati riservati per una serie

sizeof(arr) 

e sapere quanti byte ciascun elemento della matrice occupa (tutti gli elementi di un array hanno la stessa dimensione), allora è possibile calcolare il numero di elementi nell'array utilizzando la formula

sizeof(arr)/sizeof(arr[0]) 

Ecco una semplice relazione. Se si dispone di un array di N elementi di tipo T

T arr[N]; 

e si conosce la dimensione della memoria occupata dalla matrice quindi è possibile calcolare la dimensione del suo elemento usando la formula

sizeof(arr)/N == size of an element of the array. 

E viceversa

Se si conosce la dimensione della memoria occupata dal array e la dimensione del suo elemento è possibile calcolare il numero di elementi nella matrice

sizeof(arr)/sizeof(a[0]) == N - number of elements in the array 

L'ultima espressione si può riscrivere anche la seguente modo

sizeof(arr)/sizeof(T) == N - number of elements in the array 

perché gli elementi della matrice sono di tipo T e ogni elemento della matrice occupa esattamente il numero di byte che sono necessari per allocare un oggetto di tipo T.

Prendete in considerazione che di solito i principianti commettono un tale errore. Passano un array come argomento per una funzione. Per esempio supponiamo di avere una funzione di

void f(int a[]) 
{ 
    // ... 
} 

E si passa alla funzione l'array

int arr[10]; 
f(arr); 

allora la funzione utilizza il puntatore al primo elemento della matrice.In realtà la funzione ha dichiarazione

void f(int *a) 
{ 
    // ... 
} 

Quindi, se si scrive per esempio all'interno della funzione

void f(int *a) 
{ 
    size_t n = sizeof(a)/sizeof(a[0]); 
    // ... 
} 

poi come a all'interno della funzione è un puntatore (non è un array) allora si ottiene qualcosa come

void f(int *a) 
{ 
    size_t n = sizeof(int *)/sizeof(int); 
    // ... 
} 

Di solito la dimensione di un puntatore pari a 8 o 4 byte a seconda dell'ambiente utilizzato. E non otterrai il numero di elementi. Otterrai qualche valore strano.

Problemi correlati