Array in C/C++ initialisieren

statisch:
unsigned int ar[500][500];

dynamisch:
unsigned int *p_ar;
p_ar = malloc( sizeof(unsigned int) *500*500 );

oder c++ mässig

unsigned int *p_ar = new unsigned int[sizex][sizey];

Ein zweidimensionales Array definieren und initialisieren Sie so:

    unsigned values[500][500] = { v_00, v_01, ..., v_499499 };

Die Werteliste in geschweiften Klammern kann dabei auch kürzer
als 500 * 500 sein; fehlende Werte werde mit 0 initialisiert. Um
also ein vollständig mit 0 gefülltes Array zu definieren:

    unsigned values[500][500] = { 0 };

In den üblichen PC-Implementierungen von C ist der Typ 'unsigned'
32 Bit groß, das Array damit 250000 * 4 Byte = 1 MB groß. Wenn der
Wertebereich ausreicht, wäre als Elementtyp also 'unsigned short'
empfehlenswert (ich nehme an, daß die Pixelwerte kein Vorzeichen
haben).

Datenobjekte dieser Größe sollten nicht mit automatischer Lebensdauer,
also lokal in Funktionen, angelegt werden, sondern global außerhalb
von Funktionen:

    unsigned values[500][500] = { 0 };

    void foo(void)
    {
        /* ... */
    }

oder als 'static' - dann werden sie nicht auf dem Stack angelegt -:

    void foo(void)
    {
        static unsigned values[500][500] = { 0 };
    }

oder am besten dynamisch allokiert werden:

    #include <stdlib.h> /* wegen malloc() */

    unsigned (*values)[500];

    void foo(void)
    {
        /* "values" initialisieren */
        values = malloc(500 * sizeof values[500]);
        if (values == NULL) {
            /* Oha, nicht genug Speicher! */
        }
        /* ... */
    }

Hilft das bei Ihrer Frage weiter?

Gruß
Martin

Das ist genau was ich gesucht habe!
Herzlichen Dank!

Gruß Sebastian

Hi

bei der Verwendung von malloc (bzw. new in C++) muß man aber darauf
achten den Speicher auch wieder freizugeben.

Matthias

Wie kann man ein 2 Dimensionales Array an einer Funktion übergeben?

einfach einen pointer drauf. wenn die dimensionen variabel sind musst du
diese als extra parameter mitübergeben (mindestens dimensionen-1
stück):

void fnk(int* zweiDarray, int dim1)

zugriff:

int i = *(zweiDarray + (y_position*dim1)+ x_position;

nachtrag:
denk dir in der letzten zeile noch die klammer zu. und falls der
compiler meckert noch nen cast

> oder c++ mässig
> unsigned int *p_ar = new unsigned int[sizex][sizey];

Das geht? staun

Unter "C++-mäßig" versteh ich sowas:
std::vector<std::vector<unsigned int> > array(sizex);
Das würde ich in dem Fall wahrscheinlich bevorzugen, weil man sich a)
nicht mit Zeigern herumschlagen muss und b) es trotzdem praktisch
genauso schnell ist.

Oder wenns unbedingt Zeiger und dynamischer Speicher sein müssen:
unsigned int** array = new unsigned int*[sizex];
for(unsigned int i = 0; i < sizex; ++i) array[i] = new unsigned
int[sizey];
Das Freigeben des Speichers wird dann aber etwas eklig und wird gerne
vergessen.

Deswegen ist das hier wohl besser (aber immer noch schlechter als die
Vector-Lösung oder statisches Array):
unsigned int* array = new unsigned int[sizex * sizey];

Korrekterweise sollte man auch posten, wie man das array wieder
freigibt:
delete[] array;