malloc in C, aber die Verwendung von multi-dimensionalen array-syntax

Ja, Sie können dies tun, und Nein, brauchen Sie nicht ein array von Zeigern wie die meisten der anderen Antworten sagen Sie. Die Anrufung, die Sie wollen, ist nur:

int (*MAGICVAR)[200] = malloc(400 * sizeof *MAGICVAR);
MAGICVAR[20][10] = 3; //sets the (200*20 + 10)th element

Wenn Sie möchten, deklarieren Sie eine Funktion die Rückgabe dieser Zeiger, können Sie entweder es so machen:

int (*func(void))[200]
{
    int (*MAGICVAR)[200] = malloc(400 * sizeof *MAGICVAR);
    MAGICVAR[20][10] = 3;

    return MAGICVAR;
}

Oder verwenden Sie typedef, das macht es ein wenig klarer:

typedef int (*arrayptr)[200];

arrayptr function(void)
{
    /* ... */

Wenn zusätzliche Dereferenzierung ist kein Problem, Sie können verwenden Sie ein array von Zeigern.

Bearbeiten

Hier ist eine variation auf @Platinum Azure Antwort, dass nicht so viele Aufrufe von malloc. Neben der schnelleren Zuordnung, alle Elemente sind garantiert zusammenhängend:

#define ROWS 400
#define COLS 200

int **memory = malloc(ROWS * sizeof(*memory));
int *arr = malloc(ROWS * COLS * sizeof(int));

int i;
for (i = 0; i < ROWS; ++i)
{
    memory[i] = &arr[i * COLS];
}

memory[20][10] = 3;

#define ROWS 400
#define index_array_2d(a,i,j) (a)[(i)*ROWS + (j)]
...
index_array_2d( memory, 20, 10 ) = -1;
int x = index_array_2d( memory, 20, 10 );

Edit:

Arrays und Zeiger Aussehen sehr viel die gleiche, aber der compiler behandelt Sie sehr unterschiedlich. Mal sehen, was getan werden muss, um für eine array-Indizierung und die de-Referenzierung einen Zeiger mit dem offset:

1. Sagen wir erklärten, eine statische Arrays (Arrays auf dem stack ist nur ein bisschen komplizierter, festen offset von einem register, aber im wesentlichen das gleiche):

   static int array[10];

2. Und einen Zeiger:

   static int* pointer;

3. Wir dann de-Ehrerbietung einzelnen wie folgt:

   x = array[i];

x = pointer[i];

Das, was zu beachten ist, dass die Adresse des anfangs der array sowie, Adresse pointer (nicht deren Inhalt) sind festen im link/laden Zeit. Compiler dann macht Folgendes:

1. Für array de-Referenz:
   • lädt Wert von i,
   • fügt es den Wert von array, d.h. seine Feste Adresse, um die form der target-Speicher-Adresse,
   • lädt den Wert aus berechnet-Adresse
2. Für pointer de-Referenz:
   • lädt den Wert von i,
   • lädt den Wert von pointer, d.h. die Inhalt an seine Adresse,
   • addiert zwei Werte zu bilden, die effektive Adresse
   • lädt den Wert aus berechnet-Adresse.

Gleiche passiert auch bei 2D-array mit zusätzlichen Schritten der laden der zweiten index und Multiplikation mit der Reihe groß ist (das ist eine Konstante). All das ist beschlossen, zur compile-Zeit, und es gibt keine Möglichkeit der Substitution einer für den anderen zur Laufzeit.

Edit:

@caf hat hier die richtige Lösung. Es gibt einen legalen Weg innerhalb der Sprache zu index einen Zeiger als zwei-dimensionale array nach alle.

Arbeiten von Tim und caf s Antworten, überlasse ich dies hier für die Nachwelt:

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

void Test0() {
    int                             c, i, j, n, r;
    int                             (*m)[ 3 ];

    r = 2;
    c = 3;

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test1( int r, int c ) {
    int                             i, j, n;

    int                             (*m)[ c ];

    m = malloc( r * c * sizeof(int) );

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            m[ i ][ j ] = n++;
            printf( "m[ %d ][ %d ] == %d\n", i, j, m[ i ][ j ] );
        }
    }

    free( m );
}

void Test2( int r, int c ) {
    int                             i, j, n;

    typedef struct _M {
        int                         rows;
        int                         cols;

        int                         (*matrix)[ 0 ];
    } M;

    M *                             m;

    m = malloc( sizeof(M) + r * c * sizeof(int) );

    m->rows = r;
    m->cols = c;

    int                             (*mp)[ m->cols ] = (int (*)[ m->cols ]) &m->matrix;

    for ( i = n = 0; i < r; ++i ) {
        for ( j = 0; j < c; ++j ) {
            mp[ i ][ j ] = n++;
            printf( "m->matrix[ %d ][ %d ] == %d\n", i, j, mp[ i ][ j ] );
        }
    }

    free( m );
}

int main( int argc, const char * argv[] ) {
    int                             cols, rows;

    rows = 2;
    cols = 3;

    Test0();
    Test1( rows, cols );
    Test2( rows, cols );

    return 0;
}