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?
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
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()
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]).
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.
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.
Aggiungere la definizione di 'arr' alla domanda altrimenti è ambigua. – jepio
@jepio Dice che è un array, e il codice ottiene la lunghezza dell'array, quindi è sicuro assumere che arr è un array. – juanchopanza