Schnellste Möglichkeit, ein 2d-Array in C auf Null zu setzen?

Wenn array ist wirklich ein array ist, dann können Sie "null out" mit:

memset(array, 0, sizeof array);

Aber es gibt zwei Punkte, die Sie wissen sollten:

• dies funktioniert nur, wenn array ist wirklich ein "zwei-d-array", d.h. erklärt wurde T array[M][N]; für irgendeine Art T.
• es funktioniert nur in dem Bereich, wo array erklärt wurde. Wenn Sie übergeben es an eine Funktion, dann ist der name array zerfällt zu einem Zeigerund sizeof wird nicht geben Sie die Größe des Arrays.

Machen wir ein experiment:

#include <stdio.h>

void f(int (*arr)[5])
{
    printf("f:    sizeof arr:       %zu\n", sizeof arr);
    printf("f:    sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("f:    sizeof arr[0][0]: %zu\n", sizeof arr[0][0]);
}

int main(void)
{
    int arr[10][5];
    printf("main: sizeof arr:       %zu\n", sizeof arr);
    printf("main: sizeof arr[0]:    %zu\n", sizeof arr[0]);
    printf("main: sizeof arr[0][0]: %zu\n\n", sizeof arr[0][0]);
    f(arr);
    return 0;
}

Auf meine Maschine, die vor Drucke:

main: sizeof arr:       200
main: sizeof arr[0]:    20
main: sizeof arr[0][0]: 4

f:    sizeof arr:       8
f:    sizeof arr[0]:    20
f:    sizeof arr[0][0]: 4

Obwohl arr ist ein array, es zerfällt zu einem Zeiger auf sein erstes element, wenn die übergebene f()und daher die Größen gedruckt in f() sind "falsch". Auch in f() die Größe der arr[0] ist die Größe des Arrays arr[0]das ist ein "array [5] von int". Es ist nicht die Größe eines int * ist, weil das "vergehen" geschieht nur auf der ersten Ebene, und das ist, warum wir brauchen, um zu erklären f() wie ein Zeiger auf ein array der richtigen Größe.

So, wie ich schon sagte, was tun Sie waren ursprünglich nur funktionieren, wenn die beiden oben genannten Bedingungen erfüllt sind. Wenn nicht, werden Sie brauchen, um zu tun, was andere gesagt haben:

memset(array, 0, m*n*sizeof array[0][0]);

Schließlich memset() und die for Schleife, die Sie geschrieben sind nicht äquivalent im engeren Sinne. Könnte es werden (und wurden) Compiler, wo "alle bits null" nicht null ist, für bestimmte Arten, wie Zeiger und floating-point-Werte. Ich bezweifle, dass Sie sich sorgen machen müssen, dass, obwohl.

InformationsquelleAutor der Antwort Alok Singhal

Wenn Sie wirklich, wirklich besessen von Geschwindigkeit (und nicht so viel mit der Portabilität) ich denke, die absolute Schnellste Weg, dies zu tun wäre die Verwendung von SIMD-Vektor-Interna. z.B. auf Intel-CPUs, könnten Sie diese SSE2-Anweisungen:

__m128i _mm_setzero_si128 ();                   //Create a quadword with a value of 0.
void _mm_storeu_si128 (__m128i *p, __m128i a);  //Write a quadword to the specified address.

Jeder store-Befehl wird festgelegt, vier 32-bit-ints auf null-eins-hit.

p muss 16-byte-ausgerichtet, aber diese Einschränkung ist auch gut für die Geschwindigkeit, weil wird es helfen, den cache. Die andere Einschränkung ist, dass p zeigen muss, um eine Zuordnung-Größe, die ein Vielfaches von 16 bytes, das ist aber auch cool, denn es ermöglicht uns zu entrollen Sie die Schleife einfach.

Haben dies in einer Schleife, und entrollen Sie die Schleife ein paar mal, und Sie haben eine verrückte schnelle initialiser:

//Assumes int is 32-bits.
const int mr = roundUpToNearestMultiple(m, 4);      //This isn't the optimal modification of m and n, but done this way here for clarity.    
const int nr = roundUpToNearestMultiple(n, 4);    

int i = 0;
int array[mr][nr] __attribute__ ((aligned (16)));   //GCC directive.
__m128i* px = (__m128i*)array;
const int incr = s >> 2;                            //Unroll it 4 times.
const __m128i zero128 = _mm_setzero_si128();

for(i = 0; i < s; i += incr)
{
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
    _mm_storeu_si128(px++, zero128);
}

Gibt es auch eine Variante von _mm_storeu umgeht den cache (d.h. Nullstellung der array nicht verschmutzen cache), die geben könnte Sie einige sekundäre Leistung nutzen in einigen Fällen.

Finden Sie hier die für SSE2 Referenz: http://msdn.microsoft.com/en-us/library/kcwz153a(v=vs. 80).aspx

InformationsquelleAutor der Antwort Jarrod Smith

int array[N][M] = {0};

...zumindest im GCC 4.8.

InformationsquelleAutor der Antwort Arcane Engineer

Verwenden calloc statt malloc . calloc initiieren alle Felder auf 0.

int *a = (int *)calloc(n,size of(int)) ;

//alle Zellen wurden initialisiert auf 0

InformationsquelleAutor der Antwort DUDE_MXP

memset(array, 0, sizeof(int [n][n]));

InformationsquelleAutor der Antwort swestrup

Dies geschieht, weil sizeof(array) gibt die Zuordnung der Größe des Objekts verweist array. (array ist nur ein Zeiger auf die erste Zeile der mehrdimensionalen array). Aber Sie zugeordnet j arrays der Größe ich. Folglich müssen Sie multiplizieren Sie die Größe einer Zeile, die zurückgegeben wird sizeof(array) wird mit der Anzahl der Zeilen, die Sie zugewiesen, z.B.:

bzero(array, sizeof(array) * j);

Beachten Sie auch, dass sizeof(array) funktioniert nur für statisch zugewiesenen arrays. Für einen dynamisch zugewiesenen Arrays würde man schreiben

size_t arrayByteSize = sizeof(int) * i * j; 
int *array = malloc(array2dByteSite);
bzero(array, arrayByteSize);

InformationsquelleAutor der Antwort VoidPointer