array_length in C

Computing-array-Längen, C, problematisch ist am besten.

Das Problem mit dem code oben, ist, dass, wenn Sie tun:

int array_length(int a[]){ 
    return sizeof(a)/sizeof(int); 
} 

Du bist wirklich nur auf der Durchreise in einen Zeiger als "a", so sizeof(a) ist sizeof(int*). Wenn Sie auf einem 64bit-system, erhalten Sie immer 2 für sizeof(a)/sizeof(int) innerhalb der Funktion, da der Zeiger wird 64-bit.

Können Sie (möglicherweise) zu tun, wie ein makro anstelle der Funktion, aber das hat seine eigenen Probleme... (Es vollkommen inlines, also bekommen Sie das gleiche Verhalten wie Ihre int k =... block, though.)

InformationsquelleAutor Reed Copsey

Verwenden Sie ein makro,...

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

Es haben auch den bonus, die für array Datentyp 🙂

InformationsquelleAutor Goz

Die einfache Antwort auf deine Frage ist: es gibt keine Möglichkeit zu schreiben, die array_length Funktion. Sie könnte in der Lage sein, um Weg mit einem makro-definition, aber das hängt von dem Kontext, in dem Sie das makro.

Haben Sie machte den Fehler, verwirrend arrays und Zeigern in C. In C wird ein array mit Namen, in den meisten Fällen, ist äquivalent zu einem Zeiger auf sein erstes element. Ihre array_length Funktion erhält ein array a in einem solchen Kontext. In anderen Worten, ist es unmöglich, übergeben Sie ein array als array in C. die Funktion ist so, als ob es ist wie folgt definiert:

int array_length(int *a){
    return sizeof(a)/sizeof (int);
}

welche, im Grunde teilt sich die Größe der int * von der Größe int. Auch nach der obigen Beschreibung, es ist unmöglich zu wissen, die Größe eines Arrays in C in einer Funktion.

Nun, wie können Sie bestimmen seine Größe richtig außerhalb der Funktion? Die Antwort ist, dass sizeof Betreiber ist einer der Fälle, wo der name eines Arrays hat nicht zu reduzieren, um einen Zeiger auf sein erstes element. Ich habe erklärt, die Unterschiede genauer gesagt in diese Antwort. Auch beachten Sie, dass trotz Auftritte, sizeof ist ein operator, keine Funktion ist (wie wir gerade gelernt, es nicht eine Funktion sein, weil es dann nicht in der Lage zu berechnen, die Größe eines Arrays).

Schließlich, um zu bestimmen, die Größe eines Arrays a jeglicher Art T ich lieber:

size_t sz = sizeof a / sizeof a[0];

Den oben genannten Typ-Agnostiker: a könnte sein, oben. In der Tat, man könnte sogar ändern Sie die Art der a und würde sich nicht ändern müssen, die oben genannten.

InformationsquelleAutor Alok Singhal

Das problem ist, dass die Parameter der Funktion nicht wirklich arrays, obwohl C können Sie eine Erklärung abgeben, dass sieht aus wie ein. Der parameter endet als einen einfachen Zeiger. Ich habe gesagt,anderswo:

Diese läuft darauf hinaus, die Tatsache, dass plain array-Parameter in C/C++ sind eine Fiktion - Sie sind wirklich Zeigern. Array-Parameter sollten so weit wie möglich vermieden - werden Sie wirklich nur verwirren Angelegenheiten.

Das ist, warum diese Art von konstruieren, um die Anzahl der Elemente in einem array am Ende ein makro in C. Siehe diese frühere SO Antwort für das, was ich denke, ist eine gute (wenn auch kompliziert) die Umsetzung der makro:

• Ist es eine standard-Funktion in C, die zurückkehren würde, die Länge von einem array?

Für eine einfache Referenz, hier ist das makro:

#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))

Komplikationen in das makro um es sicherer zu bedienen als die meisten (beachten Sie, ich behaupte nicht, die Urheber der verwendeten Techniken im makro).

InformationsquelleAutor Michael Burr

int arr[was auch immer] innerhalb der Funktion argument-Liste definiert eine Zeiger, und nicht ein array. Also, die Informationen über Länge, ist für immer verloren.

warum!?

Zu sehen, warum, müssen Sie verstehen, was C ist. C kopiert nie komplexe chunks um implizit. Also, wenn Sie sagen "gib mir ein array", es bedeutet eigentlich "ich will, um eine Adresse, die in der array-name der Regel ist".

Dies ist kein Nachteil. Wenn Sie mehr wollen, Sie haben, um es manuell. Die Belohnung ist, dass Sie genau wissen, was Los ist auf der Maschine die Ebene, indem Sie die Leistung und andere Vorteile. Dies ist, wie können Sie das eine Universelle Programmiersprache für alle Zwecke.

InformationsquelleAutor Pavel Radzivilovsky

Array-Referenz wird dieses Problem lösen, obwohl ich würde nie empfehlen, so etwas (da es nur funktioniert, wenn Sie entweder immer vorbei, ref, oder verwenden Sie es in dem Umfang, in dem das array definiert wurde):

#include <iostream>

template <typename Arrtype>
unsigned mysize (Arrtype (&arr)) {
 return sizeof(arr) / sizeof(arr[0]);
}

int main () {
 unsigned arr[13];
 std::cout << mysize(arr) << std::endl; //prints 13
}

Auch hier erwähnt: http://cplusplus.co.il/2009/09/06/more-on-arrays/

Edit: Wie vorgeschlagen, in den Kommentaren, eine andere mögliche Lösung ist diese:

template <typename T, unsigned N>
unsigned mysize(T (&)[N]) {
    return N;
} 

InformationsquelleAutor rmn

Ich fand, dass war eine Falle gemacht, indem Sie unser C-Compiler!
(So ist es eine standard-CPL? C99 oder etwas anderes?)
Schrieb ich folgenden code in der visual studio-2010-Plattform auf x86.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a[3] = { 0xa, 0xb, 0xc }; //Declare an array which include 3 items.
    int len = sizeof(a) / sizeof(a[0]); //And the variable len refer to the code like @Neil Chowdhury o_O
    int * pa0 = a; //Then i declared a pointer point to the first element to the source array a.
    int len2 = sizeof(a) / sizeof(pa0[0]); //Len2 refer to the same action like previous statement.
    int len3 = sizeof(a) / sizeof(pa0); //Len3 refer to a's size(one int's size)divide may be a int pointer's size.
    int len4 = sizeof(pa0); //Len4 is the size of int pointer pa0.
    int len5 = sizeof(a); //And len5 is the size of pa0, the same theory as previous stmt represented.
    int len6 = sizeof(a[0]); //Len6 equal to sizeof(int)
    int len7 = sizeof(pa0[0]); //Len7 equal to sizeof(int) too.
    return 0;
}

Dann habe ich Sie gebaut, Und zeigte disassembly-code. die Ergebnisse mag:

    int a[3] = { 0xa, 0xb, 0xc };
00D13108  mov         dword ptr [ebp-14h],0Ah  
00D1310F  mov         dword ptr [ebp-10h],0Bh  
00D13116  mov         dword ptr [ebp-0Ch],0Ch  
    int len = sizeof(a) / sizeof(a[0]);
00D1311D  mov         dword ptr [ebp-20h],3  //caution!
    int * pa0 = a;
00D13124  lea         eax,[ebp-14h]  
00D13127  mov         dword ptr [ebp-2Ch],eax  
    int len2 = sizeof(a) / sizeof(pa0[0]);
00D1312A  mov         dword ptr [ebp-38h],3   //caution!
    int len3 = sizeof(a) / sizeof(pa0);
00D13131  mov         dword ptr [ebp-44h],3   //caution!
    int len4 = sizeof(pa0);
00D13138  mov         dword ptr [ebp-50h],4  
    int len5 = sizeof(a);
00D1313F  mov         dword ptr [ebp-5Ch],0Ch  
    int len6 = sizeof(a[0]);
00D13146  mov         dword ptr [ebp-68h],4  
    int len7 = sizeof(pa0[0]);
00D1314D  mov         dword ptr [ebp-74h],4  
    return 0;
00D13154  xor         eax,eax  

So, was? Blick auf diese "Vorsicht" markierten Linien!
Wie haben sich unsere c-compiler behandelt unsere C-code?
Wenn ein Zeiger kommt, vor allem, wenn wir schrieb einen Satz wie
etwas = sizeof(ein element in einem array) /sizeof(das erste element des Arrays)
der Compiler analysieren unsere syntax wie die Anzahl der ein array!
Es ist noch nicht fertig.

Getestet habe ich ein "dynamisches array". Ein array der Zuweisung durch malloc etc.

#include <stdio.h>
#include <stdlib.h>

int main()
{

    int * a = NULL;
    int len = 0;
    a = (int *) calloc(7, sizeof(int));
    len = sizeof(a) / sizeof(a[0]);
    return 0;
}

Bauen.. Zerlegen...

    int * a = NULL;
013830FE  mov         dword ptr [a],0  
    int len = 0;
01383105  mov         dword ptr [len],0  
    a = (int *) calloc(7, sizeof(int)); 
0138310C  mov         esi,esp  
0138310E  push        4  
01383110  push        7  
01383112  call        dword ptr [__imp__calloc (13882CCh)]  
01383118  add         esp,8  
0138311B  cmp         esi,esp  
0138311D  call        @ILT+300(__RTC_CheckEsp) (1381131h)  
01383122  mov         dword ptr [a],eax  
    len = sizeof(a) / sizeof(a[0]);
01383125  mov         dword ptr [len],1  //Hey!
    return 0;
0138312C  xor         eax,eax  
}

Siehst du das? compiler verpassten unsere syntax zu dieser Zeit.
So die Schlussfolgerung ist:
Wenn Sie schreiben einen Satz besonders gerne:
etwas = sizeof(ein element in einem array) /sizeof(das erste element des Arrays)
Compiler verstehen und zu analysieren, die unseren code und Zeichen der array-Kapazität etwas. Nur, wenn die Quell-array eine Feste array, oder ein array hat bereits erklärt Größe zuvor. (Zu dieser Zeit, die Größe ist eine Konstante gespeichert werden dürfen, compiler den Variablen-Tabelle.)
Es im Grunde wie @rmn sagte.
Das ist, was ich gefunden habe. Möglicherweise wertlos sein.

InformationsquelleAutor 0x2333