Dynamisches Array der besonderen Art

helm

Hallo.
Folgender Code:

#include "stdafx.h"
#include "dib.h"
#include "dib_dll.h"

HANDLE CDIB::Modify1DIB()
{
  LPBITMAPINFOHEADER lpBIalt;       // Zeiger auf DIB-Eigenschaften
  LPBITMAPINFOHEADER lpBIneu;       // Zeiger auf DIB-Eigenschaften
  LPBITMAPINFO       lpBMIalt;      // Zeiger auf DIB-Informationsblock
  LPBITMAPINFO       lpBMIneu;      // Zeiger auf DIB-Informationsblock
  BYTE huge         *lpBitsalt;     // Zeiger auf Bilddaten der DIB
  BYTE huge         *lpBitsneu;     // Zeiger auf Bilddaten der DIB
  HANDLE             hGrayDIB;      // Handle der Gray-DIB
  HANDLE             hModifyDIB;    // Handle der Modify-DIB
  DWORD              dwWidth;       // Breite der DIB
  DWORD              dwHeight;      // Höhe der DIB
  DWORD              dwX, dwY;      // Zähler für X- und Y-Schleife
  BYTE               cGray;         // Grauwert (8 Bit)

  try
    {
     if (m_hDIB)

     hGrayDIB = ::GrayDIB(m_hDIB);  // Graustufentransformation durchführen und DIB übergeben
     lpBMIalt = (LPBITMAPINFO) GlobalLock(hGrayDIB);
     lpBIalt  = (LPBITMAPINFOHEADER) lpBMIalt;
     hModifyDIB = ::CopyDIB(hGrayDIB);  // DIB kopieren
     lpBMIneu   = (LPBITMAPINFO) GlobalLock(hModifyDIB);
     lpBIneu    = (LPBITMAPINFOHEADER) lpBMIneu;

     // Bildbreite und -heohe bestimmen
     dwWidth  = lpBIneu->biWidth;
     dwHeight = lpBIneu->biHeight;

     // Bilddaten manipulieren
     lpBitsalt  = GetDIBBits(lpBIalt);
     lpBitsneu  = GetDIBBits(lpBIneu);

     int array[256];
     int i,j;

     BYTE **zweid_array = new  BYTE * [dwWidth];    // Zeilen
     BYTE **zweidneu_array = new BYTE* [dwWidth]; //Zeilen  

     for (i=0;i<dwWidth;++i)
         {  
                  zweid_array[i] = new int [dwHeight];    //Spalten
          zweidneu_array[i] = new int [dwHeight]; //Spalten

             };

Also nicht wundern, die Funktion geht noch weiter, aber das ist nicht weiter relevant. Es geht um die dynamische Anlegung der beiden zweidimensionalen Arrays. Hab da schon alles durchgetestet mit Cast und so, aber nix geht. Habt ihr ne Idee?
Danke, wäre nett wenn ihr mal ein Auge draufwerfen könntet.

hi!

weiß nicht ob dir das weiterhelfen wird aber vielleicht doch:

BYTE *zweid_array = new BYTE [dwWidth*dwHeight];    //Zeilen+Spalten
     BYTE *zweidneu_array = new BYTE [dwWidth*dwHeight]; //Zeilen+Spalten

     for (i=0;i<dwWidth;i++)
        for (j=0;j<dwWidth;j++)
           {
               zweid_array[j+i*dwWidth]= //array füllen
               zweid_array[j+i*dwWidth]= //array füllen
           }

wolltest du soetwas in der art?
array löschen nicht vergessen!

gruß

jemand

uups... tippfehler entdeckt...

bei der inneren äußeren schleife handelt es
sich natürlich um ein dwHeight.

mfg

jemand

Wie wärs mit einer verketteten Liste?

helm

Hallo.
Also die zwei Arrays sollten zweidimensional sein. Ich komme bloss irgendwie mit den Datentypen nicht zurecht. Ich meine, es wäre sinnvoll als Felanzahl in der eckigen Klammer nur ein int anzugeben, da int nur ganzzahlig ist.

Also. Ich hab es jetzt erstmal hinbekommen, das die Arrays angelegt werden. Das läuft auch soweit alles. Wenn ich allerdings zum Schluss delete einfüge, dann spuckt der Compiler Fehler aus....
Hab jetzt delete ausgelassen, ist ja aber nicht sauber.... woran könnte das denn liegen?

Die Datentypen stimmen nicht.
Wenn du bYTE ptr hast, solltest du auch Bytes erzeugen also nicht new int [x],
sondern new BYTE [x]

RenéG

Also die zwei Arrays sollten zweidimensional sein.

Ähm, warum?

Um ein dynamisches 2dimensionales Array zu erstellen, musst Du mindestens
min( dwHeight, dwWidth)+1 Arrays mit new erstellen und auch wieder löschen.
Beim Vorschlag von 'jemand' muss new bzw. delete nur 1x aufgerufen werden. Und die Zugriffsgeschwindigkeit ist nicht langsamer!

Wenn Du unbedingt mit Array-Operatoren arbeiten willst, empfehle ich std::vector

d.h.

using namespace std;
typdef vector< vector<BYTE> > Dim2Array;
Dim2Array myArray;
myArray.resize( dwHeight);
for( Dim2Array::iterator it=myArray.begin(); it!=myArray.end(); it++)
  it->resize( dwWidth);

// Und schon kann man drauf zugreifen ...
myArray[0][0] = 5;