Wie kann man Code Kopie durch Template ersetzen?

volkard

Vielleicht wäre was möglich, aber solange der Kontext ein großes Geheimnis ist, natürlich nicht. Das geht dann für 100€/h.

volkard schrieb:

Übungsaufgabe vom Prof? Dann fehlt mehr Kontext, um zu ahnen, auf was er hinauswill.

Wenns von einem Prof käme könnte der vielleicht einen vptr-Hack erwarten. Standardkonform geht das jedenfalls nur mit den 2^17 ifs (weil unsigned nur von 0 bis 2^16 gehen muss).

@tjroamer: Wenn du wenigstens die Signatur in std::vector<std::shared_ptr<thing_dispatcher*>> ändern könntest, hättest du noch eine kleine Chance (sofern du die Erstellung der Liste beeinflussen kannst).

Es sieht so aus, dass ich 2^32 Mal schreiben muss, um alle möglichen Fälle abzudecken.

Ach nein, da ist ein Troll am Werk. Hat sich erledigt.

tjroamer

Sone schrieb:

volkard schrieb:

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion

Bitte die vollständige Anforderung schreiben. Immer wieder einen halben Satz zu kriegen, der alles umwirft, das ist nicht fein.

Wovon redest du?

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion [...] func(std::vector<Base*> &obj_list)[...] anbieten, um andere sie aufrufen zu können.

Sorry, vielleicht habe ich nicht klar geschrieben. Jetzt ist die konkrete Anforderung:

**Meine Klasse muss den Usern die Funktion

void func(std::vector<Base*> *obj_list);

zur Verfügung stellen. Die Funktion muss je nach der Subklasse do_thing_1() oder do_thing_2() richtig aufrufen.
**

Gruß,

Kai

volkard

tjroamer schrieb:

Sone schrieb:

volkard schrieb:

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion

Bitte die vollständige Anforderung schreiben. Immer wieder einen halben Satz zu kriegen, der alles umwirft, das ist nicht fein.

Wovon redest du?

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion [...] func(std::vector<Base*> &obj_list)[...] anbieten, um andere sie aufrufen zu können.

Sorry, vielleicht habe ich nicht klar geschrieben. Jetzt ist die konkrete Anforderung:

**Meine Klasse muss den Usern die Funktion
void func(std::vector<Base*> *obj_list);
zur Verfügung stellen. Die Funktion muss je nach der Subklasse do_thing_1() oder do_thing_2() richtig aufrufen.
**

Gruß,

Kai

Süßer, wir haben den Code von Base immer noch nicht. Sind wenigstens do_thing_1 und do_thing_2 dort virtuell? Dann würde doch RTTI reichen.

tjroamer

BöserBube schrieb:

volkard schrieb:

Übungsaufgabe vom Prof? Dann fehlt mehr Kontext, um zu ahnen, auf was er hinauswill.

Wenns von einem Prof käme könnte der vielleicht einen vptr-Hack erwarten. Standardkonform geht das jedenfalls nur mit den 2^17 ifs (weil unsigned nur von 0 bis 2^16 gehen muss).

@tjroamer: Wenn du wenigstens die Signatur in std::vector<std::shared_ptr<thing_dispatcher*>> ändern könntest, hättest du noch eine kleine Chance (sofern du die Erstellung der Liste beeinflussen kannst).

Es sieht so aus, dass ich 2^32 Mal schreiben muss, um alle möglichen Fälle abzudecken.

Ach nein, da ist ein Troll am Werk. Hat sich erledigt.

ich denke, ich muss aufgeben, der Parameter std::vector<Base*> ist leider nicht änderbar. Vielen Dank an euch allen für eure Zeit und gute Nacht!

Gruß,

Kai

tjroamer

volkard schrieb:

tjroamer schrieb:
Sone schrieb:

volkard schrieb:

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion

Bitte die vollständige Anforderung schreiben. Immer wieder einen halben Satz zu kriegen, der alles umwirft, das ist nicht fein.

Wovon redest du?

tjroamer schrieb:

Die Anforderung ist: meine Klasse muss die public Funktion [...] func(std::vector<Base*> &obj_list)[...] anbieten, um andere sie aufrufen zu können.

Sorry, vielleicht habe ich nicht klar geschrieben. Jetzt ist die konkrete Anforderung:

**Meine Klasse muss den Usern die Funktion
void func(std::vector<Base*> *obj_list);
zur Verfügung stellen. Die Funktion muss je nach der Subklasse do_thing_1() oder do_thing_2() richtig aufrufen.
**

Gruß,

Kai
Süßer, wir haben den Code von Base immer noch nicht. Sind wenigstens do_thing_1 und do_thing_2 dort virtuell? Dann würde doch RTTI reichen.

die Klasse Base und A<N>, B<N> sehen so aus:

class Base
{
public:
  Base() {}
  virtual const char* kind();
  virtual const char* name();
  virtual ~Base();
};

template<unsigned int N>
class A: public Base
{
public:
  A() {}
  void do_thing_1()
  {
    // do thing_1 depending on the N
  }

  virtual const char* kind() { return "A"; }
  virtual const char* name() { return "A"; }
};

template<unsigned int N>
class B: public Base
{
public:
  B() {}
  void do_thing_2()
  {
    // do thing_2 depending on the N
  }

  virtual const char* kind() { return "B"; }
  virtual const char* name() { return "B"; }
};

do_thing_1() und do_thing_2() sind keine virtual

Sone

Aber Hase! Da sind ja weder do_thing_1 oder ~_2 in der Basisklasse deklariert, geschweige denn virtuell!

Übrigens, die sind so klein? In dem Fall sei doch ein ganz Böser Bezlebub' und schreib die zwei Zeilen da rein - ich nehme die Verantwortung auf mich:

virtual void do_thing_1() = 0;
virtual void do_thing_2() = 0;

tjroamer

Sone schrieb:

Aber Hase! Da sind ja weder do_thing_1 oder ~_2 in der Basisklasse deklariert, geschweige denn virtuell!

Übrigens, die sind so klein? In dem Fall sei doch ein ganz Böser Bezlebub' und schreib die zwei Zeilen da rein - ich nehme die Verantwortung auf mich:
virtual void do_thing_1() = 0;
virtual void do_thing_2() = 0;

anscheinend gibt es keinen anderen Weg. OK, ich versuche auf diesen Weg zu gehen. Vielen Dank.

Gruß,

Kai

camper

tjroamer schrieb:

Das ist fast unmöglich, 2^32 Möglichkeiten aufzulisten.

Das ist nicht dein Problem. Dein Problem ist, dass du 2^32+ verschiedene Funktionen hast.

Sone

camper schrieb:

tjroamer schrieb:

Das ist fast unmöglich, 2^32 Möglichkeiten aufzulisten.

Das ist nicht dein Problem. Dein Problem ist, dass du 2^32+ verschiedene Funktionen hast.

Fast ein wenig ironisch - Stroustrup schreibt noch, Templates sind gut, um den Maschinencode zu verkürzen
Edit: Oder so ähnlich.

tjroamer

camper schrieb:

tjroamer schrieb:

Das ist fast unmöglich, 2^32 Möglichkeiten aufzulisten.

Das ist nicht dein Problem. Dein Problem ist, dass du 2^32+ verschiedene Funktionen hast.

die Funktion operate() ist als template definiert. Hier ist kein Problem. Der User kann folgenden Code schreiben:

A<13> a_13();
B<1000> b_1000();

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);

MyClass muss solchen Code beherrschen. Das ist mein Problem.

Gruß,

/Kai

volkard

A<13> a_13();//er wird
B<1000> b_1000();//sich wundern

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);//hier
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);

tjroamer

volkard schrieb:

A<13> a_13();//er wird
B<1000> b_1000();//sich wundern

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);//hier
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);

gibt es hier einen Tippfehler oder wie?

Gruß,

Kai

Sone

Ich sehe es sofort. :stolz:

Edit:

tjroamer schrieb:

volkard schrieb:

A<13> a_13();//er wird
B<1000> b_1000();//sich wundern

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);//hier
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);

gibt es hier einen Tippfehler oder wie?

Das sind Funktionsdeklarationen.
Guckstdu.

tjroamer

Sone schrieb:

Ich sehe es sofort. :stolz:

Edit:

tjroamer schrieb:
volkard schrieb:
A<13> a_13();//er wird
B<1000> b_1000();//sich wundern

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);//hier
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);
gibt es hier einen Tippfehler oder wie?
Das sind Funktionsdeklarationen.
Guckstdu.

OK. Wahrscheinlich habe ich zu einfach geschrieben. Ich wollte schreiben, a_13 und b_1000 sind zwei Klassenobjekten.

sollte sein:

A<13> a_13;
B<1000> b_1000;

Gruß,

/Kai

volkard

tjroamer schrieb:

camper schrieb:

tjroamer schrieb:

Das ist fast unmöglich, 2^32 Möglichkeiten aufzulisten.

Das ist nicht dein Problem. Dein Problem ist, dass du 2^32+ verschiedene Funktionen hast.

die Funktion operate() ist als template definiert. Hier ist kein Problem. Der User kann folgenden Code schreiben:
A<13> a_13();
B<1000> b_1000();

std::vector<Base*> obj_list;
obj_list.push_back(&a_13);
obj_list.push_back(&b_1000);

MyClass myclass();

myclass.func(obj_list);
MyClass muss solchen Code beherrschen. Das ist mein Problem.

Gruß,

/Kai

Aber der User ist bei Euch und kann auch angewiesen werden, die Liste ein wenig anders zu bauen?

Zum Beispiel ist die Liste ein Template-Listen-Ding, was die Typen der Elemente alle kennt? //Am besten, aber für Dich am schwierigsten und schränkt die Benutzer am meisten ein.

Oder dürfen wir einen Wrapper um A und B bauen, der zusätzlich die Adresse der wichtigen Funktion kennt und nur solche Objekte darf der User anlegen? //Naja, häßlich.

Oder auch nur den Zwang, wenn er ein A<13> benutzt, muß er auch

registerVptrAndFunc<A<13>>();

mindestens einmal im Programm aufrufen? //Stört den Benutzer vermutlich am wenigsten und ist auch schnell gebastelt. Leider compilerabhängige Tricks.

Sone

tjroamer schrieb:

die Funktion operate() ist als template definiert.

Um das Template geht es nicht. Sondern um die daraus instantiierten Funktionen.

Ich hab grad mal im Anhang B (N3337) nachgeguckt - komisch. Sollte doch irgendwie impliziert sein, dass....

volkard

Wir gehen davon aus, daß die Benutzer nur ein paar, vielleicht mal 50 A- und B-Klassen in einem Projekt benutzt, das sind dann 100 Funktionen. Ok, wenn er sie braucht. Der Compiler erzeugt sie.
Aber wenn Du anmeldest, 2^32 Funktionen zu brauchen, indem Du in lauter if-Zeigen eine der Adressen anfragst, machste die ausführbarre Datei recht groß.
Wäre die erste 400GB große exe-Datei, die ich sehen würde.
Mach mal.

volkard schrieb:

Wir gehen davon aus, daß die Benutzer nur ein paar, vielleicht mal 50 A- und B-Klassen in einem Projekt benutzt, das sind dann 100 Funktionen. Ok, wenn er sie braucht. Der Compiler erzeugt sie.
Aber wenn Du anmeldest, 2^32 Funktionen zu brauchen, indem Du in lauter if-Zeigen eine der Adressen anfragst, machste die ausführbarre Datei recht groß.
Wäre die erste 400GB große exe-Datei, die ich sehen würde.
Mach mal.

Ja, der Nutzer verwendet nur normalerweise nur bis zur 512 . Ich kann 512*2 if-anweisung manuell schreiben. Ich habe gefragt weil ich dumm fand wenn man solchen hässlichen code schreiben muss. Aber man muss so tun wenn nichts andere geht.

tjroamer

volkard schrieb:

Wir gehen davon aus, daß die Benutzer nur ein paar, vielleicht mal 50 A- und B-Klassen in einem Projekt benutzt, das sind dann 100 Funktionen. Ok, wenn er sie braucht. Der Compiler erzeugt sie.
Aber wenn Du anmeldest, 2^32 Funktionen zu brauchen, indem Du in lauter if-Zeigen eine der Adressen anfragst, machste die ausführbarre Datei recht groß.
Wäre die erste 400GB große exe-Datei, die ich sehen würde.
Mach mal.

Mach mal.

Ja, der Nutzer verwendet nur normalerweise nur bis zur 512 . Ich kann 512*2 if-anweisung manuell schreiben. Ich habe gefragt weil ich dumm fand wenn man solchen hässlichen code schreiben muss. Aber man muss so tun wenn nichts andere geht.