Hoe vind ik het aantal elementen in een array?

Ik heb een intarray en ik moet het aantal elementen daarin vinden. Ik weet dat het iets te maken heeft met sizeof, maar ik weet niet precies hoe ik het moet gebruiken.


Antwoord 1, autoriteit 100%

Als u uw array binnen het bereik heeft, kunt u sizeofgebruiken om de grootte in bytes te bepalen en de deling gebruiken om het aantal elementen te berekenen:

#define NUM_OF_ELEMS 10
int arr[NUM_OF_ELEMS];
size_t NumberOfElements = sizeof(arr)/sizeof(arr[0]);

Als u een array als functieargument ontvangt of een array in heap toewijst, kunt u de grootte ervan niet bepalen met behulp van de sizeof. U moet de maatinformatie op de een of andere manier opslaan/doorgeven om deze te kunnen gebruiken:

void DoSomethingWithArray(int* arr, int NumOfElems)
{
    for(int i = 0; i < NumOfElems; ++i) {
        arr[i] = /*...*/
    }
}

Antwoord 2, autoriteit 41%

int a[20];
int length;
length = sizeof(a) / sizeof(int);

en je kunt een andere manier gebruiken om ervoor te zorgen dat je code niet hard-coded wordt naar int

Zeg als je een array array

hebt

je hoeft alleen maar:

int len = sizeof(array) / sizeof(array[0]);

Antwoord 3, autoriteit 26%

Persoonlijk vind ik dat sizeof(a) / sizeof(*a) er schoner uitziet.

Ik definieer het ook liever als een macro:

#define NUM(a) (sizeof(a) / sizeof(*a))

Dan kun je het gebruiken in for-loops, dus:

for (i = 0; i < NUM(a); i++)

Antwoord 4, autoriteit 24%

Het is niet mogelijk om het aantal elementen in een array te vinden, tenzij het een tekenarray is. Beschouw het onderstaande voorbeeld:

int main()
{
    int arr[100]={1,2,3,4,5};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("%d", size);
    return 1;
}

De bovenstaande waarde geeft ons de waarde 100, zelfs als het aantal elementen vijf is.
Als het een tekenreeks is, kunt u lineair zoeken naar de null-tekenreeks aan het einde van de reeks en de teller verhogen terwijl u doorgaat.


Antwoord 5, autoriteit 13%

Super eenvoudig.

Deel het aantal toegewezen bytes gewoon door het aantal bytes van het gegevenstype van de array met behulp van sizeof().

Bijvoorbeeld, gegeven een integer array genaamd myArray

int numArrElements = sizeof(myArray) / sizeof(int);

Als het gegevenstype van uw array niet constant is en mogelijk kan veranderen, laat de deler in de vergelijking dan de grootte van de eerste waarde gebruiken alsde grootte van het gegevenstype.

Bijvoorbeeld:

int numArrElements = sizeof(myArray) / sizeof(myArray[0]);

Op deze manier is de code type-agnostisch en zal correct functioneren, ongeacht het gegevenstype van de array.


Antwoord 6, autoriteit 9%

In het echt kunnen we niet tellen hoeveel elementen er in een array zijn opgeslagen

Maar je kunt de lengte of grootte van de array vinden met de operator sizeof.

Maar waarom kunnen we niet vinden hoeveel elementen aanwezig zijn in mijn array.

Omdat wanneer we een array-compiler initialiseren, geheugen in ons programma geven zoals a[10] (10 blokken van 4 grootte) en elk blok een vuilniswaarde heeft als we een waarde in een index plaatsen zoals a[0]=1,a [1]=2,a[3]=8; en ander blok heeft rotzooi waarde niemand kan zeggen welke waarde afval is en welke waarde geen afval isdaarom kunnen we niet berekenen hoeveel elementen in een array. Ik hoop dat dit je zal helpen het te begrijpen. Klein concept


Antwoord 7, autoriteit 6%

Ik heb de volgende code gebruikt zoals hierboven voorgesteld om het aantal elementen in mijn 2-dimensionale array te evalueren:

#include <stdio.h>
#include <string.h>
void main(void)
{
    char strs[3][20] =
    {
        {"January"},
        {"February"},
        {""}
    };
    int arraysize = sizeof(strs)/sizeof(strs[0]);
    for (int i = 0; i < arraysize; i++)
    {
        printf("Month %d is: %s\n", i, strs[i]);
    }
}

Het werkt goed. Voor zover ik weet, kun je verschillende gegevenstypen in C-arrays niet door elkaar halen en moet je ook alle array-elementen van dezelfde grootte hebben (als ik gelijk heb), daarom kun je daar je voordeel mee doen met deze kleine truc:

  1. tel het aantal bytes met de functie sizeof() van de hele 2d-array (in dit geval 3*20 = 60 bytes)
  2. tel het aantal bytes met de functie sizeof() van het eerste array-element strs[0] (in dit geval 20 bytes)
  3. verdeel de hele grootte met de grootte van één element wat je het aantal elementen geeft

Dit geknipte zou draagbaar moeten zijn voor 2D-arrays in C, maar in andere programmeertalen zou het niet kunnen werken omdat je verschillende gegevenstypen binnen arrays met verschillende groottes kunt gebruiken (zoals in JAVA).


Antwoord 8, autoriteit 6%

#include<stdio.h>
int main()
{
    int arr[]={10,20,30,40,50,60};
    int *p;
    int count=0;
    for(p=arr;p<&arr+1;p++)
        count++;
    printf("The no of elements in array=%d",count);
    return 0;
}

OUTPUT=6

UITLEG

pis een pointer naar een 1-D array, en in de lus for(p=arr,p<&arr+1;p++)
Ik heb pnaar het basisadres laten wijzen. Stel dat het basisadres 1000 is; als we pverhogen, dan wijst het naar 1002 enzovoort. Nu komen we bij het concept van &arr– Het vertegenwoordigt in feite de hele array, en als we 1 toevoegen aan de hele array, dwz &arr+1, geeft het de adres 1012 dwz het adres van de volgende 1-D array (in ons geval is de grootte van int 2), dus de voorwaarde wordt 1000<1012.

Dus in feite wordt de voorwaarde

for(p=1000;p<1012;p++)

Laten we nu de staat controleren en de waarde tellen

  • 1e keer p=1000en p<1012voorwaarde is true: voer de lus in, verhoog de waarde van countnaar 1.
  • 2e keer p=1002en p<1012voorwaarde is true: voer de lus in, verhoog de waarde van countnaar 2.
  • 6e keer p=1010en p<1012voorwaarde is true: voer de lus in, verhoog de waarde van counttot 6.
  • Laatste keer p=1012en p<1012voorwaarde is onwaar: print de waarde van count=6in printf-instructie.

Antwoord 9, autoriteit 6%

De vraag is simpel: gegeven een C++ array (bijv. xzoals in int x[10]), hoe zou je het aantal elementen erin krijgen?

Een voor de hand liggende oplossing is de volgende macro (definitie 1):

#define countof( array ) ( sizeof( array )/sizeof( array[0] ) )

Ik kan niet zeggen dat dit niet correct is, omdat het het juiste antwoord geeft als je het een array geeft. Dezelfde uitdrukking geeft je echter iets neps als je iets levert dat geen array is. Als u bijvoorbeeld

int * p;

vervolgens countof( p )geeft u altijd 1 op een machine waar een int-pointer en een int dezelfde grootte hebben (bijvoorbeeld op een Win32-platform).

Deze macro accepteert ook ten onrechte elk object van een klasse die een lidfunctie-operator [] heeft. Stel dat u bijvoorbeeld

. schrijft

class IntArray {
private:
    int * p;
    size_t size;
public:
    int & operator [] ( size_t i );
} x;

dan is sizeof( x )de grootte van het x-object, niet de grootte van de buffer waarnaar wordt verwezen door x.p. Daarom krijg je geen correct antwoord door countof( x ).

Dus we concluderen dat definitie 1 niet goed is, omdat de compiler niet verhindert dat je het misbruikt. Het slaagt er niet in af te dwingen dat alleen een array kan worden doorgegeven.

Wat is een betere optie?

Nou, als we willen dat de compiler ervoor zorgt dat de parameter voor countof altijd een array is, moeten we een context vinden waarin alleen een array is toegestaan. Dezelfde context zou elke niet-array-uitdrukking moeten afwijzen.

Sommige beginners kunnen dit proberen (definitie 2):

template <typename T, size_t N>
size_t countof( T array[N] )
{
   return N;
}

Ze denken dat deze sjabloonfunctie een array van N elementen accepteert en N retourneert.

Helaas compileert dit niet omdat C++ een arrayparameter op dezelfde manier behandelt als een pointerparameter, d.w.z. de bovenstaande definitie is gelijk aan:

template <typename T, size_t N>
size_t countof( T * array )
{
    return N;
}

Het wordt nu duidelijk dat het functielichaam niet kan weten wat N is.

Als een functie echter een arrayverwijzingverwacht, zorgt de compiler er wel voor dat de grootte van de daadwerkelijke parameter overeenkomt met de declaratie. Dit betekent dat we definitie 2 kunnen laten werken met een kleine wijziging (definitie 3):

template <typename T, size_t N>
size_t countof( T (&array)[N] )
{
    return N;
}

Deze telling werkt erg goed en je kunt hem niet voor de gek houden door hem een verwijzing te geven. Het is echter een functie, geen macro. Dit betekent dat u het niet kunt gebruiken waar een compileertijdconstante wordt verwacht. Je kunt in het bijzonder niet iets schrijven als:

int x[10];
int y[ 2*countof(x) ]; // twice as big as x

Kunnen we er iets aan doen?

Iemand (ik weet niet wie het is – ik zag het net in een stukje code van een onbekende auteur) kwam met een slim idee: N verplaatsen van de hoofdtekst van de functie naar het retourtype (bijv. make de functie retourneert een array van N elementen), dan kunnen we de waarde van N krijgen zonder de functie daadwerkelijk aan te roepen.

Om precies te zijn, we moeten ervoor zorgen dat de functie een array-referentie retourneert, aangezien C++ je niet toestaat om een array rechtstreeks te retourneren.

De implementatie hiervan is:

template <typename T, size_t N>
char ( &_ArraySizeHelper( T (&array)[N] ))[N];
#define countof( array ) (sizeof( _ArraySizeHelper( array ) ))

Toegegeven, de syntaxis ziet er vreselijk uit. Enige uitleg is inderdaad nodig.

Ten eerste de dingen op het hoogste niveau

char ( &_ArraySizeHelper( ... ))[N];

zegt _ArraySizeHelperis een functie die een verwijzing retourneert (let op de &) naar een char array van N elementen.

Vervolgens is de functieparameter

T (&array)[N]

wat een verwijzing is naar een T-array van N elementen.

Ten slotte wordt countofgedefinieerd als de grootte van het resultaat van de functie _ArraySizeHelper. Merk op dat we niet eens _ArraySizeHelper()hoeven te definiëren, — een declaratie is voldoende.

Met deze nieuwe definitie,

int x[10];
int y[ 2*countof(x) ]; // twice as big as x

wordt geldig, precies zoals we willen.

Ben ik nu gelukkig? Nou, ik denk dat deze definitie zeker beter is dan de andere die we hebben bezocht, maar het is nog steeds niet helemaal wat ik wil. Om te beginnen werkt het niet met typen die in een functie zijn gedefinieerd. Dat komt omdat de sjabloonfunctie _ArraySizeHelpereen type verwacht dat toegankelijk is in het globale bereik.

Ik heb geen betere oplossing. Als je er een weet, laat het me dan weten.


Antwoord 10, autoriteit 4%

void numel(int array1[100][100])
{
    int count=0;
    for(int i=0;i<100;i++)
    {
        for(int j=0;j<100;j++)
        {
            if(array1[i][j]!='\0') 
            {
                count++;
                //printf("\n%d-%d",array1[i][j],count);
            }
            else 
                break;
        }
    }
    printf("Number of elements=%d",count);
}
int main()
{   
    int r,arr[100][100]={0},c;
    printf("Enter the no. of rows: ");
    scanf("%d",&r);
    printf("\nEnter the no. of columns: ");
    scanf("%d",&c);
    printf("\nEnter the elements: ");
    for(int i=0;i<r;i++)
    {
        for(int j=0;j<c;j++)
        {
            scanf("%d",&arr[i][j]);
        }
    }
    numel(arr);
}

Dit toont het exacte aantal elementen in de matrix, ongeacht de grootte van de array die je noemde tijdens het initialiseren (ALS je dat bedoelde)


Antwoord 11

ik heb meestal een gemakkelijke manier gevonden om de lengte van de array in een lus uit te voeren, gewoon zo

int array[] = {10, 20, 30, 40};
 int i;
 for (i = 0; i < array[i]; i++) {
    printf("%d\n", array[i]);
 }

Antwoord 12

Als we het aantal elementen in de array niet weten en wanneer de invoer door de gebruiker wordt gegeven tijdens runtime. Dan kunnen we de code schrijven als

C-CODE:

while(scanf("%d",&array[count])==1) { 
  count++;
}

C++-CODE:

while(cin>>a[count]) {
  count++;
}

Nu zal de telling het aantal array-elementen hebben dat is ingevoerd.


Antwoord 13

sizeofretourneert de grootte in bytes van het argument. Dit is niet wat je wilt, maar het kan helpen.

Stel dat je een array hebt:

int array[4];

Als u sizeoftoepast op de array (sizeof(array)), retourneert deze de grootte in bytes, in dit geval 4 * de grootte van een int, dus in totaal misschien 16 bytes (afhankelijk van je implementatie).

Als je sizeoftoepast op een element van de array (sizeof(array[0])), zal het de grootte in bytes teruggeven, wat in dit geval is de grootte van een int, dus in totaal misschien 4 bytes (afhankelijk van uw implementatie).

Als je de eerste deelt door de tweede, wordt het: (4 * de grootte van een int) / (de grootte van een int) = 4; Dat is precies wat je wilde.

Dus dit zou moeten doen:

sizeof(array) / sizeof(array[0])

Nu zou je waarschijnlijk een macro willen hebben om deze logica in te kapselen en nooit meer na te hoeven denken hoe het moet:

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

Je hebt de haakjes nodig die alle macro’s omsluiten zoals in elke andere complexe macro, en ook elke variabele omsluiten, alleen om onverwachte bugs met betrekking tot de prioriteit van operators te voorkomen.

Je kunt het nu op elke array als deze gebruiken:

int array[6];
ptrdiff_t nmemb;
nmemb = ARRAY_SIZE(array);
/* nmemb == 6 */

Houd er rekening mee dat argumenten van functies die als arrays worden gedeclareerd, geen echte arrays zijn, maar verwijzingen naar het eerste element van de array, dus dit zal er NIET op werken:

void foo(int false_array[6])
{
        ptrdiff_t nmemb;
        nmemb = ARRAY_SIZE(false_array);
        /* nmemb == sizeof(int *) / sizeof(int) */
        /* (maybe  ==2) */
}

Maar het kan in functies worden gebruikt als u een aanwijzer naar een array geeft in plaats van alleen de array:

void bar(int (*arrptr)[7])
{
        ptrdiff_t nmemb;
        nmemb = ARRAY_SIZE(*arrptr);
        /* nmemb == 7 */
}

Antwoord 14

Ervan uitgaande dat je een array hebt met elementen 1,3,4.
Om de lengte te weten, moet u de functie sizeofals volgt gebruiken:

int myArray[] = {1,3,4};
int len = sizeof(myArray) / sizeof(myArray[0]);

U kunt het aantal elementen controleren door de uitvoer als volgt af te drukken:

cout<<"This array has " << len << " elements";

Het volledige programma ziet er als volgt uit:

#include <iostream>
using namespace std;
int main()
{
    int myArray[] = {1,3,4};
    int len = sizeof(myArray) / sizeof(myArray[0]);
    cout<<"The array has " << len << "elements";
    return 0;
}

Antwoord 15

we kunnen het aantal elementen in array alleen vinden als array in dit formaat is gedeclareerd

int a[]={1,2,3,4,5,6};

aantal element in array is

n=sizeof(a) / sizeof(a[0]);

we zouden de array-grootte niet moeten kunnen berekenen als deze als volgt wordt gedeclareerd int a[10]={1,2,3,4,5,6}


Antwoord 16

Eigenlijk is er geen goede manier om de elementen in een dynamische integerarray te tellen. De opdracht sizeof werkt echter correct in Linux, maar niet correct in Windows. Vanuit het oogpunt van een programmeur wordt het niet aanbevolen om sizeof te gebruiken om het aantal elementen in een dynamische array te nemen. We moeten het aantal elementen bijhouden bij het maken van de array.

Other episodes