4. ein großes 2 dimensionales array erzeugen ?

ein großes 2 dimensionales array erzeugen ?

  • M

    Hallo,
    ich möchte im MFC ein ganz normales 2-Dimensionales Array erzeugen, und alle mit intwerten = 0 vorbelegen...

    ich kriegs nicht auf die Reihe 😞

    und in meinem tollen vc++ buch steht halt gleichmal garnix drinnen 😞

    Was soll ich tun ?

    achja ich hab schon

    #include <afxtempl.h>

typedef CArray<int, int> CIntArray;

    doch bei der erzeugung von 2 dimensionen da haperts ...

    Mittlerweile habe ich

    int MyArray[720][576];
	for(int i=0; i < 5; i++)
        for(int k=0; k < 8; k++)
           MyArray[i][k]=0;

    Aber die dimensionen sind zu groß und die anwendung crasht 😞

    wie kann ich so ein großes 2 dimensionales array erzeugen ?

    0
  • A
     

    typedef CArray<int, int> CIntArray;
typedef CArray<CIntArray, CIntArray&> CIntArray2D;
...
CIntArray2D ar;
int size = 10;
// Größe des Arrays
ar.SetSize(size);

// Größe der einzelnen Arrays, hier 10x10
for(int i = 0; i < size; ++i)
{
	ar[i].SetSize(size);
}

// mit 0 füllen
for(int i = 0; i < size; ++i)
{
	for(int j = 0; j < size; ++j)
	{
		ar[i][j] = 0;
	}
}
    0
  • A

    Wenn Du so große Arrays haben willst, dann musst Du sie auf dem Heap erzeugen:

    int** MyArray = new int*[700];
for(int i = 0; i < 700; ++i)
{
	MyArray[i] = new int[520];
	// mit 0 füllen
	memset(MyArray[i], 0, sizeof(int) * 520);
}

// Speicher wieder freigeben
for(int i = 0; i < 700; ++i)
	delete[] MyArray[i];
    0
  • M

    Eine Millarde Dank 🙂

    Das mit dem Heap war das problem.. ein kleineres ging ....
    super vielen Dank !!

    0

  • Tut euch selbst einen Gefallen und fangt an std::vector statt den MFC Containern zu verwenden.

    0
  • M

    und das geht wie ?

    0 

  • void Foo()
{
    size_t dimX = 567;
    size_t dimY = 789;
    std::vector<int> v(dimX*dimY);
    size_t x = 10;
    size_t y = 333;
    v[x + y*dimX] = 123;
    // ...
}

    2D Arrays als "Vektoren von Vektoren" bzw. als "Arrays von Zeigern auf Arrays" zu implementieren ist meist keine gute Wahl. Einfach ein 1D Array verwenden und dann selbst den Index ausrechnen ist IMO besser.

    Natürlich kann man sich dafür selbst eine Klasse schreiben die das kapselt, bzw. sich eine fertige solche suchen, dann muss man nicht überall soviel tippen.

    Du kannst aber auch gleich so machen wenn die Grösse zur Compile-Zeit feststeht:

    template <class T> struct wrapper
{
	T v;
};

int main() 
{
	std::auto_ptr<wrapper<int [456][567]> > p(new wrapper<int [456][567]>());
	int (&MyArray)[456][567] = p->v;

	MyArray[10][20] = 123;
}
    0
  • M

    Vielen Dank das Du Dir die Mühe gemacht hast, das Posting ist bei meinen Favoriten 🙂

    Aber was genau ist denn nun der Unterschied zwischen den beiden Dingern ?

    Ich muss halt sowieso schon eine Schleife durchlaufen, da ich von einem Bitmap die Pixel abfrage.
    Und wenn ich gerade an der Stelle bin, dann schreib ich in mein Array rein, was ich wie im 3. Posting erstellt habe.

    Das klappt wunderbar, ist halt ein bischen langsam, aber wahrscheinlich auch nur darum, weil ich ständig die Bitmaps rendern muss...

    0
Anmelden zum Antworten