2 dimensionel data struktur

Et array kan godt blive så stort !

Men nok bare ikke pås takken.

Lav det til et globalt array.

Det virkede.
Post et svar hvis du vil have dine points :)
Jeg ville også blive glad for et eksempel på hvordan man kunne gøre det dynamisk.
Altså noget med vectors eller new.

2D arrays dynamisk er noget bøvl.

Nemmeste er nok:

struct big
{
  int a[640][480];
}

...

big *pixels = new big;

svar

Man bør kunne bruge en vector, eller et rigtigt dynamisk array:

#include <vector>
#include <iostream>

int main()
{
  std::vector<std::vector<int > >My2DVector(640, std::vector<int>(480));
  My2DVector[0][0] = 123;
  My2DVector[639][479] = 321;
  std::cout << My2DVector[0][0] << " " << My2DVector[639][479] << std::endl;

  int **My2dArray = new int * [640];
  for(int i = 0; i < 640; i++)
      My2dArray[i] = new int [480];

  My2dArray[0][0] = 555;
  My2dArray[639][479] = 333;
  std::cout << My2dArray[0][0] << " " << My2dArray[639][479] << std::endl;

  for(int i = 0; i < 640; i++)
      delete [] My2dArray[i];
  delete[] My2dArray;
}

Det der er ikke et 2D array, men et array af arrays.

Og det er en udmærket løsning.

vector af vector tror jeg er for dyr sammenlignet med de andre.

Ja, det er et array af array's

Jeg ved ikke om vector af vector er for dyr, det er mit indtryk at overhead er meget lille med moderne kompilere. Fordelen er at man slipper for at new og delete, og man runtime ved hvor stor den er.

Så vidt jeg kan se er overheadet 500-1000%.

I mange sammenhænge betyder det måske ikke noget men 640x480 pixels lyder
som noget hvor hastighed kunne betyde noget.

testet med:

#include <iostream>
#include <vector>
#include <ctime>

using namespace std;

const int X = 640;
const int Y = 480;
const int N = 100;

static int a[X][Y];
static vector<vector<int> >v(X,vector<int>(Y));

int main()
{
  clock_t t1 = clock();
  for(int i = 0; i < N; i++)
  {
      for(int j = 0; j < X; j++)
      {
          for(int k = 0; k < Y; k++)
          {
              a[j][k] = i;
          }
      }
  }
  clock_t t2 = clock();
  cout << "2D array: " << (t2 - t1) << endl;
  clock_t t3 = clock();
  for(int i = 0; i < N; i++)
  {
      for(int j = 0; j < X; j++)
      {
          for(int k = 0; k < Y; k++)
          {
              v[j][k] = i;
          }
      }
  }
  clock_t t4 = clock();
  cout << "vector of vector: " << (t4 - t3) << endl;
  return 0;
}

Det kommer an på kompiler og optimering (vec.cpp er dit program):

D:\Program\NG\Player>g++ vec.cpp -o vec.exe

D:\Program\NG\Player>vec
2D array: 250
vector of vector: 2500

D:\Program\NG\Player>g++ -O2 vec.cpp -o vec.exe

D:\Program\NG\Player>vec
2D array: 203
vector of vector: 188

D:\Program\NG\Player>bcc32 vec.cpp
Borland C++ 5.5 for Win32 Copyright (c) 1993, 2000 Borland
vec.cpp:
Turbo Incremental Link 5.00 Copyright (c) 1997, 2000 Borland

D:\Program\NG\Player>vec
2D array: 219
vector of vector: 203

Ah - klart nok - med en template så betyder optimize level naturligvis meget