class t_klasse {
      public:
          t_klasse(double a=0, bool b=0, char c=0, int d=1) { ... };
          ...
      private:

          double a;
          bool   b;
          char   c;
          int    d;
};

Beim Entwurf bin ich mir nicht ganz sicher, wie ich zwischen Konstruktor-[] und Zugriffs-[] unterscheiden kann. Konzept:

class t_klasse {
    public:
        t_klasse(double a=0, bool b=0, char c=0, int d=1);

        t_klasse operator[](size_t size) {
            a=new double[size];
            b=new bool[size];
            c=new char[size];
            d=new int[size]; } // denke, so lässt sich ein Feld erstellen ?!

        t_klasse(double a, bool b, char c, int d) {
            this->a=new double(a);
            this->b=new bool(b);   
            this->c=new char(c);                   
            this->d=new int(d); } // Standard-Konstruktor

    private:
          double *a;
          bool   *b;
          char   *c;
          int    *d;
};

Wie kann ich aber nun zugreifen? Ruft man t_klasse[element] auf, sollte theoretisch eine "NON-ARRAY t_klasse" zurückgegeben werden. Wäre dankbar über Ansätze zur Realisierung!

//edit:

Von Klassen-Pointer-Inkompatibilität geblendet hab ich ganz vergessen, das sich auch von "Natur aus" Klassen-Arrays erstellen lassen.

Naja, damit mein Posting weiterhin Sinn behält, gehen wir mal davon aus, dass sich die Größe des Arrays dynamisch ändern lässt. Die zentrale Frage ist aber noch die Geschichte mit den eckigen Klammern.

char foo[5];//dafür ist er nicht

//dafür ist er
foo[0]='a';
std::cout<<foo[0];

char matrix[20];

überladen? Vielleicht new[] überladen? Wie könnte eine entsprechende Klasse in Etwa aussehen?

Wenn Du
tKlasse matrix[20];

machst werden 20 Objekte vom Typ tKlasse erzeugt und auch für jedes der 20 der Standard-Konstruktor einmal aufgerufen.

Was willst Du denn erreichen? Kannst Du nicht die Anzahl dem Konstruktor als Integer übergeben und dann ein passendes Feld erzeugen?

sry