c++ Klassen Deklaration/Definition

[Rasputin (Gast)]

Hilfe Forum,

Wie mache ich bei folgendem Code die Deklaration/Definition richtig?

#include <memory>
#include <set>

struct A;
struct B;
struct less;

struct A {
  typedef std::shared_ptr<A> ptr_t;
  typedef std::set<ptr_t, less> set_t;

  int value;

  A(int _value) : value(_value) {
  }
};

struct B {
  typedef std::shared_ptr<B> ptr_t;
  typedef std::set<ptr_t, less> set_t;

  int num;

  A::set_t data;

  B(int _num) : num(_num) {
  }
};

struct less {
  bool operator()(const A::ptr_t &lh, const A::ptr_t &rh) {
    return lh->value < rh->value;
  }

  bool operator()(const B::ptr_t &lh, const B::ptr_t &rh) {
    return lh->num < rh->num;
  }
};

struct C {
  B::set_t data;
};


int main() {
  A::ptr_t a1(new A(1));
  A::ptr_t a2(new A(2));

  B::ptr_t b(new(1));

  b->data.insert(a1);
  b->data.insert(a2);

  C c;

  c.data.insert(b);

}

Ich krieg' gleich die Kriese und bin dankbar für jede Hilfe! :/

[Sebastian V. (sebi_s)]

Vor der Definition deiner Klassen A und B muss die less Klasse bekannt 
sein. Das kannst du z.B. durch folgende Definition der Klasse erreichen:

struct less {
  bool operator()(const std::shared_ptr<A> &lh, const std::shared_ptr<A> &rh);
  bool operator()(const std::shared_ptr<B> &lh, const std::shared_ptr<B> &rh);
};

Die Definition der Funktionen kann dann erst folgen wenn die Klassen A 
und B auch definiert wurden. Eine Möglichkeit direkt die typedefs in 
deiner Klasse zu benutzen fällt mir jetzt nicht ein.

[Wilhelm M. (wimalopaan)]

Mit einem template, da der code strukturell identisch ist, bzw. nur vom 
DT abhängig ist. Ausserdem erfolgt die Instanziierung eines Templates 
"lazy", also erst da, wo sie gebraucht wird.

#include <memory>
#include <set>

struct A;
struct B;
//struct less;

template<typename T>
struct less {
  bool operator()(const typename T::ptr_t &lh, const typename T::ptr_t &rh) {
    return lh->value < rh->value;
  }
};

struct A {
  typedef std::shared_ptr<A> ptr_t;
  typedef std::set<ptr_t, less<A>> set_t;

  int value;

  A(int _value) : value(_value) {
  }
};

struct B {
  typedef std::shared_ptr<B> ptr_t;
  typedef std::set<ptr_t, less<B>> set_t;

  int num;
  int value;

  A::set_t data;

  B(int _num) : num(_num) {
  }
};


struct C {
  B::set_t data;
};


int main() {
  A::ptr_t a1(new A(1));
  A::ptr_t a2(new A(2));

  B::ptr_t b(new B(1));

  b->data.insert(a1);
  b->data.insert(a2);

  C c;

  c.data.insert(b);

}

Wobei ich mal eben Dein Datenelement umbenannt habe in B. Falls dass 
nicht gewüncht ist, müsstest Du das template less für B spezialisieren 
...

[nicht“Gast“ (Gast)]

Moin,

Ehrlich.nach das so nicht. Schon bei den kleinen Schnipsel Code ist es 
schon nicht mehr intuitiv durchzusehen was da passieren soll. Lass den 
mal ein wenig größer werden und ein halbes Jahr vergehen. Dann sieht 
keiner mehr durch. Sich du nicht.

[Wilhelm M. (wimalopaan)]

Warum ist der "normale" Weg für Dich nicht anwendbar?

struct A {
  typedef std::shared_ptr<A> ptr_t;
  typedef std::set<ptr_t> set_t;

  int value;

  A(int _value) : value(_value) {
  }
};

bool operator<(const A& lhs, const A& rhs) {
    return lhs.value < rhs.value;
}

[Sebastian V. (sebi_s)]

Wilhelm M. schrieb:
> Warum ist der "normale" Weg für Dich nicht anwendbar? [...]

So würde das set doch nur die shared_ptr vergleichen, aber nicht die 
Werte. Aber für das Problem würde ich mir dann ein ptr_less Functor 
bauen der Pointer vergleicht indem er sie dereferenziert und die Werte 
vergleicht.

[Wilhelm M. (wimalopaan)]

Jo klar, meinte auch das:

bool operator<(const std::shared_ptr<A>& lhs, const std::shared_ptr<A>& rhs) {
    return lhs->value < rhs->value;
}

[Rasputin (Gast)]

Danke sehr für die zahlreiche Beteiligung!

Wilhelm M. schrieb:
> Warum ist der "normale" Weg für Dich nicht anwendbar?

Funktioniert leider so nicht (auch dein 2ter Vorschlag). Ich schätze, 
weil für std::shared_ptr<T> bereits alle Vergleichsoperatoren definiert 
sind:
http://de.cppreference.com/w/cpp/memory/shared_ptr/operator_cmp

Wilhelm M. schrieb:
> Mit einem template, da der code strukturell identisch ist, bzw. nur vom
> DT abhängig ist.

Ist er leider nicht. Ich habe absichtlich A::value und B::num genannt, 
denn im eigentlichen Code heissen die auch nicht gleich. Ich kann diese 
Variable nicht umbenennen (bzw. ich will nicht, weil dadurch der Sinn 
nicht mehr ersichtlich wäre).

Sebastian V. schrieb:
> Die Definition der Funktionen kann dann erst folgen wenn die Klassen A
> und B auch definiert wurden. Eine Möglichkeit direkt die typedefs in
> deiner Klasse zu benutzen fällt mir jetzt nicht ein.

Ok, trotzdem Danke.

nicht“Gast“ schrieb:
> Moin,
>
> Ehrlich.nach das so nicht. Schon bei den kleinen Schnipsel Code ist es
> schon nicht mehr intuitiv durchzusehen was da passieren soll. Lass den
> mal ein wenig größer werden und ein halbes Jahr vergehen. Dann sieht
> keiner mehr durch. Sich du nicht.

Auf was beziehst du dich?

[Wilhelm M. (wimalopaan)]

Wie wärs damit?

#include <memory>
#include <set>
#include <functional>

struct A {
    int value;
    A(int _value) : value(_value) {}
};

namespace std {
template<>
struct less<std::shared_ptr<A>> {
      bool operator()(const std::shared_ptr<A> &lh, const std::shared_ptr<A> &rh) {
          std::cout << __PRETTY_FUNCTION__ << std::endl;
          return lh->value < rh->value;
      }
}; 
}

struct B {
    typedef std::shared_ptr<A> ptr_t;
    typedef std::set<ptr_t, std::less<std::shared_ptr<A>>> set_t;
    
    int num;

    set_t data;
    
    B(int _num) : num(_num) {}
};

namespace std {
template<>
struct less<std::shared_ptr<B>> {
      bool operator()(const std::shared_ptr<B> &lh, const std::shared_ptr<B> &rh) {
          std::cout << __PRETTY_FUNCTION__ << std::endl;
          return lh->num < rh->num;
      }
}; 
}

struct C {
    typedef std::shared_ptr<B> ptr_t;
    typedef std::set<ptr_t, std::less<std::shared_ptr<B>>> set_t;
    set_t data;
};


int main() {
  B::ptr_t a1(new A(1));
  B::ptr_t a2(new A(2));

  C::ptr_t b(new B(1));

  b->data.insert(a1);
  b->data.insert(a2);

  C c;

  c.data.insert(b);

}

[Wilhelm M. (wimalopaan)]

Du kannst auch für std::set den Comparator-Typ-Parameter weglassen fällt 
mir grad auf. Denn die vollständige Spezialisierung hat ja gegenüber dem 
allgemeiner Template Vorrang:

struct B {
    typedef std::shared_ptr<A> ptr_t;
    typedef std::set<ptr_t> set_t;
    
    int num;

    set_t data;
    
    B(int _num) : num(_num) {}
};

[Rasputin (Gast)]

Ich hatte noch eine Idee. Und funktioniert sogar ;) Wirkt auf mich 
relativ sauber.

#include <memory>
#include <set>

struct A;
struct B;

struct shared_ptr_less {
  template <typename T>
  bool operator()(const std::shared_ptr<T> &lh, const std::shared_ptr<T> &rh) {
    return (*lh) < (*rh);
  }
};

struct A {
  typedef std::shared_ptr<A> ptr_t;
  typedef std::set<ptr_t, shared_ptr_less> set_t;

  const int value;

  A(int _value) : value(_value) {
  }
};

struct B {
  typedef std::shared_ptr<B> ptr_t;
  typedef std::set<ptr_t, shared_ptr_less> set_t;

  const int num;

  A::set_t data;

  B(int _num) : num(_num) {
  }
};

inline bool operator<(const A &lh, const A &rh) {
  return lh.value < rh.value;
}

inline bool operator<(const B &lh, const B &rh) {
  return lh.num < rh.num;
}

struct C {
  B::set_t data;
};

int main() {
  A::ptr_t a1(new A(10));
  A::ptr_t a2(new A(2));
  A::ptr_t a3(new A(1024));
  A::ptr_t a4(new A(128));

  B::ptr_t b(new B(1));

  b->data.insert(a1);
  b->data.insert(a2);
  b->data.insert(a3);
  b->data.insert(a4);

  for (auto it = b->data.begin(); it != b->data.end(); it++) {
    printf("%i\n", (*it)->value);
  }

  C c;

  c.data.insert(b);
}

P.S.: oben habe ich noch const vor int vergessen! Das ist natürlich sehr 
wichtig!

[Wilhelm M. (wimalopaan)]

Ja, geht auch, wenn Du auch möchtest, dass die DT A bzw. B generell 
anordnenbar sein sollen. Aber das wird wohl so sein.

Das "normale" Vorgehen, ist allerdings std::less zu spezialisieren - in 
dem Sinne, dass man das gewissermaßen erwartet ... Das kannst Du ja aber 
auch mit Deinem Ansatz kombinieren.

[Rasputin (Gast)]

Wilhelm M. schrieb:
> namespace std {
> template<>
> struct less<std::shared_ptr<A>> {
>       bool operator()(const std::shared_ptr<A> &lh, const
> std::shared_ptr<A> &rh) {
>           std::cout << _PRETTY_FUNCTION_ << std::endl;
>           return lh->value < rh->value;
>       }
> };
> }

Bist du sicher? Ich bekomme:
error: redefinition of 'struct std::less<std::shared_ptr<A> >'

[Wilhelm M. (wimalopaan)]

Ja.
Poste bitte Deinen gesamten Code.

[Rasputin (Gast)]

Fehlalarm. Beim 2ten Mal gings. Muss wohl irgendwas doppel kopiert 
haben.