Geht das eleganter?

[Badestrand]

@SucheDerEleganz: Der Vorschlag ist nicht lächerlich, du verstehst nur nicht genau, was ich meine Also ich schlage dir nicht vor, die Bytes einfach roh in den double-Speicher reinzukopieren, denn das wäre total dämlich wie du ja selbst sagst.
Ich schlage stattdessen vor, jeden Zahlenwert in einem double-Wert zu speichern, egal ob es vorher ein char, int oder float war.
Um es wirklich deutlich zu machen (sonst geht das noch 10 mal hin und her): Bei einer Byte-Datei liest du das erste Byte der Datei ein, wandelst dieses Byte in ein double um (der dann logischerweise einen Wert zwischen 0..255 enthält) und pusht diesen double in das Array rein. So hast du dann kein Array aus Bytes/Shorts/.., sondern ein Array aus doubles, wobei byte_array[i]==double_array[i] gilt, du also bei dem double-Arrayzugriff die selben Werte erhältst, als wenn du die Werte in einem Byte-Array speichern würdest.

Hier eine Beispiel-Lade-Funktion:

template<typename T> std::vector<double> loadFile( const char* path )
{
	// Datei öffnen
	std::ifstream file( path, std::ios::binary );
	if ( ! file )
		throw "file could not be loaded";

	// Dateigröße ermitteln
	file.seekg( 0, std::ios::end );
	const std::streamsize file_size = file.tellg();
	file.seekg( 0, std::ios::beg );

	// Die Dateigröße muss mit der Datentypgröße zusammenpassen
	if ( file_size % sizeof(T) != 0 )
		throw "file is corrupt";

	// Datei einlesen
	std::vector<T> raw( file_size / sizeof(T) );
	file.read( reinterpret_cast<char*>(&raw[0]), file_size );

	// Alle Werte zu doubles konvertieren und zurückgeben
	return std::vector<double>( raw.begin(), raw.end() );
}

int main()
{
	try
	{
		std::vector<double> arr = loadFile<char>( "bla.bin" );

		// Oder auch:
		if ( /*ist byte-Datei*/ )
			arr = loadFile<char>( "bla.bin" );
		else if ( /*ist short-Datei*/ )
			arr = loadFile<short>( "bla.bin" );
		else if ( ...

		// Ausgabe der Werte
		std::copy( arr.begin(), arr.end(), std::ostream_iterator<double>(std::cout,"\n") );
	}
	catch ( const char* err )
	{
		std::cout << "Error: " << err << "!" << std::endl;
	}
}

[SucherDerEleganz]

Hehe, ok. Die Aussage "Speicher die Werte einfach alle in einem double Array" war etwas missverständlich;)
Der von dir gepostete Code würde natürlich gehen, aber mal ehrlich.. elegant ist das nicht. Zunächst mal der eklige reinterpret_cast, dann lädst du alles in einen vector des passenden Typs ein, um die Werte dann wieder in einen double vector zu kopieren. Und die enorme Speicherverschwendung wäre auch ein KO Kriterium für mich (ferner sind Operationen wie mul auf doubles langsamer im Vergleich zu ints oder chars, aber das wäre jetzt nicht ausschlaggebend;)

Was ich bräuchte wäre sowas wie dynamische Templates:
Foo Member: array<T> foo;
Foo Ctor: Foo(type t) { foo.setType(t); foo.add(...); }
Aufruf: Foo* f = new Foo(int);

Aber sowas geht leider nicht^^

[Nexus]

SucherDerEleganz schrieb:

Aber sowas geht leider nicht^^

Schau dir vielleicht mal Boost.Any und Boost.Variant an. Aber in deinem Fall gibts eigentlich bessere Möglichkeiten, die hier schon erwähnt wurden...

[Badestrand]

SucherDerEleganz schrieb:

Und die enorme Speicherverschwendung wäre auch ein KO Kriterium für mich (ferner sind Operationen wie mul auf doubles langsamer im Vergleich zu ints oder chars, aber das wäre jetzt nicht ausschlaggebend;)

Genau deswegen braucht man mehr Infos von dir. Sag doch gleich, dass du viele Werte oder wenig Speicher hast und deine Rechenzeit knapp ist. Dann hätte ich mir die ganze Mühe nicht machen brauchen. Gr!

[Don06]

Außerdem solltest du natürlich auch erwähnen wie viele Werte du grob verarbeiten musst. Viele überschätzen soetwas. Man sollte zunächst sauberen Code schreiben, bevor man zu solchen Hacks wie void* Zeigern greift. Ist die Stelle im Code wirklich so performancerelevant wie du denkst, hat dein Profiler dir das gesagt? Wenn nicht, nimm Badestrands Variante, dass ist für jeden C++ Programmierer wesentlich verständlicher, als dieses void*-Zeug.

[SucherDerEleganz]

Badestrand schrieb:

Genau deswegen braucht man mehr Infos von dir. Sag doch gleich, dass du viele Werte oder wenig Speicher hast und deine Rechenzeit knapp ist.

Völlig unerheblich wieviele es sind. Die bis zu 8 (!) fache Speichermenge zu verbraten ist nicht sinnvoll - egal ob ich nun 1000 Daten oder 10^9 habe.

@Don06: Nein, eher nicht. Ich werde keine 50 Zeilen Code schreiben um Zeilen code zu ändern. Abgesehen davon hat mir noch immer keiner geantwortet, wie ich nun bei Badestrands Template Lösung die Daten in der Klasse speichern soll (sprich: was KONKRET jetzt mein void* foo ersetzen soll)

[Badestrand]

SucherDerEleganz schrieb:

Völlig unerheblich wieviele es sind. Die bis zu 8 (!) fache Speichermenge zu verbraten ist nicht sinnvoll - egal ob ich nun 1000 Daten oder 10^9 habe.

Quatsch. Wenn du für Systeme entwickelst, die in der Regel 1-4 GB Arbeitsspeicher haben sind 20 zusätzliche Kilobytes ein Firlefanz und nicht mal erwähnenswert.

[camper]

Badestrand schrieb:

SucherDerEleganz schrieb:

Völlig unerheblich wieviele es sind. Die bis zu 8 (!) fache Speichermenge zu verbraten ist nicht sinnvoll - egal ob ich nun 1000 Daten oder 10^9 habe.

Quatsch. Wenn du für Systeme entwickelst, die in der Regel 1-4 GB Arbeitsspeicher haben sind 20 zusätzliche Kilobytes ein Firlefanz und nicht mal erwähnenswert.

Die Größe des Caches sollte man schon berücksichtigen. Allerdings ist das nicht besonders relevant:
Die Fragestellung ist immer noch ziemlich unklar - was konstituiert eine elegante Lösung?
Muss die Lösung bestimmten Anforderung bzgl. Geschwindigkeit, Speicherverbrauch, Codestruktur etc. genügen?
Nach 4 Seiten ist immer noch nicht klar, was am Ende herauskommen soll.

y = (static_cast<FLOAT*>(foo))[index] * scaleY;

Die elementare Frage nach den Datentypen ist immer noch unbeantwortet (das fällt unter schlampige Fragestellung). Damit ist darf sich nat. jeder Poster sein Eigenes heraussuchen. Die Verwendung eines gemeinsamen Datentyps ist dann ein logischer Vorschlag.

[SucherDerEleganz]

Bei Leuten die ernsthaft jetzt noch immer nicht meine simple Frage verstanden haben, muss ich wirklich an deren Intelligenz zweifeln. Soll ichs euch in Paint aufmalen?

Und jetzt nehmt mal die Stöcke aus dem Arsch und hackt nicht dauernd so pedantisch auf dem Wort "elegant" rum... meine Fresse. Ich wollte nur wissen ob das in C++ auf EINFACHE WEISE (elegant halt. Das der Code nett und schlicht aussieht. Sprich: Nicht 50 Zeilen Code etc.) geht, dass ich den void* durch was anderes ersetzen kann.

[Kritiker]

SucherDerEleganz schrieb:

Bei Leuten die ernsthaft jetzt noch immer nicht meine simple Frage verstanden haben, muss ich wirklich an deren Intelligenz zweifeln. Soll ichs euch in Paint aufmalen?

Und jetzt nehmt mal die Stöcke aus dem ***** und hackt nicht dauernd so pedantisch auf dem Wort "elegant" rum... meine Fresse. Ich wollte nur wissen ob das in C++ auf EINFACHE WEISE (elegant halt. Das der Code nett und schlicht aussieht. Sprich: Nicht 50 Zeilen Code etc.) geht, dass ich den void* durch was anderes ersetzen kann.

Ja, das geht eleganter!
Entferne einfach dein Brett vor dem Kopf, überleg dir ob du zur Übersetzungszeit oder erst zur Laufzeit entscheiden kannst welcher Datentyp eingelesen werden soll und lies dir den Thread hier nochmal durch, denn er enthält bereits für beide Fälle die entscheidenden Hinweise.

[Simon2]

SucherDerEleganz schrieb:

...
@Simon2: Was soll f.[index] bedeuten? ...

Dass ich mich auch vertippen kann.

SucherDerEleganz schrieb:

...
Vermutlich meinst du v[index], oder?

Genau!

SucherDerEleganz schrieb:

...Erstens habe ich ja doch wieder eine Fallunterscheidung drinnen ...

Aber nur genau EINMAL (nämlich beim Einlesen) und da wird eben gemappt zwischen einem "Typkennzeichen", wie Du es (ist zumindest meine Annahme)aus der Datei einliest. Das switch könntest Du noch mit einer map kaschieren, aber sonst wüsste ich keinen Weg, wie Du da drumherumkommen könntest.

SucherDerEleganz schrieb:

...Ich brauche ja einen Container/Array als Member, das mir die Daten aus der Datei hält ...

Diese Anforderung ist mir bei Dir bislang noch nicht aufgefallen.
Die wesentliche Frage hier ist: Befinden sich in Deiner Containerinstanz zu einem Zeitpunkt immer Objekte gleichen Typs ? (also mal ein [int, int, int, ....] und für eine andere Datei ein [float, float, ...])
Oder brauchst Du einen "Mischcontainer" ? (also [int, int, float, string, float, ...])

Von Zweiterem würde ich dringend abraten, bei Ersterem fährst Du mit so einer template-Lösung ziemlich gut.

SucherDerEleganz schrieb:

...Bei Templates muss der Typ ja zur Compilezeit feststehen, ...

Das ist aber ein Vorteil und kein Hindernis. So legst Du viele Ablaufpfade bereits zur Compilezeit fest, was
- doppelt Laufzeit spart (weniger Fallunterscheidungen + gute Optimierungsmöglichkeiten für Compiler und
- Fehlermöglichkeiten reduziert (z.B. irgendwo ein vergessener/falscher Typkennzeichner => fällt bereits zur Compilezeit auf bzw. passiert gar nicht, weil das template keinen Typen "vergessen kann").

SucherDerEleganz schrieb:

...Und um 2 (!) Zeilen Code, die mir nicht so gefallen...

Oh - Du sparst sehr viel mehr Zeilen! Aus (1+n) "manuellen" Typunterscheidungen (beim Einlesen + bei n Funktionalitäten, die differenzieren müssen) reduzierst Du auf eine. Wenn Du 8 Typen unterscheidest, sind das jeweils 8 Zeilen....
und sobald ein Typ dazukommt, musst Du an jeder einzelnen der (1+n) Stelle diesen nachpflegen.
So habe ich Dein Szenario mit dem (einleuchtenden) Problem verstanden:

SucherDerEleganz schrieb:

...
In den Memberfunktionen greife ich dann immer auf das Array zu und muss leider ständig Fallunterscheidungen machen ...(zum einen den void* und dann noch die ständigen ifs())...

SucherDerEleganz schrieb:

...Aber wenn es da keine wirklich simple Alternative gibt (wenig Code), dann lass ich einfach so wie es jetzt ist.

Also meine Lösung benötigt definitv weniger Code (viel weniger Code-Dopplung), bietet mehr Sicherheit und ist für Viele leichter zu lesen ("einfacher")....

Aber nun gut, ich muss das nicht anpreisen wie "sauer Bier". So einen "Wasch-mich-aber-mach-mich-nicht-nass"-Trick (oder hier eher "Verrat-mir-wie's-geht-aber-sag-mir-nichts-Neues"), wie Du ihn anscheinend gerne hättest, kann ich leider nicht liefern.
Dein Problem ist übrigens weder exotisch noch rein kosmetischer Natur ... was dazu führt, dass es inzwischen diesen hier verbreiteten Konsens einer "guten Lösung" gibt. Ob Du lieber zu denjenigen zählst, die von dieser Fremderfahrung profitieren oder sie lieber selbst machst, ist Deine freie Entscheidung.
(ich selbst habe auch viel mehr schlechte Erfahrungen machen müssen, als mir lieb war - und hätte mit ein paar mehr gelesenen Büchern mir viel Ärger ersparen können )

Gruß,

Simon2.

[Nexus]

SucherDerEleganz schrieb:

Bei Leuten die ernsthaft jetzt noch immer nicht meine simple Frage verstanden haben, muss ich wirklich an deren Intelligenz zweifeln.

Meine Güte, schau doch nur, wie viele Vorschläge hier schon gebracht wurden. Aber Ratschläge ohne konkrete Codebeispiele scheinst du ja grundsätzlich zu ignorieren...

SucherDerEleganz schrieb:

Soll ichs euch in Paint aufmalen?

Gerne, wenn es das Verständnis erleichtert. Wobei dein Problem inzwischen eigentlich gelöst sein sollte.

[Simon2]

SucherDerEleganz schrieb:

Bei Leuten die ernsthaft jetzt noch immer nicht meine simple Frage verstanden haben, muss ich wirklich an deren Intelligenz zweifeln....

Kannst Du natürlich machen - aber Du kannst auch kurz in Erwägung ziehen, dass vielleicht wirklich Deine Fragestellung doch nicht gaaaaanz so eindeutig und allgemeinverständlich ist, wie Du Dir das gedacht hast.
So wie beim "Geisterfahrerphänomen" nicht unbedingt wirklich alle Anderen falsch liegen müssen ....

Vermutlich bist Du noch nicht so lange hier im Forum, aber es treiben sich hier (auch in diesem Thread) sehr gute Leute rum (ich zähle mich nicht dazu).

... und spätestens wenn camper, der den C++-Standard rückwärts auswendig draufhat und bei dem ich noch NIE erlebt habe (und ich bin nun auch schon eine längere Zeit hier dabei), dass er eine Programmieraussage revidieren musste, die Fragestellung nicht versteht, würde ich das schon sehr ernst nehmen.
Aber auch das ist Deine freie Entscheidung.

Letztlich bleibt's dabei: Wenn diesen Augenblick das Forum für immer abraucht, hast Du weiterhin Dein Problem - und sonst keiner von uns hier.

So - und nu geh' ich ins Bett zu meinem lieben Frauchen.

Nacht,

Simon2.

[Kritiker]

Simon2 schrieb:

... und spätestens wenn camper, der den C++-Standard rückwärts auswendig draufhat und bei dem ich noch NIE erlebt habe (und ich bin nun auch schon eine längere Zeit hier dabei), dass er eine Programmieraussage revidieren musste, die Fragestellung nicht versteht, würde ich das schon sehr ernst nehmen.

Nicht zu viel loben, sonst strengt er sich nicht mehr an.
Also, ich habs schon erlebt.

Trotzdem, es stimmt schon. Der Thread ist beinahe eine Elefantenrunde.

[SucherDerEleganz]

Simon2 schrieb:

Diese Anforderung ist mir bei Dir bislang noch nicht aufgefallen.

Ihr wollt mich doch verarschen, oder? So eine Art Aprilscherz. Auf SEITE 1 des Threads ist in meinem Code Sample klar ersichtlich, dass void* data; ein MEMBER der Klasse ist und ich somit also die eingelesenen Daten in der Klasse halten will.

Simon2 schrieb:

Die wesentliche Frage hier ist: Befinden sich in Deiner Containerinstanz zu einem Zeitpunkt immer Objekte gleichen Typs ?

Auch das ist auf Seite 1 klar geklärt. Spätestens mit dem Posting von Badestrand sollte das eindeutig gewesen sein:

Oh, sorry, dann hatte ich das falsch verstanden. Ich dachte, es würden gemischt floats, ints usw drinstehen.

Aus dem Posting ist klar ersichtlich, dass ich KEINE Mischarrays oder sowas brauche. Und dann sagst du mir ein paar Seiten weiter, dass das nicht klar hervorging. Sorry, aber...

Weil das Problem ja immernoch so völlig diffus und undurchschaubar zu sein scheint ( ) hier nochmal (ca. zum 3. Mal) der Code wie es im Moment aussieht (vereinfacht):

class Foo {
private:
   void*		data;
   DATA_TYPE		dataType;
public:	
   Foo(DATA_TYPE dataType) { 
      // stream öffnen usw
      this->dataType = dataType;
      if(dataType == RAW_F32) {
         data = new FLOAT[count]; 
         stream.read( (char*)data, count * 4);
      }
      else if(dataType == RAW_U8) {
         data = new BYTE[count]; 	
         stream.read( (char*)data, count);
      }
   }

   // In genauer EINER einzigen Methode greife ich nun lesend auf das Array zu:

   void method() {
      // ...
   if(dataType == RAW_F32)
      v[index].SplineB.y = (static_cast<FLOAT*>(data))[index] * this->scaleY;
   else if(dataType == RAW_U8)
      v[index].SplineB.y = (static_cast<BYTE*>(data))[index] * this->scaleY;	

   }

Das ist alles. Wie ich es auf mehreren Seiten immer wieder gepostet habe. Und jetzt nochmal meine simple Frage (zum 2. oder 3. Mal): Bei euren Lösungen, durch welchen Datentyp ersetze ich nun void* data (da ich ja die Daten als Membervariable in der Klasse halten will)?

[drakon]

Simon2 schrieb:

So - und nu geh' ich ins Bett zu meinem lieben Frauchen.

Ich habe mich dich immer jünger vorgestellt. (Was wohl am namen liegt, da ich nur jugendliche Simons kenne. :))

@SucherDerEleganz :
Ist DATA_TYPE zur Laufzeit bekannt?
Wenn ja: Siehe mein Beispiel auf Seite 1
wenn nein: Siehe mein Kommentar auf Seite 2. (virtuelle Funktionen)

class IDataType
{
public:
    virtual void read () = 0;
    virtual IDataType (){}
};

class RAW_F32 : public IDataType
{
public:
    void read () {}
};

class RAW_U8 : public IDataType
{
public:
    void read () {}
};
...

class Foo {
private:
   std::list<IDataType*>   data;
public:   
   Foo(std::string type) {
      if ( type == "RAW_F32")
          data.push_back (new RAW_F32);
      else if ( type == "RAW_U8")
          data.push_back (new RAW_U8);
      ...
   }

   void method() { 
   //gemütlich auf den Container zugreifen und die Schnittstelle benutzen und du hast keine Probleme.
   }

Allerdings vermute ich, dass die Typen bereits zur Compilezeit bekannt sein können, wenn du da ja sowas hast: DATA_TYPE dataType. Aber wie auch immer. Das, was ich jetzt gesagt habe haben schon andere vor mir (+ ich selbst) schon gesagt..

[Simon2]

drakon schrieb:

...
Ich habe mich dich immer jünger vorgestellt. (Was wohl am namen liegt, da ich nur jugendliche Simons kenne. :))...

Um das mal klarzustellen: Ende des Jahres werde ich 40, bin seit 13,5 Jahren verheiratet und habe zwei 10jährige Töchter (also insgesamt 3 großartige Mädels im Haus, die mir immer wieder Gelassenheit schenken für so Heißsporne wie den Threadersteller hier ).

Ich kenne sonst auch nur recht jugendliche "Simons" und war meine ganze Kindheit hindurch eigentlich ganz stolz auf meinen Exotennamen (es gab sogar Leute, die fragten, ob ich jüdisch sei). Dafür habe ich leider auch nicht das "Überhören" gelernt, wenn Namensvettern gerufen werden, wie es wohl Franks, Thomasse und Claudias entwickelt haben. Wenn jetzt ein Mutter ihren "Siiiiiiimon" ruft, komme ich auch oft angelaufen (tja, ich weiß schon, warum Elten ihren Kindern peinlich sind ).

Gruß,

Simon2.

[Simon2]

SucherDerEleganz schrieb:

Simon2 schrieb:

Diese Anforderung ist mir bei Dir bislang noch nicht aufgefallen.

...Auf SEITE 1 des Threads ist in meinem Code Sample klar ersichtlich, dass void* data; ein MEMBER der Klasse ist...

Aha! Ich kann Dir ach genau sagen, wo mein Mißverständnis lag:
Lies mal laut:

SucherDerEleganz schrieb:

...Ich brauche ja einen Container/Array als Member, das mir die Daten aus der Datei hält ...

(so habe ich es verstanden)
und

SucherDerEleganz schrieb:

...Ich brauche ja einen Container/Array als Member, das mir die Daten aus der Datei hält ...

(so hast Du es anscheinend gemeint)
Das sollte ein wenig belegen, warum man schriftlich etwas ausführlicher formulieren muss als in der "Sprechsprache".

@Topic:
1.) Ich sehe nicht, wo meine Lösung einem Einsatz innerhalb einer Klasse widersprechen sollte. Dann packst Du die Funktionen eben in eine Klasse, aber das bekommst Du schon hin. Du kannst Dich auch noch entscheiden, ob Du für jeden Typ einen eigene Klasse anlegen (sprich: Klassentemplate) oder innerhalb der einen Klasse die "fachlichkeit()" typspezifisch machen möchtest (wie ich es oben getan habe)
2.) Ich sehe auch nicht, warum diese Anforderung besteht; die Implementierung in nerhalb einer Klasse ist ein eher technisches Implementierungsdetail, das mit den fachlichen Anfordeungen eher weniger zu tun hat.

Aber nun gut:
Entwurf mit Klassentemplate (1.)

template <typename T>
struct foo {
   vector<T> v;
   void fachlichkeit() {
      y = v[index] * scaleY; // keine Fallunterscheidung mehr nötig
   }
   foo(size_t) : v(size) {}
};

int main() {
...
   switch(dataType) {
   case TYPE_BYTE: foo<char>(X).fachlichkeit(); break
   case TYPE_FLOAT: foo<float>(X).fachlichkeit(); break
...

(Kann natürlich auch erstmal nur das foo-Objekt erzeugen (mit new und interface wie von Nexus beschrieben) und dann woanders fachlichkeit() aufrufen)

... und einer für 2.)

struct foo {
   size_t s;
   template <typename T>
   void fachlichkeit() {
      vector<T> v(s);
      y = v[index] * scaleY; // keine Fallunterscheidung mehr nötig
   }
   foo(size_t) : s(size) {}
};

int main() {
...
   foo f(X);
   switch(dataType) {
   case TYPE_BYTE: f.fachlichkeit<BYTE>(); break
   case TYPE_FLOAT: f.fachlichkeit<FLOAT>(); break
...

Ein Pferdefuß von Nexus' reiner "virtual-Lösung" ist, dass nicht generisch auf die Daten in der Liste zugegriffen werden kann. Ich weiß zwar, dass alle ein "idata"-Objekt beinhalten, aber wenn ich konkret mit einem arbeiten möchte, weiß ich nicht, welchen Typ sie haben ... und eine "generische Zugriffsfunktion" kann es auch nicht geben aufgrund der "Vererbungssemantik" (=gleiche Funktionssignatur) in C++.
Aber man könnte sie mit meinen Ansätzen kombinieren.

Nochmal ein Tipp zu Deiner Kommunikation: Wenn Du
1.) Nicht sofort verbal um Dich schlägst, wenn Dir etwas nicht passt
2.) eigene Begrenztheit (wie sie jeder Mansch hat) und die Existenz von Mißverständnissen ("Warum Boshaftigkeit voraussetzen, wo Irrtum oder DUmmheit es genauso erklären?", sagt ein Kollege immer so schön) mit in Deine Überlegungen einbeziehst und
3.) Dich nicht nur auf die Dinge, die Dir nicht passen stürzt, sondern auch mal sagst, wo Du was verstehst, was Dir gefällt, ....
dann kommst Du im Leben, im Internet und erst Recht hier im Forum deutlich schneller und stressfreier zum Ziel (ich habe nämlich deutlich mehr geschrieben als die paar Schnipsel, auf die Du eingehst).

So - nun bringe ich meine Tochter zum Volleyballspiel.

Schönen Tag noch,

Simon.

[drakon]

Ein Pferdefuß von Nexus' reiner "virtual-Lösung" ist, dass nicht generisch auf die Daten in der Liste zugegriffen werden kann. Ich weiß zwar, dass alle ein "idata"-Objekt beinhalten, aber wenn ich konkret mit einem arbeiten möchte, weiß ich nicht, welchen Typ sie haben ... und eine "generische Zugriffsfunktion" kann es auch nicht geben aufgrund der "Vererbungssemantik" (=gleiche Funktionssignatur) in C++.

Ich denke mal, dass du mich gemeint hast und nicht Nexus.

Das mit dem Zugriff ist mir schon klar, aber im Normalfall tendieren die Leute dazu zu meinen, dass sie wissen müssen, mit was sie es zu tun haben, als sich einfach auf die Schnitstelle zu verlassen.
Schlussendlich macht man das ganze mit abstrakter Klasse usw. ja darum, weil die Objekte eine einheitliche Aufgabe haben, aber jeweils ev. etwas anderes machen müssen. Wenn aber keine einheitliche Schnittstelle gefunden werden kann, dann hat auch keine Vererbung stattzufinden.
(Nichtsdesto trotz ist deine Lösung natürlich eine gute Möglichkeit das zu erzwingen. Nur muss man sich dann fragen, ob das so nötig ist. Und mir fällt kein gutes Beispiel ein, wo es das wirklich ist. )

[Simon2]

drakon schrieb:

...Ich denke mal, dass du mich gemeint hast und nicht Nexus. ;)...

KREISCH!!
Natürlich - sorry.

drakon schrieb:

...Das mit dem Zugriff ist mir schon klar, aber ...

Hast natürlich Recht, aber ich wollte den Threadstarter da vorsichtshalber mal darauf hinweisen. Mir schien es halt so, als ob er die Klasse im Wesentlichen als "Verpackung für seine Daten" haben, deren eigentliche Verarbeitung aber außerhalb haben wollte. Und dahin kommt er eben mit Deinem Ansatz nicht (ungefrickelt)...
Letztlich wollte ich nur darauf hinweisen, dass da noch Arbeit vor ihm liegt, wenn er diesen Weg beschreitet.

Gruß,

Simon2.