2012-04-24 26 views
26

Ho una matrice int e ho bisogno di trovare il numero di elementi in essa contenuti. So che ha qualcosa a che fare con sizeof ma non sono sicuro di come usarlo esattamente.Come posso trovare il numero di elementi in una matrice?

+5

Dai un'occhiata a questo. http://stackoverflow.com/questions/4081100/c-finding-the-number-of-elements-in-an-array – twain249

+0

Se sei su MSVC, hai _countof –

+0

Mentre tutti hanno la soluzione, voglio fai notare che è molto probabile che non ci sia modo di trovare la dimensione di un array dinamico a meno che tu non abbia registrato la dimensione perché sizeof (a) del puntatore a è la dimensione del puntatore 'int * a = new int [10 ] in questo caso trovare 'sizeof (* a)' è 4 byte. Quindi è importante mantenere il controllo della dimensione dell'array. – CppLearner

risposta

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

ed è possibile utilizzare un altro modo per rendere il codice non può essere hard-coded per int

Dire se si dispone di una matrice array

è sufficiente:

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

Se si dispone della matrice in ambito, è possibile utilizzare sizeof per determinarne la dimensione in byte e utilizzare la divisione per calcolare il numero di elementi:

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

Se si riceve un array come argomento di funzione o allocare una matrice in mucchio non è possibile determinare le dimensioni mediante il sizeof. Dovrete memorizzare/passare le informazioni sulle dimensioni in qualche modo per essere in grado di usarlo:

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

Personalmente ritengo che sizeof (a)/sizeof (* a) sembra più pulito.

anche io preferisco definirlo come una macro:

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

Quindi è possibile utilizzare in for-loop, questa convenzione:

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

Si potrebbe fare ciò, ma risulterebbe nel calcolo della dimensione ogni volta che esegue il test nel ciclo for, quindi una volta ogni iterazione. E così farebbe divisione ogni singola volta attraverso il ciclo. Sarebbe più efficiente assegnare il risultato di 'NUM (a)' a una variabile di istanza proprio sopra il ciclo e usare quel valore nel ciclo. – Gavin

+5

@Gavin no, non calcolerebbe la dimensione per ogni iterazione. Il compilatore è abbastanza intelligente da vedere che i risultati di ciascuna dimensione e della divisione sono costanti e determinano il risultato al momento della compilazione, che successivamente compila nel codice come numero costante. Potresti essere stato ingannato dall'aspetto dell'applicazione 'sizeof', che sembra una funzione dovuta alle parentesi, ma non è una funzione. 'sizeof' è un operatore e le parentesi sono solo una convenzione. – blubberdiblub

-2
template <typename Type, int N> 
inline int getElementCount(Type (&array)[N]) 
{ 
    (void)array; // (required to avoid a spurious warning in MS compilers) 
    (void)sizeof(0[array]); // This line should cause an error if you pass an object with a user-defined subscript operator 
    return N; 
} 
+1

Lingua sbagliata. –

1

ho usato seguente codice come suggerito sopra per valutare il numero di elementi nel mio array bidimensionale:

#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]); 
    } 

} 

Funziona bene. Per quanto ne so, non puoi mischiare diversi tipi di dati in array C e dovresti avere la stessa dimensione di tutti gli elementi dell'array (se ho ragione), quindi puoi approfittarne con questo piccolo trucco:

  1. numero di conteggio di byte con funzione sizeof() da intera matrice 2d (in questo caso 3 * 20 = 60 byte) numero
  2. conteggio dei byte con sizeof() funzione dal primo strs elemento array [0] (in questo caso 20 byte)
  3. divide intero formato con dimensioni di un elemento ciò che vi darà numero di elementi

Questo snippato dovrebbe essere portatile per gli array 2d in C, tuttavia in altri linguaggi di programmazione potrebbe non funzionare perché è possibile utilizzare diversi tipi di dati all'interno di array con dimensioni diverse (come in JAVA).

3

Non è possibile trovare il numero di elementi in un array a meno che non sia un array di caratteri. Considera l'esempio seguente:

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

Il valore sopra riportato ci dà valore 100 anche se il numero di elementi è cinque. Se è un array di caratteri, è possibile cercare linearmente la stringa nulla alla fine dell'array e aumentare il contatore mentre si attraversa.

+0

Quello che volevi scrivere: 'printf ("% d ", size);'. Ma sei corretto, puoi trovare solo la dimensione definita dell'array, non la dimensione reale! – uetoyo

2
#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

SPIEGAZIONE

p è un puntatore a una matrice 1-D, e nel ciclo for(p=arr,p<&arr+1;p++) ho fatto p scegliere l'indirizzo di base . Supponiamo che il suo indirizzo di base sia 1000; se incrementiamo p, punta a 1002 e così via. Veniamo ora al concetto di &arr - In pratica rappresenta l'intero array e se aggiungiamo 1 all'intero array, ad esempio &arr+1, esso fornisce l'indirizzo 1012, ovvero l'indirizzo del prossimo array 1-D (nel nostro caso la dimensione di int è 2), in modo che la condizione diventa 1000 < 1012.

quindi, in sostanza la condizione diventa

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

e ora cerchiamo di controllare la condizione e contare il valore

  • 1a volta p=1000 e p<1012 condizione è true: entrare nel ciclo, incrementare il valore di count a 1.
  • 2 ° tempo p=1002 e p<1012 condizione è true: entrare nel ciclo, incrementare il valore di count a 2.
  • ...
  • 6 ° tempo p=1010 e p<1012 condizione è true: entrare nel ciclo, incrementare il valore di count a 6.
  • l'ultima volta p=1012 e p<1012 condizione è falsa: stampare il valore di count=6 a 01.230.323,899 miladichiarazione.
+0

Questo non funziona (almeno in C++). Dovresti lanciare '& arr + 1' a (int *) in questo modo:' for (p = arr; p <(int *) (& arr + 1); p ++) ' – Staszek

-1

In realtà, non esiste un modo corretto per contare gli elementi in un array intero dinamico. Tuttavia, il comando sizeof funziona correttamente su Linux, ma non funziona correttamente su Windows. Dal punto di vista di un programmatore, non è consigliabile usare sizeof per prendere il numero di elementi in una matrice dinamica. Dovremmo tenere traccia del numero di elementi durante la creazione della matrice.

+0

L'operatore' sizeof' restituirà solo il * size * di un array * dichiarato all'interno dello stesso scope *, altrimenti 'sizeof' riporta semplicemente la dimensione del * puntatore * a cui l'array è stato convertito quando è passato come parametro. Non ha nulla a che fare con il sistema operativo e non vi è alcuna raccomandazione contro l'uso di 'sizeof' sull'altro se non di capire cosa si sta assumendo il' sizeof'. (* nessun gioco di parole *). –

-1

i principalmente trovato un modo semplice per eseguire la lunghezza di array in un ciclo proprio come quella

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

Se non si conosce il numero di elementi nella matrice e quando l'ingresso è dato dalla utente in fase di esecuzione. Quindi possiamo scrivere il codice come

C CODICE:

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

C++ CODICE:

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

Ora il conteggio sarà avere il conteggio del numero di elementi di matrice che vengono inseriti.

Problemi correlati