Ich möchte in einer abstrakten Basisklasse eine const definieren, die aber in jeweiligen Vererbungen einen anderen Wert hat. Wie muss ich das machen?

class ExampleBase
{
...
private:
    static const int max = 0;
...
}

class Example: public ExampleBase
{
...
private:
    static const int max = 100;
...
}

Danke schonmal

class ExampleBase
{
...
private:
    static const int max;
...
};
const int ExampleBase::max =0;
...

class Example: public ExampleBase
{
...
private:
    static const int max;
...
};
const int Example::max =1000;
...

nein, da sist so nicht richtig. Das was du machst ist genau dasselbe, was der threadstarter tut. bei static const sind diese vorortwertzuweisungen durchaus möglich. nichtsdestotrotz ändert sich dadurch nicht das verhalten(bin ich mir aber nicht ganz sicher, ob der compiler hier nicht böse fehlermeldungen wirft)

@Threadstarter
wenn du willst, dass dann methoden aus der Basisklasse zugriff auf den veränderten wert haben sollen, so ist das nicht möglich. static const ist typ gebunden, bzw compile time constant. da kann eine abgeleitete Klasse nichts daran ändern.

EDIT: lahm

Ein standardkonformer Compiler benötigt keine separate Definition von Konstanten. Innerhalb der Klasse definieren und initialisieren genügt.

Das stimmt so nicht. Ob eine Definition nötig ist, hängt vom Client-Code ab. Wird z.B. irgendwo die Adresse der Konstanten gebildet, wird auch eine separate Definition benötigt. Andernfalls wird spätestens der Linker ein "undefined external symbol" melden.

Wenn man also nicht genau weiß, wie die Konstante verwendet wird, schreibt man am Besten:

struct X {
    static const int i = 22;
};

// in einer cpp-Datei
const int X::i; // -> Definition ohne Initialisierung, da i bereits einen Wert hat

Also in Pseudo etwa so:

class AbstractBase
{
    ...
    (const?) int factor = 0
    ...
}

class Derivate1: public AbstractBase
{
    ...
    const? int factor = 12
    ..
}

class Derivate2: public AbstractBase
{
    ...
    const? int factor = 15
    ...
}
...
main()
{
    ...
    int x = 2   // per User Eingabe
    foreach( AbstractBase* Obj )
    {
        int y = x * Obj->factor
        print y
    }
    ...
}

Soll nun für Derivate1 24 ausgeben und für Derivate2 30 etc..
Geht sowas überhaupt?

Ich möchte einfach einen Klassenspezifischen, festen Wert setzten, einen Faktor für Berechnungen.
[...]
Geht sowas überhaupt?

Nicht so wie du es gemacht hast. Subtyping Polymorphie bezieht sich auf Verhalten (Funktionen) nicht auf Daten.
Du kannst also z.B. aus factor einfach eine virtuelle Funktion machen:

class AbstractBase {
public:
    virtual int factor() const { return 0; }
}

class Derivate1: public AbstractBase
{
    virtual int factor() const { return 12; }
}
...
main()
{
    ...
    int x = 2   // per User Eingabe
    foreach( AbstractBase* Obj )
    {
        int y = x * Obj->factor()
        print y
    }
    ...
}

Eine andere Alternative wäre des setzen des Faktors im Konstruktor:

class AbstractBase {
public:
    AbstractBase() : factor(0) {}
    const int factor;
protected:
    AbstractBase(int f) : factor(f) {}

}

class Derivate1: public AbstractBase
{
public:
  Derivate1() : AbstractBase(12) {}
}