Eleganz vs. Performance:

pale dog

BorisDieKlinge schrieb:

was ist schneller A oder B ? Vorschläge?

falls du 'm_Type' benutzt, um herauszufinden, ob es sich um ein AAA-objekt handelt, dann könntest du auch 'typeid' nehmen...

BorisDieKlinge

hmm.. genau will bspw. zwischen AAA und BBB objekten unterscheiden:) wie geht das mit typeid....

BorisDieKlinge schrieb:

return t==m_Type ? true : false;

das ergebnis eines vergleichs ist bereits ein boolscher wert.

return t==m_Type;

otze

BorisDieKlinge schrieb:

hmm.. genau will bspw. zwischen AAA und BBB objekten unterscheiden:) wie geht das mit typeid....

vielleicht solltest du dich eher fragen, ob du wirklich den typ der Klasse kennen musst, wahrscheinlich liegt da ein designfehler vor. Typeid braucht man in C++ eigentlich...nie, zumindest wenn man es richtig macht.

Swordfish

Für schnellen lesezugriff verwende ich immer eine public const&:

class foo_t {

    private:
        char m_type;

    public:
        const char &type;

        foo_t : m_type( 'x' ), type( m_type ) { };
}

greetz, Swordfish

BorisDieKlinge

ich hab quasie 2 klassen AAA und BBB welche beide von einer Abstrkten basisklasse ableiten..

Je nach Parameter, wird ein VEctor mit AAA und BBB gefühlt, wobei es immer untschiedlich sein kann bspw. 5 mal AAA dann 2mal BB dann wieder 1 AAA und 6 BBB etc. ist ganz unterschiedlich..

wenn ich nun den vector travesiere, will ich quaise immer checken vieviele AAA udn BBB nacheinander kommen im vector..

Versteht ihr!!

Meep Meep

Swordfish schrieb:

Für schnellen lesezugriff verwende ich immer eine public const&:
class foo_t {

    private:
        char m_type;

    public:
        const char &type;

        foo_t : m_type( 'x' ), type( m_type ) { };
}

davon abgesehen, das dadurch die klassengroesse marginal vergroessert wird, seh ich keinen grund warum das schneller sein soll.
ich tendiere eher dazu zu sagen, das egal ob ueber ne referenz, wie in deinem beispiel, oder mittels 'char getType(void) const { return m_type; }', beides nach der optimierung gleich schnell seit wird. wahrscheinlich ergibt es sogar den selben code. wobei bei referenzen ein aehnlich problem zu tage tritt, das naemlich zuerst die addresse ausgelesen werden muss, auf welche die referenz ueberhaupt zeigt.

Meep Meep

rapso

Meep Meep schrieb:

Swordfish schrieb:
Für schnellen lesezugriff verwende ich immer eine public const&:
class foo_t {

    private:
        char m_type;

    public:
        const char &type;

        foo_t : m_type( 'x' ), type( m_type ) { };
}
davon abgesehen, das dadurch die klassengroesse marginal vergroessert wird, seh ich keinen grund warum das schneller sein soll.

ist nicht schneller, ist auch nicht groesser da die reference wegoptimiert werden darf (da references keine groesse haben muessen) aber ich versteh auch nicht was gegen ein sauberes

'char getType(void) const { return m_type; }'

spricht.

wahrscheinlich ergibt es sogar den selben code. wobei bei referenzen ein aehnlich problem zu tage tritt, das naemlich zuerst die addresse ausgelesen werden muss, auf welche die referenz ueberhaupt zeigt.

nein, das ist ja kein pointer, die reference zeig immer auf m_type, ohne ausnahme, muss also nicht ausgelesen werden usw.

btw. meine version ist immer noch die schnellste

Braunstein

@BorisDieKlinge
wenn es nur um diese beiden Klassen geht, spendier doch der Basisklasse einfach eine Funktion die den Typ zurückgibt (eine String oder enum oder so).

tntnet

Swordfish schrieb:

Für schnellen lesezugriff verwende ich immer eine public const&:
class foo_t {

    private:
        char m_type;

    public:
        const char &type;

        foo_t : m_type( 'x' ), type( m_type ) { };
}
greetz, Swordfish

Das bringt ausser zusätzlicher Komplexität keine Vorteile . Da kannst Du die Variable auch gleich public machen, was aber böse ist. Für den lesezugriff verwende ich eine getter-Methode. Steht diese in der Klasse, wird diese inlined und ist genauso schnell, wie ein direkter Zugriff. Es bietet aber die Option, die Implementierung später zu ändern ohne das Interface zu ändern:

class Foo
{
    char m_type;
  public:
    char getType() const    { return m_type; }
    bool isTypeA() const    { return m_type == 'A'; }
};

Die Verwendung der Methoden bringen keinen Performancenachteil gegenüber public Variablen und Direktzugriff, dafür aber Lesbarkeit und die Freiheit, die Implementierung zu ändern.

Shinja

tntnet schrieb:

Das bringt ausser zusätzlicher Komplexität keine Vorteile . Da kannst Du die Variable auch gleich public machen, was aber böse ist.

Also irgendwie versteh ich jetzt nicht, wieso jeder das mit ner public variablen gleichsetzt... es ist doch ne const referenz, heiszt das nicht, dass man es nur lesend verwenden kann und man somit den gleichen effekt wie bei einer gettermethode hat??

tntnet

Shinja schrieb:

tntnet schrieb:

Das bringt ausser zusätzlicher Komplexität keine Vorteile . Da kannst Du die Variable auch gleich public machen, was aber böse ist.

Also irgendwie versteh ich jetzt nicht, wieso jeder das mit ner public variablen gleichsetzt... es ist doch ne const referenz, heiszt das nicht, dass man es nur lesend verwenden kann und man somit den gleichen effekt wie bei einer gettermethode hat??

Du kannst aber nur eine konstante Referenz liefern, wenn die Variable auch da ist. Will ich den Wert irgendwie anders speichern, kann ich das nicht tun. Bei einer Getter-Methode kann ich den Wert auch berechnen. Nehmen wir ein Beispiel: Wir haben ein Punkt:

class Point
{
    double m_x;
    double m_y;
  public:
    const double& x;
    const double& x;
    A() : x(m_x), y(m_y) { }
};

Hier habe ich eine public Referenz auf die Koordinaten. Ich kann einfach mit p.x und p.y (p ist vom Typ Point) auf die Koordinaten zugreifen. Später stelle ich fest, daß es praktikabler wäre, den Punkt in Polarkoordinaten zu speichern:

class Point
{
    double m_len;
    double m_deg;
  public:
    const double& len;
    const double& deg;
    A() : len(m_len), deg(m_deg) { }
};

Der Zugriff p.x ist jetzt nicht mehr möglich. Ich muß die Programme ändern, die diese Klasse verwendet haben.

Und jetzt die Variante mit Gettern:

class Point
{
    double m_x;
    double m_y;
  public:
    double getX() const  { return m_x; }
    double getY() const  { return m_y; }
};

Ich greife jetzt mit p.getX() und p.getY() auf meine Koordinaten zu. Mache ich das gleiche mit Polarkoordinaten ergibt sich das:

class Point
{
    double m_len;
    double m_rad;
  public:
    double getX() const  { return m_len * cos(m_rad); }
    double getY() const  { return m_len * sin(m_rad); }
};

Ich kann weiter mit p.getX() und p.getY() auf meine Koordinaten zugreifen. Das Interface hat sich nicht geändert, die Implementierung schon.

Tntnet