[C++] Zweidimensionales Array füllen

[Nico22 (Gast)]

Liebes Forum,

ich habe in C++ eine Klasse für ein zweidimensionales Array 
implementiert und kann diese auch benutzen:

twodim var(2, 2);
var[0][0] = 0;

und so weiter.

Nun ist es mir aber etwas zu umständlich, beispielsweise eine 
5x5-Tabelle immer nach diesem Muster zu füllen. In den Sinn kommt mir, 
eine solche Syntax verwendbar zu machen:

int x[5][5] = {
{1, 2, 3, 4, 5},
{1, 2, 3, 4, 5},
{1, 2, 3, 4, 5},
{1, 2, 3, 4, 5},
{1, 2, 3, 4, 5},
}

Kann ich jetzt mit irgendeinem {Assignment-,}Operator sowas emulieren? 
Das Problem ist, dass 5x5 beliebig mxn sein soll.

Gruß,
Nico

[Klaus W. (mfgkw)]

Nein, weil das keine Zuweisung ist, sondern eine Initialisierung.
Da gibt es momentan keinen eleganten Weg für das, was ich vermute
was du wilst.

Mit dem nächsten C++ wird das wohl besser...

[Nico22 (Gast)]

Wenn deine Vermutung richtig ist, hast du wohl recht ;-)

Hast du denn irgendwas irgendwie ähnlich Elegantes? Oder geht das in C++ 
echt nur mit Krücken?

[Klaus W. (mfgkw)]

Ein Objekt eines eigenen Datentyps kannst du nicht mit
= { ... } initialisieren, sorry.

Wenn du dich auf g++ beschränkst, es also nicht portabel sein soll,
könnte es gehen.

[Nico22 (Gast)]

Danke, Klaus, für den Hinweis.

Hast du da ne Syntax oder Direktive zur Hand oder ein Stichwort? Wenn du 
erst suchen muss, schaue ich sonst selbst nach.

Nico

[Klaus W. (mfgkw)]

Was ich im Kopf hatte, sind die "compound literals" aus C99,
die der gcc bzw. g++ auch bei C++ akzeptiert, zusammen mit
einem entsprechenden ctor in der Klasse.

Ich hatte mir das so vorgestellt:

class Matrix
{
 public:

  Matrix( size_t m, size_t n, double arr[m][n] )
    : m( m ),
      n( n ),
      pWerte( new double[m*n] )
  {
    for( size_t i=0; i<m; ++i )
    {
      for( size_t j=0; j<n; ++j )
      {
        pWerte[i*n+j] = arr[i][j];
      }
    }
  }

  double &operator()( size_t i, size_t j )
  {
    return pWerte[i*n+j];
  }

 private:

  size_t     m;
  size_t     n;
  double    *pWerte;

}; // class Matrix

...
  Matrix    m( 3, 2,
               (double[3][2])
               {
                  { 1.0, 2.0 },
                  { 1.1, 2.1 },
                  { 1.1, 2.1 }
               }
               );

Das geht nur leider nicht so, weil im ctor der
Parameter double arr[m][n] nicht akzeptiert wird, wegen noch
unbekannten m und n.

Wenn man auf die zeilenweise Klammerung der Matrix beim Initialisieren 
verzichten kann, geht es zumindest so:

#include <iostream>

class Matrix
{
 public:

  Matrix( size_t m, size_t n )
    : m( m ),
      n( n ),
      pWerte( new double[m*n] )
  {
  }

  Matrix( size_t m, size_t n, double *arr )
    : m( m ),
      n( n ),
      pWerte( new double[m*n] )
  {
    for( size_t i=0; i<m; ++i )
    {
      for( size_t j=0; j<n; ++j )
      {
        pWerte[i*n+j] = arr[i*n+j];
      }
    }
  }

  double &operator()( size_t i, size_t j )
  {
    return pWerte[i*n+j];
  }

 private:

  size_t     m;
  size_t     n;
  double    *pWerte;

}; // class Matrix

int main( int nargs, char **args )
{
  Matrix    m( 3, 2,
               (double[])
               {
                  1.0, 2.0,
                  1.1, 2.1,
                  1.1, 2.1
               }
               );


  std::cout << "m( 2, 1 ) = " << m( 2, 1 ) << std::endl;
}

Das sieht schon etwas ähnlicher aus wie eine array-Initialisierung
in C.
Etwas eleganteres sehe ich spontan nicht, sorry.

[Yalu X. (yalu) (Moderator)]

Keine fertige Lösung, aber ein Ansatz:

Schau die mal die Boost-Assignment-Library an. Da werden durch Überladen
des ()- und des ,-Operators verrückteste Dinge gemacht, die noch weit
über das hinausgehen, was du vor hast, und das alles standardkonform:

  http://www.boost.org/doc/libs/1_45_0/libs/assign/doc/index.html

Ich habe sie mir nicht näher angeschaut, aber mit etwas Glück arbeitet
die Library direkt mit deiner Klasse zusammen, mit etwas weniger Glück
kannst du sie mittels weiterer Überladungen passend machen. Falls das
alles nicht funktionieren sollte, kannst du zumindest die Grundideen
übernehmen und etwas Ähnliches selbst schreiben.