2D Arrays umbau auf dynamisch

[CMW]

Moin
Ich hab ein Programm geschrieben, das ein magisches Quadrat errechnet...

//---------------------------------------------------------------------------

#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
#include <vcl/vcl.h>

//---------------------------------------------------------------------------
const int MAX = 3;
int zeile = 0, spalte = MAX % 2;
int feld [MAX][MAX];

void main()
{
      feld [zeile][spalte] = 1;

			for (int i = 1;i < MAX*MAX ; i++)
			{

					if (i % 3 == 0){
						zeile += 1;
					}

					else {
						spalte += 1;
						zeile -= 1;
					}

					if (zeile < 0) {
						zeile = MAX - 1;
					}
					if (spalte == MAX) {
						 spalte = 0;
					}

				feld [zeile][spalte] = i+1;
			}

			for (int z = 0;z < MAX ;z++) {
				for (int s = 0;s < MAX ; s++) {
					 cout << setw (4) << feld [z][s];
				}
	  cout << endl;
			}
getch();
}
//---------------------------------------------------------------------------

Jetzt habe ich Probiert den Quelltext so umzuschreiben, dass die Größe des Quadrates (const int MAX) vom User festgelegt wird,
Habe ich in etwa so gemacht

int **feld;          
/* Idee hatte ich aus dem Yahoobord, wo jemand nen ähnliches PRob hatte; */
feld = new int *[MAX];
for (int i = 0; i < MAX; i++)
{
    feld[i] = new int [MAX];
}

Das problem ist, dass ich dann einen fehler bekomme, dass der speicher belegt ist,
wie kann ich das sonst machen ?

mfg

CMW

[Krux]

das so zu machen ist schonmal nicht schlecht, eine andere möglichkeit wäre

int* feld = new int[MAX*MAX];

auf feld an position x,y greift man folgendermaßen zu:

feld[x+MAX*y];

aber wo dein Fehler herkommt sehe ich so auf Anhieb nicht.

[CMW]

sooo in etwa sieht das aus

c++

//---------------------------------------------------------------------------

#include <iostream.h>
#include <iomanip.h>
#include <conio.h>
//---------------------------------------------------------------------------
int print();
int test();
int test2();
int test3();
int test4();

int MAX = 3;
int zeile = 0, spalte = MAX % 2;
int **feld;

int main()
{
	  feld = new int*[MAX];
	  feld[MAX] = new int [MAX];

	  feld [zeile][spalte] = 1;

			for (int i = 1;i < MAX*MAX ; i++)
			{

					if (i % 3 == 0){
						zeile += 1;
					}

					else {
						spalte += 1;
						zeile -= 1;
					}

					if (zeile < 0) {
						zeile = MAX - 1;
					}
					if (spalte == MAX) {
						 spalte = 0;
					}

				feld [zeile][spalte] = i+1;
			}
		   print();
		   test();
		   test2();
		   test3();
		   test4();

getch();
return 0;
}

int print()
{
    			for (int z = 0;z < MAX ;z++) {
				for (int s = 0;s < MAX ; s++) {
					 cout << setw (4) << feld [z][s];
				}
	  cout << endl;
			} return 0;
}

int test()
{
 int summe = 0, tester = 15,x;

	for (int i = 0;i < MAX ; i++) {
		for (int j = 0 ;j < MAX ; j++) {
			x = feld [i][j];
			summe += x;

		if (summe == tester) {
		  cout << i+1 << ". Zeile: Ok " << endl;
		}

	}
	if (summe != tester) {
	   cout << "Error" << endl; return 0;

	}
	summe = 0;
	}
   return 0;
	}
int test2()
{
		int c,summe2 = 0, tester = 15;
		for (int d = 0;d < MAX ;d++ ) {
			for (int b = 0 ;b < MAX ; b++) {
			c = feld [d][b];
			summe2 += c;
		if (summe2 == tester) {
		  cout << d+1 << ". Spalte: Ok " << endl;
		}

	}
		if (summe2 != tester) {
	  cout << "Error"; return 0;
	}
	summe2 = 0;
			}
return 0;
}

int test3()
{    int j, summe = 0, tester = 15;

	cout << "Die Diagnonale ";

	for (int i = 0; i < MAX; i++) {
		j = i;
		summe += feld [i][j];
		cout << i+1 << "/" << j+1 << " , ";

	}
	if (summe == tester) {
		cout << " entspricht dem System"<< endl;
	}
	else cout << " entspricht nicht dem system" << endl;
  return 0;
}

int test4()
{
    int j=0, summe = 0, tester = 15;
	cout << "Die Diagonale ";
	for (int i = MAX-1;i >=0 ;i--) {
		 summe += feld [i][j];
		j++;
		cout << j << "/" << i+1 << " , ";
	}
	if (summe == tester) {
	   cout << " ist OK";
	}
	else cout << "Error";
   return 0;
}

[*D*Evil]

Ehm da wir hier in C++ sind und damit du dir nicht den ganzen Speicher zerhaust:

template<typename T>
class dynamic_array_type2
{
public:
	dynamic_array_type2(std::size_t row, std::size_t col) : m_row(row), m_col(col)	{	m_data = new T[row * col];}
	~dynamic_array_type2(){	delete [] m_data;}

public:
	T&			at(std::size_t x, std::size_t y) { if (y >= m_row || x >= m_col) throw std::out_of_range("x and/or y"); return m_data[x + m_col * y]; }
	T const&	at(std::size_t x, std::size_t y) const	{ if (x >= m_row || y >= m_col) throw std::out_of_range("x and/or y"); return m_data[x + m_col * y]; }

	T& operator ()(std::size_t x, std::size_t y)				{ return at(x, y);	}
	T const& operator () (std::size_t x, std::size_t y) const	{ return at(x, y);	}

	std::size_t row() const { return m_row; }
	std::size_t col() const { return m_col; }
	std::size_t size() const { return m_col * m_row; }

private:
	std::size_t		m_row;
	std::size_t		m_col;
	T*	m_data;
};

...

template <typename T>
void type(std::istream& in, T& dest, const std::string& prompt)
{
	std::cout << prompt < std::flush;
	while (!(in >> dest)) 
	{ 
		in.sync(); 
		in.clear(); 
		in.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); 
		std::cout << prompt << std::flush; 
	}
	return in;
}

Hab dir direkt nen kleines Hilfstemplate geschrieben um Daten einzulesen ...

int main()
{
    std::size_t dimension_x, dimension_y;
    type<std::size_t>(std::cin, dimension_x, "max. x: ");
    type<std::size_t>(std::cin, dimension_y, "max. y: ");

    dynamic_array_type2<int> field(dimension_x, dimension_y);
    std::size_t row = 0;
    field(row, field.col() - 1) = 1;

    for (std::size_t i = 3; i < field.size(); i += 3) ++row;
}

usw. (das ist jetzt bis zur nach der 1. for-Schleife) ...