Hvis du har en array derefter sizeof(array) returnerer antallet af bytes arrayet optager. Da hvert element kan tage mere end 1 byte plads, skal du dividere resultatet med størrelsen af et element (sizeof(array[0]) ). Dette giver dig antallet af elementer i arrayet.
Eksempel:
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 EKSEMPEL
Bemærk, at hvis du sender et array til en funktion, vil ovenstående ikke virke, da arrayet henfalder til en pointer og sizeof(array) returnerer størrelsen på markøren.
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 EKSEMPEL #2
Som det er beskrevet i C++ Standard (5.3.3 Sizeof)
I dette udtryk
sizeof(arr) / sizeof(arr[0])
der bruges to underudtryk med operatorstørrelsen.
Dette underudtryk
sizeof(arr)
giver antallet af bytes optaget af array arr (Jeg formoder, at arr er et array).
For eksempel hvis du erklærede et array som
int arr[10];
så skal compileren reservere hukommelse til at indeholde 10 elementer af typen int. Hvis for eksempel sizeof( int ) er lig med 4, vil compileren reservere 10 * 4 =40 bytes hukommelse.
Underudtryk
sizeof(arr[0])
angiver antallet af bytes optaget af et element i arrayet. Du kan bruge et hvilket som helst indeks som f.eks.
sizeof(arr[1000])
fordi udtrykket ikke er evalueret. Det er kun vigtigt størrelsen i bytes af objektet (et element i arrayet), der bruges inde i operatoren.
Så hvis du kender det samlede antal bytes, der var reserveret til et array
sizeof(arr)
og ved hvor mange bytes hvert element i arrayet optager (alle elementer i et array har samme størrelse), så kan du beregne antallet af elementer i arrayet ved at bruge formlen
sizeof(arr) / sizeof(arr[0])
Her er et simpelt forhold. Hvis du har en matrix af N elementer af typen T
T arr[N];
og du kender størrelsen af hukommelsen optaget af arrayet, så kan du beregne størrelsen af dets element ved at bruge formel
sizeof( arr ) / N == size of an element of the array.
Og omvendt
Hvis du kender størrelsen af hukommelsen optaget af arrayet og størrelsen af dets element, kan du beregne antallet af elementer i arrayet
sizeof( arr ) / sizeof( a[0] ) == N - number of elements in the array
Det sidste udtryk kan du også omskrive på følgende måde
sizeof( arr ) / sizeof( T ) == N - number of elements in the array
fordi elementerne i arrayet har type T, og hvert element i arrayet optager nøjagtigt det antal bytes, der kræves for at allokere et objekt af typen T.
Vær opmærksom på, at begyndere normalt laver en sådan fejl. De sender en matrix som et argument til en funktion. Lad os for eksempel antage, at du har en funktion
void f( int a[] )
{
// ...
}
Og du går videre til funktionen dit array
int arr[10];
f(arr);
så bruger funktionen markøren til det første element i arrayet. Faktisk har funktionen erklæring
void f( int *a )
{
// ...
}
Så hvis du for eksempel skriver indenfor funktionen
void f( int *a )
{
size_t n = sizeof( a ) / sizeof( a[0] );
// ...
}
derefter som a i funktionen er en pointer (det er ikke et array), så får du noget lignende
void f( int *a )
{
size_t n = sizeof( int * ) / sizeof( int );
// ...
}
Normalt størrelsen af en pointer svarende til enten 8 eller 4 bytes afhængigt af det anvendte miljø. Og du får ikke antallet af elementer. Du vil få noget mærkeligt værdi.
Det virker kun hvis arr er ikke blevet henfaldet til en pointer, det vil sige, det er en matrixtype, ikke en pointertype.
sizeof(arr) er den samlede størrelse optaget af arrayet.
sizeof(arr[0]) er størrelsen af det første element i arrayet. (Bemærk, at arrays med nul længde ikke er tilladt i C++, så dette element eksisterer altid, hvis selve arrayet eksisterer).
Da alle elementer vil være af samme størrelse, er antallet af elementer sizeof(arr) / sizeof(arr[0]) .