static const member_

Hello

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 = 0;
...
};
const int ExampleBase::max =0;
...

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

Kapier ich nicht.
Du änderst da ja nochmal den Wert der Kosntanten

ups sorry hatte deinen code nur abkopiert und was dazu geschrieben. muss natürlich sohier aussehen:

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;
...

otze

@Cpt.Tanga

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.

LordJaxom

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

EDIT: lahm

HumeSikkins

LordJaxom schrieb:

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

Sry, ich kapiers nicht ganz.
Ich möchte einfach einen Klassenspezifischen, festen Wert setzten, einen Faktor für Berechnungen.
Da ich nun die polymorphen Objekte mit Zeigern auf die Basisklasse bearbeite, muss ich den Faktor ja überladen, oder?

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?

HumeSikkins

Statiker schrieb:

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) {}
}