Wie bestimme ich die Größe meines Arrays in C?
https://stackoverflow.com/questions/37538
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie bestimme ich die Größe meines Arrays in C?
Das ist die Anzahl der Elemente das array halten kann?
Lösung
Zusammenfassung:
int a[17];
size_t n = sizeof(a)/sizeof(a[0]);
Vollständige Antwort:
Um die Größe des Arrays in bytes, die Sie verwenden können, die sizeof
Betreiber:
int a[17];
size_t n = sizeof(a);
Auf meinem computer, ints sind 4 bytes lang ist, so ist n 68.
Zur Ermittlung der Anzahl der Elemente in dem array, können wir teilen die Gesamtgröße des Arrays durch die Größe des array-Elements.Sie könnten dies tun mit der Art, wie diese:
int a[17];
size_t n = sizeof(a) / sizeof(int);
- und erhalten Sie die richtige Antwort (68 / 4 = 17), aber wenn der Typ des
a geändert, Sie hätten einen bösen Fehler, wenn Sie vergessen zu ändern
die sizeof(int) wie gut.
Also die bevorzugte divisor sizeof(a[0]), die Größe der
zeroeth element des Arrays.
int a[17];
size_t n = sizeof(a) / sizeof(a[0]);
Ein weiterer Vorteil ist, dass man jetzt leicht parametrisieren der name des Arrays in ein makro ein und erhalten:
#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
int a[17];
size_t n = NELEMS(a);
Andere Tipps
Die sizeof Weg ist der richtige Weg iff Sie sind den Umgang mit arrays nicht erhalten als Parameter.Ein array gesendet, die als parameter an eine Funktion behandelt wird wie ein Zeiger, so sizeof zurück die Zeiger der Größe, statt des Arrays.
Also, innerhalb der Funktion diese Methode funktioniert nicht.Verwenden Sie stattdessen immer einen zusätzlichen parameter übergeben size_t size Angabe der Anzahl der Elemente im array.
Test:
#include <stdio.h>
#include <stdlib.h>
void printSizeOf(int intArray[]);
void printLength(int intArray[]);
int main(int argc, char* argv[])
{
int array[] = { 0, 1, 2, 3, 4, 5, 6 };
printf("sizeof of array: %d\n", (int) sizeof(array));
printSizeOf(array);
printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
printLength(array);
}
void printSizeOf(int intArray[])
{
printf("sizeof of parameter: %d\n", (int) sizeof(intArray));
}
void printLength(int intArray[])
{
printf("Length of parameter: %d\n", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}
Ausgang (in einer 64-bit-Linux-Betriebssystem):
sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2
Ausgang (in einer 32-bit-windows-Betriebssystem):
sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1
Es ist erwähnenswert, dass sizeof hilft nicht, wenn es mit einem array-Wert abgeklungen ist, um einen Zeiger:obwohl es Punkte für den start in ein array, um den compiler ist es dasselbe wie ein Zeiger auf ein einzelnes element des Arrays.Ein Zeiger nicht "denken" etwas über das array, das verwendet wurde, um ihn zu initialisieren.
int a[10];
int* p = a;
assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));
Der sizeof - "trick" ist der beste Weg, den ich kenne, mit einem kleinen, aber (für mich als einer der wichtigsten Hauptärgernis) wichtige änderung bei der Verwendung von Klammern.
Wie der Wikipedia-Eintrag macht deutlich, C sizeof keine Funktion;es ist ein Betreiber.So, es nicht benötigen Klammern um das argument, es sei denn, das argument ist eine Art name.Diese ist leicht zu merken, da es macht das argument, die Aussehen wie ein cast-Ausdruck, die auch verwendet der Klammer.
Also:Wenn Sie haben die folgenden:
int myArray[10];
Finden Sie die Anzahl der Elemente mit code wie diesem:
size_t n = sizeof myArray / sizeof *myArray;
Für mich liest sich viel leichter, als die alternative mit Klammern.Ich habe auch zugunsten Verwendung der Sternchen im rechten Teil der division, seit es ist mehr präzise als die Indizierung.
Natürlich ist das alles compile-Zeit, so gibt es keine Notwendigkeit zu sorgen über die Teilung beeinträchtigen die Leistung des Programms.So verwenden Sie dieses Formular, wo immer Sie können.
Es ist immer am besten verwenden, sizeof auf ein Tatsächliches Objekt, wenn Sie eine haben, anstatt auf eine Art, seitdem Sie brauchen nicht zu befürchten, einen Fehler zu machen und unter Angabe der falsche Typ.
Zum Beispiel, sagen, Sie haben eine Funktion, die Ausgänge einige Daten als Strom von bytes, zum Beispiel über ein Netzwerk.Nennen wir die Funktion send(), und machen Sie es, nehmen Sie als argument einen Zeiger auf das Objekt zu senden, und die Anzahl der bytes im Objekt.So, der Prototyp wird:
void send(const void *object, size_t size);
Und dann Sie benötigen zu senden eine ganze Zahl, so dass Sie code wie diese:
int foo = 4711;
send(&foo, sizeof (int));
Nun, Sie haben eingeführt subtile Weise Schießen selbst in den Fuß, indem Sie die Art der foo in beiden Orten.Wenn man aber der andere nicht, der code bricht.Also, Mach es immer so:
send(&foo, sizeof foo);
Jetzt bist du geschützt.Sicher, Sie duplizieren die Namen der variable, aber das hat eine hohe Wahrscheinlichkeit des Brechens in einer Weise erkennt der compiler, wenn Sie es verändern.
int size = (&arr)[1] - arr;
Check-out diesen link Erklärung
Sie können die Verwendung von sizeof operator, aber es funktioniert nicht für Funktionen, weil es wird nehmen Sie die Referenz der Zeiger Sie können Folgendes tun, um zu finden die Länge eines Arrays:
len = sizeof(arr)/sizeof(arr[0])
Code ursprünglich hier gefunden:C-Programm zu finden, die die Anzahl der Elemente in einem array
Wenn Sie wissen, den Datentyp des Arrays, die Sie verwenden können, so etwas wie:
int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};
int noofele = sizeof(arr)/sizeof(int);
Oder wenn Sie nicht wissen, die Daten-array-Typ, die Sie verwenden können, so etwas wie:
noofele = sizeof(arr)/sizeof(arr[0]);
Hinweis:Dieses Ding funktioniert nur, wenn das array ist nicht definiert, die zur Laufzeit (wie malloc), und das array ist nicht bestanden in einer Funktion.In beiden Fällen, arr (array-name) ist ein Zeiger.
Das makro ARRAYELEMENTCOUNT(x) dass jeder zu nutzen bewertet falsch.Diese, realistisch betrachtet, nur eine sensible Angelegenheit, da kann man nicht Ausdrücken, das Ergebnis in ein array-Typ.
/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))
ARRAYELEMENTCOUNT(p + 1);
Tatsächlich ergibt:
(sizeof (p + 1) / sizeof (p + 1[0]));
In der Erwägung, dass
/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])
ARRAYELEMENTCOUNT(p + 1);
Es korrekt ausgewertet wird:
(sizeof (p + 1) / sizeof (p + 1)[0]);
Dies ist wirklich nicht viel zu tun mit der Größe des arrays explizit.Ich habe gerade bemerkt, dass sich viele Fehler nicht wirklich beobachtet, wie sich der C-Präprozessor funktioniert.Sie umschließen stets die makro-parameter, nicht ein Ausdruck in der macht beteiligt werden.
Das ist richtig;mein Beispiel war schlecht.Aber das ist eigentlich genau das, was passieren sollte.Wie ich oben schon erwähnt habe p + 1 wird am Ende als ein Zeiger-Typ und die Unwirksamkeit des gesamten makro (genau wie wenn Sie versucht haben um das makro zu verwenden, die in einer Funktion mit einem Zeiger-parameter).
Am Ende des Tages, in diesem insbesondere Instanz, der Fehler ist eigentlich egal (ich bin nur verschwenden die Zeit aller beteiligten;huzzah!), weil Sie nicht Ausdrücken, mit eine Art von 'array'.Aber wirklich der Punkt, über den Präprozessor Bewertung subtles ich denke, ist wichtig.
Für mehrdimensionale arrays es ist ein bisschen komplizierter.Oft Menschen definieren expliziten makro-Konstanten, d.h.
#define g_rgDialogRows 2
#define g_rgDialogCols 7
static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
{ " ", " ", " ", " 494", " 210", " Generic Sample Dialog", " " },
{ " 1", " 330", " 174", " 88", " ", " OK", " " },
};
Aber diese Konstanten können ausgewertet werden zur compile-Zeit auch mit sizeof:
#define rows_of_array(name) \
(sizeof(name ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name) \
(sizeof(name[0]) / sizeof(name[0][0]))
static char* g_rgDialog[][7] = { /* ... */ };
assert( rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);
Beachten Sie, dass dieser code funktioniert in C und C++.Für arrays mit mehr als zwei Dimensionen verwenden
sizeof(name[0][0][0])
sizeof(name[0][0][0][0])
etc., ad infinitum.
Größe eines Arrays in C:
int a[10];
size_t size_of_array = sizeof(a); // Size of array a
int n = sizeof (a) / sizeof (a[0]); // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a
// Size of each element = size of type
sizeof(array) / sizeof(array[0])
#define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))
"Sie eingeführt haben, auf subtile Weise Schießen selbst in den Fuß"
C 'native' arrays speichern nicht Ihre Größe.Es wird daher empfohlen, zum speichern der Länge des Arrays in einer separaten variable/const, und übergeben Sie es, wenn Sie das array übergeben, das ist:
#define MY_ARRAY_LENGTH 15
int myArray[MY_ARRAY_LENGTH];
Sie SOLLTEN immer vermeiden, native arrays (es sei denn, Sie können nicht, in diesem Fall, beachten Sie die Fuß).Wenn Sie schreiben C++, verwenden Sie die STL's 'vector' - container."Im Vergleich zu arrays, Sie bieten fast die gleiche Leistung", und Sie sind weit mehr nützlich ist!
// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;
// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
numbers.push_back(i);
// Determine the size of the array
cout << numbers.size();
@ Magnus:Der standard definiert sizeof wie nachgiebig die Anzahl der bytes im Objekt-und dass sizeof (char) ist immer ein.Die Anzahl der bits in einem byte ist die Realisierung spezifischer.
Edit:ANSI-C++ standard Abschnitt 5.3.3 Sizeof:
Der sizeof-operator liefert die Anzahl der bytes im Objekt-Repräsentation seines Operanden.[...] sizeof (char), sizeof (signed char) und sizeof (unsigned char) 1;das Ergebnis von sizeof jede andere grundlegende Typ wird durch die Implementierung definiert.
Abschnitt 1.6 Der C++ - Speichermodell:
Die grundlegende Speichereinheit, die in der C++ - Speichermodell ist das byte.Ein byte ist zumindest groß genug ist, um jedes Mitglied der basic execution character set und besteht aus einer zusammenhängenden Folge von bits, die Anzahl von denen ist, ist die Implementierung definiert.
@Skizz:Ich bin mir ziemlich sicher, dass ich Recht habe, obwohl das beste "Quelle" kann ich Ihnen im moment der Wikipedia, aus dem Artikel über sizeof:
Wikipedia ist falsch, Skizz, ist richtig.sizeof(char) ist 1, per definition.
Ich meine, Lesen Sie den Wikipedia-Eintrag richtig eng zu sehen, dass es falsch ist."Vielfaches von char". sizeof(char) kann niemals alles sein andere als "1".Wenn es, sagen wir, 2, würde dies bedeuten, dass sizeof(char) zweimal war die Größe von char!
Wenn Sie wirklich wollen, dies zu tun, übergeben, um Ihre array-ich schlage vor, die Umsetzung einer Struktur zu speichern einen Zeiger auf den Typ, den Sie möchten, die ein array und eine Ganzzahl, die die Größe des Arrays.Dann können Sie passieren, um zu Ihren Funktionen.Geben Sie einfach die array-variable mit dem Wert (Zeiger auf erstes element) an, die Zeiger.Dann können Sie gehen Array.arr[i] um die i-te element, und verwenden Sie Array.size um die Anzahl der Elemente im array.
Ich habe einige code für Sie.Es ist nicht sehr nützlich, aber Sie könnten verlängern mit mehr features.Um ehrlich zu sein, wenn dies die Dinge, die Sie wollen, Sie sollten aufhören, mit C und verwenden Sie eine andere Sprache mit diesen features eingebaut.
/* Absolutely no one should use this...
By the time you're done implementing it you'll wish you just passed around
an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and
cut out the array in main by using the stdlib memory allocation methods,
but it will work much slower since it will store your array on the heap */
#include <stdio.h>
#include <string.h>
/*
#include "MyTypeArray.h"
*/
/* MyTypeArray.h
#ifndef MYTYPE_ARRAY
#define MYTYPE_ARRAY
*/
typedef struct MyType
{
int age;
char name[20];
} MyType;
typedef struct MyTypeArray
{
int size;
MyType *arr;
} MyTypeArray;
MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*
#endif
End MyTypeArray.h */
/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
MyType d;
d.age = age;
strcpy(d.name, name);
return d;
}
MyTypeArray new_MyTypeArray(int size, MyType *first)
{
MyTypeArray d;
d.size = size;
d.arr = first;
return d;
}
/* End MyTypeArray.c */
void print_MyType_names(MyTypeArray d)
{
int i;
for (i = 0; i < d.size; i++)
{
printf("Name: %s, Age: %d\n", d.arr[i].name, d.arr[i].age);
}
}
int main()
{
/* First create an array on the stack to store our elements in.
Note we could create an empty array with a size instead and
set the elements later. */
MyType arr[] = {new_MyType(10, "Sam"), new_MyType(3, "Baxter")};
/* Now create a "MyTypeArray" which will use the array we just
created internally. Really it will just store the value of the pointer
"arr". Here we are manually setting the size. You can use the sizeof
trick here instead if you're sure it will work with your compiler. */
MyTypeArray array = new_MyTypeArray(2, arr);
/* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
print_MyType_names(array);
return 0;
}
Der beste Weg ist, Sie speichern diese Informationen, zum Beispiel, in einer Struktur:
typedef struct {
int *array;
int elements;
} list_s;
Implementieren alle notwendigen Funktionen wie erstellen, zu zerstören, zu überprüfen, Gleichheit, und alles, was Sie brauchen.Es ist einfacher als parameter übergeben.
Die Funktion sizeof gibt die Anzahl der bytes, die verwendet wird, indem das array in den Speicher.Wenn Sie wollen zu berechnen die Anzahl der Elemente im array ist, sollten Sie teilen Sie die Zahl mit der sizeof variable Typ des Arrays.Lassen Sie uns sagen, int array[10];, wenn die variable den Typ integer in Ihren computer ist 32 bit (oder 4 Byte), um die Größe des array, sollten Sie das folgende tun:
int array[10];
int sizeOfArray = sizeof(array)/sizeof(int);
Sie verwenden können die & Betreiber.Hier ist der Quellcode:
#include<stdio.h>
#include<stdlib.h>
int main(){
int a[10];
int *p;
printf("%p\n", (void *)a);
printf("%p\n", (void *)(&a+1));
printf("---- diff----\n");
printf("%zu\n", sizeof(a[0]));
printf("The size of array a is %zu\n", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));
return 0;
};
Hier ist die Beispielausgabe
1549216672
1549216712
---- diff----
4
The size of array a is 10
Beispiel
#include <stdio.h>
int main() {
int size;
scanf("%d", &size);
int array[size];
printf("%d\n", (int) (sizeof(array) / sizeof(int)));
printf("%d\n", (int) (sizeof(array) / sizeof(array[0])));
return 0;
}
