Grundsätzliche Frage

Neuling09

Ich habe mal eine Frage zu einer Klasse namens Matrix.
Und zwar wollte ich sie etwa so aufbauen:

class Matrix
{
      private:
              const int DIMENSION;
              int matrix[DIMENSION][DIMENSION];
      public:
             Matrix(int D=3) : DIMENSION(D) {};
};

Ok. Dass das nicht so wirklich funktioniert kann ich mir denken.

Dann wollte ich etwas ähnliches machen. Nämlich dieses hier:

class Matrix
{
      private:
              const int DIMENSION;
              int *matrix[][];
      public:
             Matrix(int D=3) : DIMENSION(D)
             {
                        matrix = new int[DIMENSION][DIMENSION];
             };
};

Das geht aber auch nicht.

Also ich kann nicht erklären was ich genau will, aber ich denke das sieht man.
Kann mir jemand einen Rat geben wie ich das vernünftig anstelle?

Xebov

//Das geht so nicht
int *matrix[][];
//korrekt wäre das hier
int *matrix;

Neuling09

Das hier geht aber auch nicht:

class Matrix
{
      private:
              const int DIMENSION;
              int *matrix;
      public:
             Matrix(int D=3) : DIMENSION(D)
             {
                        matrix = new int[DIMENSION][DIMENSION];
             };
};

freaky

Neuling09 schrieb:

Das geht aber auch nicht.

Das ist schön und was genau geht nicht ?

Neuling09

FreakY<3Cpp schrieb:

Neuling09 schrieb:

Das geht aber auch nicht.

Das ist schön und was genau geht nicht ?

cannot convert 'Matrix[][3]' to 'int' in assignment

Und ich weiß nicht wie ich das ändern soll damit es geht.

Firefighter

Kleiner Tip.Benutze die std Container, wie std::vector<T> und verschachtele den einfach wie hier:
`

std::vector<std::vector<T> >;`
Ist auch ein 2-Dimensionales Array.

Dravere

Wenn die Dimensionen in x und y Richtung nicht variabel sind, dann empfiehlt es sich sowieso, nicht ein 2D Array oder ähnliches zu nehmen. Man kommt deutlich einfacher zu recht, wenn man die Sache auf ein 1D Array abbildet:

Ohne C++ Standardbibliothek:

class Matrix
{
private:
  int m_dim;
  int* m_matrix;

public:
  Matrix(int dim)
    : m_dim(dim)
    , m_matrix(0)
  {
    m_matrix = new int[dim * dim];
  }

  ~Matrix()
  {
    delete[] m_matrix;
  }

public:
  int& get(int x, int y)
  {
    int index = y * m_dim + x;

    assert(index >= 0 && index < (m_dim * m_dim));

    return m_matrix[index];
  }

  // usw.
}

Mit der Standardbibliothek:

private:
  int m_dim;
  std::vector<int> m_matrix;

public:
  Matrix(int dim)
    : m_dim(dim)
    , m_matrix(dim * dim)
  {
  }

public:
  int& get(int x, int y)
  {
    return m_matrix[y * m_dim + x];
    // Assert passiert hier automatisch.
    // Bei den meistens Standardbibliotheken, zumindest.
  }

  // usw.
}

http://www.cplusplus.com/reference/

Grüssli

Neuling09

Danke für die Antworten.

So ähnlich wie du, davere, hatte ich das auch mal gelöst.
Das sah dann so aus:

Matrix::Matrix(int d)
{               
                DIMENSION = d;
                matrix = (int *) malloc(DIMENSION*DIMENSION*sizeof(int));
                for (int i=0; i<DIMENSION; i++)
                    for (int j=0; j<DIMENSION; j++)
                        if (i == j) *(matrix+(i*DIMENSION+j)) = 1;
                           else *(matrix+(i*DIMENSION+j)) = 0;
};

Weiß nicht ob das so schön ist in C++.

Ich wollte es darum mit einem 2D Array versuchen und ich dachte in C++ würde das so vielleicht gehen. Naja schade. Trotzdem danke für die Hilfe