Geht das eleganter?

Man könnte zusammenfassend sagen:

Ja, es geht eleganter. Aber solang du darauf bestehst dass alles so bleibt wie es ist, gehts eben nicht eleganter.

*john 0

SucherDerEleganz schrieb:

Und so arrogante Aussagen wie sie von ~john könnt ihr euch auch sparen.

Arrogant ist hier nur eine Person. Es wird keinerlei Code herausgerückt, so daß es schlicht weg nicht möglich ist einen sinnvollen Vorschlag zu machen. Wenn man void* vermeiden will, muß man das Design entsprechend anpassen und dazu muß man das Programm entsprechend tiefgreifend ändern. Der Hinweis auf Double Dispatch ist insofern von Belang, weil dies der einzige sinnvolle Grund ist noch auf switch case mit TypeIDs in C++ auszuweichen. Macht man es trotzdem hat man einen Designfehler produziert. Bei Altlasten mag das durchaus sinnvoll sein es weiter zu behalten, aber das kann nicht der Regelfall für neuen Code sein.

Simon2

pumuckl@logged_off schrieb:

Man könnte zusammenfassend sagen:

Ja, es geht eleganter. Aber solang du darauf bestehst dass alles so bleibt wie es ist, gehts eben nicht eleganter.

Oder noch kürzer: "besser" ε { "anders" }

Tachyon

Was diskutiert ihr denn überhaupt mit so einer Knallerbse? Eure ganzen Tipps sind doch echt Perlen für die Säue. Ich wurde mal sagen, dass der gute TO sich inzwischen eindeutig als Troll geoutet hat.

*john 0

Simon2 schrieb:

Es geht hier um einen einfachen Dispatch (reine Erzeugung) anhand von Typinformationen, die erst zur Laufzeit aus einer Datei gelesen werden.

Im Falle von zwei Typen ist ein "Dispatch" schon overkill, eine Fallunterscheidung tät es da schon. Wenn man sich allerdings die Mühe macht extra Klassen zu erzeugen und dann Switch&Case mit TypID benutzt, dann vergeht mir der Spaß. Denn in so einem Fall kann man das gleich sauber und elegant machen, d.h. mittels Polymorphie, dafür ist sie ja in C++ vorhanden.

Simon2 schrieb:

Das Lesen den ganzen Threads wäre vllt. keine schlechte Idee gewesen. :p

Da der Thread nur wenig konkrete Information vom Urheber desselben beinhaltet, habe ich mich auf das Querlesen beschränkt. Ich weiß, bis jetzt nicht was sein konkretes Problem ist. Abgesehen davon, daß er Fallweise Floats und Doubles aus einer Datei einlesen muß, wird er nicht nämlich nicht sonderlich konkret.

Simon2

~john schrieb:

...Im Falle von zwei Typen ist ein "Dispatch" schon overkill...

Ich hatte das schon so verstanden, als ob es um eine deutlich größere Anzahl von Typen geht.

Hmmmm - ich bin ja auch ein grooooßer Freund von Polymorphie und ein ebenso intensiver Gegner von Typ-IDs (und dezugehörigem Frickelcode).
Aber wie hättest Du es denn (ohne Typkennzeichner und entsprechendes switch) die Erzeugung von Objekten unterschiedlichen Typs aus einem flat file gelöst ?
Natürlich kann man das auslagern in ein "Creator", an dem sich Factories registrieren ... aber ohne irgendein Typkennzeichen auskommen ? Da fällt mir gar nichts zu ein.

Gruß,

Simon2.

Tachyon

Simon2 schrieb:

Aber wie hättest Du es denn (ohne Typkennzeichner und entsprechendes switch) die Erzeugung von Objekten unterschiedlichen Typs aus einem flat file gelöst ?

Mit überladenen Funktionen für die jeweiligen Typen. Einlesen tut man dann in den entsprechenden Typen, und dann ruft man z.B. eine put Funktion auf. Welche put Funktion dann konkret benutzt wird, entscheidet der Typ der Einlesevariable.

Simon2

Tachyon schrieb:

...Mit überladenen Funktionen für die jeweiligen Typen. Einlesen tut man dann in den entsprechenden Typen, und dann ruft man z.B. eine put Funktion auf. Welche put Funktion dann konkret benutzt wird, entscheidet der Typ der Einlesevariable.

Sorry, hast Du da mal ein Beispiel für ?
(ich will jetzt nicht in die Fußstapfen des TOs treten, aber es interessiert mich wirklich)

Ich sage jetzt mal so: Nach meinem Verständnis greifen virtuelle Funktionen erst bei bereits erstellten Objekten (klar - ohne vtable geht's halt nicht) ... aber die Entscheidung, welches Objekt nun erzeugt wird, muss doch vorher stattfinden.
NACH der Erzeugung braucht man natürlich keinen Typkennzeichner mehr - da weiß jedes Objekt selbst, was für ein Typ es ist (bzw. wie es die virtual-Schnittstelle zu bedienen hat) - aber davor ?

Oder anders ausgedrückt: Was soll in dem File stehen und wer liest das ein ?

Gruß,

Simon2.

Tachyon

Simon2 schrieb:

...

Ne, ich rede hier nicht von Polymorphie und spätem binden.
Ich meinte frühes binden, so ähnlich, wie bei std::ostream:

void CC::put(int a);
void CC::put(float a);
void CC::put(double a);
//...

CC c(/*...*/);
//Entscheide, was gelesen wird, in diesem Fall float...
float input;
c.put(input); //CC::put(float a)

Irgendwie so.

Köstlich. Nur weil ich die vorgeschlagenen Lösung als absolut NICHT elegant finde, bin ich natürlich gleic ein Troll. Aber natürlich, das ist nicht Arroganz von euch - es ist wohl einfach Fakt, dass wenn man Lösungen von euch nicht sofort gut findet man automatisch ein blöder Troll ist. Widerlich so eine Haltung. Und wenn ich lesen muss, dass manche auf Seite 7 das Problem immer noch nicht verstanden habe (obwohl ich mehrmals den KOMPLETTEN Problemcode gepostet habe), kann man sich auch seinen Teil denken.

Und abzustreiten das der vorgeschlagene Code mit Kanonen auf Spatzen schießen ist, ist auch lächerlich. Um also 2 oder 3 ifs (ich wiederhole: ZWEI oder DREI ifs) im Code zu elimineren soll ich Konstrukte wie template <class T> class Foo : public IFoo, private boost::noncopyable, liste von einem Typ anlegen, wobei ich für jeden Datentyp eine eigene Klasse anlegen soll, reinterpret_casts usw usw.)
Und Double Dispatching Pattern bei diesem Fall vorschlagen, ist auch mehr als sinnfrei.

Wie ich bereits gesagt habe: Ich bleibe bei void*. Das hat absolut nichts mit Sturheit zu tun - welch idiotischer Vorwurf. Was glaubt ihr wohl warum ich hier im Forum frage ob es anders geht?
Wie auch immer, wenn ich die ellenlangen Codes mit dem winzige Code des void* Vergleiche ist die Entscheidung sehr leicht.

Es ist für Anfänger normal, dass sie "Eleganz" im Code noch nicht erkennen können.

Du brauchst dir also keine Vorwürfe zu machen. Nimm jetzt ruhig dein void* und später, viele, viele Bücher später, darfst du dann auch bei den großen Jungs mitspielen.

Bis dahin könntest du vielleicht auf das Rumtrollen verzichten, ja?

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

asc

SucherDerEleganz schrieb:

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

Aber selbst beleidigend werden, und Informationen verweigern.

Tachyon

SucherDerEleganz schrieb:

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

Lieber ein Arsch mit Niveau, als eine Blase voller Urin...

SucherDerEleganz schrieb:

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

Große Worte von einem der nach wenigen Posts anfängt die Intelligenz der Leute anzuzweifeln, die versuchen ihm zu helfen.

Ich hingegen hab selten ein Forum mit so einer Anhäufung von Kompetenz und so wenigen A***l**** erlebt.

Ansonsten stimme ich Tachyon zu.

Simon2

Tachyon schrieb:

Simon2 schrieb:

...

Ne, ich rede hier nicht von Polymorphie und spätem binden.
Ich meinte frühes binden, so ähnlich, wie bei std::ostream:
void CC::put(int a);
void CC::put(float a);
void CC::put(double a);
//...

CC c(/*...*/);
//Entscheide, was gelesen wird, in diesem Fall float...
float input;
c.put(input); //CC::put(float a)
Irgendwie so.

Aber das ist doch exakt dasselbe, wie ich mit meinem template-Ansatz gemacht habe (nur dass Du die overloads ausgeschrieben und Dich mit einem Kommentar um den switch gedrückt) hast... :p

Gruß,

Simon2.

Simon2

SucherDerEleganz schrieb:

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

Tröste Dich: Das Forum hat schon einige Newbies mit Diva-Komplex überlebt....

Übrigens: Hat Deine Haltung Dich inzwischen zum Ziel gebracht und Du Dein Problem gelöst ?

Gruß,

Simon2.

Nexus

SucherDerEleganz schrieb:

Naja, da mir offenbar niemand ein paar konkrete (!) Codeschnippsel zeigen kann, bleibe ich einfach bei meinem void*.

Spätestens auf Seite 3 hätte man merken müssen, dass er in seiner Sturheit sowieso sein void* bis zum Tod verteidigen wird.

Aber ja, ist ja nicht der erste Armer-Hilfesuchender-Gegen-Böse-Community-Krieg in diesem Forum. Eigentlich nur schade um die Zeit, die die Benutzer dafür opfern mussten...

Simon2 schrieb:

SucherDerEleganz schrieb:

Selten ein Forum erlebt mit so vielen arroganten Arschlöchern.

Tröste Dich: Das Forum hat schon einige Newbies mit Diva-Komplex überlebt....

Ich bin weder ein Newbie noch eine Diva. Aber der Grad an Arroganz hier ist einfach widerlich.

Simon2 schrieb:

Übrigens: Hat Deine Haltung Dich inzwischen zum Ziel gebracht und Du Dein Problem gelöst ?

Und wie so oft habe ich etwas bereits mehrfach gesagt aber es wird dennoch immer und immer wieder blöd nachgefragt. Ich habe bereits gesagt, dass ich den void* lasse. Ich habe in der Zwischenzeit schon zig andere Sachen gemacht, weil ich mich nicht ewig mit so Kleinscheiss rumplagen kann (ich muss produktiv sein und kann es mir nicht erlauben in meiner kleinen, theoretisch idealen Traumwelt rumzugeistern)

Wenn den Thread jemand mit etwas Distanz und Objektivität durchliest wird er feststellen, dass sich einige der Leute, die versucht haben zu Antworten, wie arrogante Kinder aufgeführt haben ("dädädä, dein Code is voll mies du Kackn00b, da muss man ja kotzen"; ja ist klar, ein void* ist die schlimmste Sünde der Erde) und nicht eine einzige lauffähige und elegante Lösung gezeigt wurde. Nur ewig lange Konstrukte, die ich dann natürlich noch modifizieren muss. Und wenn man das gezeigte dann nicht gut findet, liegt das natürlich nur daran, dass man ein Newbie ist und Diva.

Dravere

@SucherDerEleganz,
Was suchst du denn noch hier, wenn das hier alles arrogante Arschlöcher in diesem Forum sind?
Es wurde auf Seite eins eigentlich genügend gesagt, um dein Problem zu lösen, doch warst du nie zufrieden, ohne wirklich zu begründen. Wurdest sogar etwas vorlaut und am Ende beleidigend, da kann man wirklich nicht viel anderes erwarten.

Zudem ist es wirklich fraglich, ob du wirklich genügend Verständnis von C++ hast, dass du kein Newbie bist. Ich will dir jetzt nicht auf die Füsse treten, aber wenn ich dich mal von der ersten Seite zitieren darf:

SucherDerEleganz schrieb:

Wie ich nun den void* data durch ein std::tr1::array ersetzen kann ist mir nicht ganz klar. Dazu brauch ich ja den Typen, aber den kenn ich ja nicht bei der Deklaration der Klasse. Ich müsste wohl also sowas schreiben:
std::tr1::array<T> und Foo zu einer Template Klasse machen, oder? Aber das will ich auf keinen Fall, denn Foo hat mit Templates ja eigentlich nix am Hut

Wieso willst du unbedingt verhindern, dass Foo zu einer Templateklasse wird? Wieso sollte sie nichts mit Templates am Hut haben? Genau für sowas sind Templates da, aber das scheinst du ja nicht zu verstehen.

Es wurde zwar schon Code gezeigt, aber ich kann dir gern nochmals was hinklatschen. Ich nehme jetzt nur die Beschreibung vom Problem, welche du auf der ersten Seite gegeben hast, die sollte ja ausreichen, oder?

template<typename ValueT>
class Foo
{
  // Typedefs //
public:
  typedef ValueT Value;
  typedef std::vector<Value> Vector;

  // Attributes //
private:
  Vector m_vector;

  // Constructors & Destructor //
public:
  Foo();
  ~Foo();

  // Methods //
public:
  void read(typename Vector::size_type amount);
  void method();
};

template<typename ValueT>
void Foo<ValueT>::read(typename Vector::size_type amount)
{
  // ...
  m_vector.resize(amount);
  // ...
}

template<typename ValueT>
void Foo<ValueT>::method()
{
  // ...
  y = m_vector[index] * scaleY;
  // ...
}

Genau was du verlangt hast. Wieso willst du es dann nicht? Und sowas ähnliches hatte sogar schon drakon hingeschrieben, auch auf Seite eins. Aber aus einem nicht ergründbaren Grund, verabscheust du anscheinend Templates ...

Grüssli