class SomeClass{
protected:
// Sowohl der Zeiger als auch der Inhalt des char-Arrays sollen konstant
// sein
const char* ConstantString[5];
public:

SomeClass();
};

Wie bekomme ich jetzt Daten in das Array hinein, strcpy klappt ja in der Konstruktor-Initialisierungsliste nicht! Und nur in einer Konstruktor-Initialisierungsliste kann man doch Konstanten initialisieren.

Bitte um Tipps.

oder

SomeClass() : ConstantString("Hallo") {};

P.S.: Nehm ich mal an

Gruß,

Simon2.

Boris hat wohl übersehen, das da nen 2Dim-Array ist. Bei einem 1Dim Char-Array sollte es so aber funktionieren.

Glaub' ich nicht !
Hab's nämlich auch übersehen und mit einem 1D-Array getestet ... und die Fehlermeldung zeigt auch, dass der Compiler sich daran stört, dass es sich um ein Array handelt ... nicht daran, dass es ein char ist; ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

Gruß,

Simon2.

würde das gehen?

Simon2 schrieb:

ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

char* arr1[4]; // "ein Array von char*" ( 2 Dim-Array : char** )
char  arr2[4]; // "ein Array von char"  ( 1 Dim-Array : char*  )

Du meinst da ist kein Unterschied ?

Und das würde nicht funktionieren ?

class SomeClass{
protected:
// Sowohl der Zeiger als auch der Inhalt des char-Arrays sollen konstant
// sein
const char* ConstantString;
public:
// C'tors von Boris
SomeClass() : ConstantString("Halo") {};
SomeClass(const char *a) : ConstantString(a) {};
};

Du meinst da ist kein Unterschied ?
Und das würde nicht funktionieren ?

Wie aus der Compilermeldung deutlich werden sollte, redet Simon vermutlich von Arrays, und nicht von Zeigern

class SomeClass{
const char ConstantStringA[5]; // as opposed to
const char* ConstantStringB[5];
};

(Kann sein das wir aneinander vorbeireden)

Simon2 schrieb:

ich wüsste also nicht, wo der Unterschied sein sollte, wenn man ein Array von char* statt eines von char nimmt.

char* arr1[4]; // "ein Array von char*" ( 2 Dim-Array : char** )
char  arr2[4]; // "ein Array von char"  ( 1 Dim-Array : char*  )

Du meinst da ist kein Unterschied ?...

Du hast den Zusammenhang meiner Aussage nicht beachtet: Wenn der Compiler sagt "Das geht mit Arrays nicht !", dann spielt es für ihn keine Rolle, ob es sich dabei um char[], char*[], int[], myType[], .... handelt, sondern es wird für alle gleich "nicht klappen".

KasF schrieb:

...
Und das würde nicht funktionieren ?
...

"Ob Du Recht hast oder nicht, sagt Dir gleich .... der Compiler !"
Wenn es nicht durch den Compiler geht, geht's nicht (was nicht bedeutet, dass es Std-konform ist, wenn es der Compiler schluckt .... ist ein reiner Falsifizierungstest) !
(Ausnahmen mit schlechten Compilern oder sehr komplizierten template-Kisten mal ausgelassen - solch eher einfachen Standardkonstrukte wie hier kriegen vernünftige Compiler ganz gut hin)

Gruß,

Simon2.

class SomeClass{
public:
  SomeClass( char const * (&s)[5] )
    : ConstantString(s, s+5)
  { }

protected:
  std::vector<std::string> const ConstantString;
};

// oder auch:

// SomeClass.cpp

namespace {
vector<string> make_SomeClass_strings( /* params */ )
{
  vector<string> result;
  // fill result
  return result;
}
} // anon namespace 

SomeClass::SomeClass()
  : ConstantString(make_SomeClass_strings())
{

}

Btw, const-Zeiger auf const sieht so aus:

char const * const foo;
// bzw
const char * const foo;