Klassen mit Templates - sinnvoll und realisierbar?



  • Hi,

    habe Probleme mit Templateklassen-Vererbung. Ich frage mich, ob mein Aufbau überhaupt sinnvoll gewählt ist.

    01: template<class T_HDR, class T_CONTENT>
    02: class BaseFile
    03: {
    04: 	protected:
    05: 		class BaseHeader {
    06: 			// some basics
    07: 		};
    08: 		class BaseContent {
    09: 			// some basics
    10: 		};
    11: 		// ...
    12: 		BaseHeader* hdr;	
    13: 		BaseContent* cnt;
    14: 		//...
    15: 	public:
    16: 		BaseFile(const char* fname); // see below
    17: };
    18: 
    19: template<class T_HDR, class T_CONTENT>
    20: BaseFile<T_HDR, T_CONTENT>::BaseFile(const char* fname)
    21: {
    22: 	hdr = new T_HDR;
    23: 	cnt = new T_CONTENT;
    24: 	// ... some init stuff
    25: }
    26: 
    27: class XFile : public BaseFile<XHeader, XContent>
    28: {
    29: 	class XHeader : public BaseHeader {
    30: 		// some special methods for headers of XFile
    31: 	};
    32: 	class XContent : public BaseContent {
    33: 		// some special methods for contents of XFile
    34: 	};
    35: 	
    36: 	XFile(const char* fname) : BaseFile<XHeader, XContent>(fname) {}
    37: };
    

    Im Grunde genommen bräuchte man hier gar keine templates. Ich könnte auch einfach im Konstruktor von XFile den Speicher für den richtigen Typ mit new allokieren. Ich wollte es aber eigentlich lieber dem BaseFile überlassen, um Codewiederholung auszuschließen. Das geht aber offenbar nur mit Templates.

    Folgende Probleme:
    1.) Der Compiler kennt in Zeile 27 XHeader und XContent natürlich nicht. Wie kann man das lösen?
    2.) Wäre es sinnvoller, wenn man schon Templates nutzt, Zeile 12 und 13 zu ersetzen durch

    T_HDR hdr;
    T_CONTENT cnt;
    

    Dies würde die Zeit zum allokieren sparen. Dadürch würde aber das ganze virtuelle Vererbungs-Modell überflüssig.

    3.) Oder sollte man hier nicht doch ganz auf Templates verzichten? Man müsste zwar dann den Speicher bei jeder erbenden Klasse selbst allokieren, aber der Aufbau wäre vielleicht verständlicher.

    Vielen Dank für Eure Hilfe,
    voidpointer



    1. Wenn XFile selber ein Template sein soll (mit XHeader und XContent als templateparameter) dann musst du es natürlich dranschreiben. SOnst solltest du vor der definition von XFile die Definitionen von XHeader und XContent liefern, damit der Compiler weiß woran er ist.

    2. Das ist eine Designentscheidung, sprich: es kommt drauf an was du erreichen willst. Was auf jeden Fall nicht klappen wird ist, einen BaseHeader pointer mit einem new T_HDR zu initialisieren - die pointer sind nicht kompatibel, wenn die Klassen nicht voneinander abgeleitet sind.

    3. Kommt auch wieder drauf an was du erreichen willst, also welches Ziel du mit alledem verfolgst.



  • pumuckl schrieb:

    1. Wenn XFile selber ein Template sein soll (mit XHeader und XContent als templateparameter) dann musst du es natürlich dranschreiben. SOnst solltest du vor der definition von XFile die Definitionen von XHeader und XContent liefern, damit der Compiler weiß woran er ist.

    XFile sollte eigentlich kein Template, sondern eine Template-Klasse sein. Wie könnten solche Definitionen aussehen?

    pumuckl schrieb:

    1. Das ist eine Designentscheidung, sprich: es kommt drauf an was du erreichen willst. Was auf jeden Fall nicht klappen wird ist, einen BaseHeader pointer mit einem new T_HDR zu initialisieren - die pointer sind nicht kompatibel, wenn die Klassen nicht voneinander abgeleitet sind.

    Ok, aber wenn ich hier für T_HDR, wie geplant, XHeader einsetze, dann müsste es doch klappen, oder nicht?

    pumuckl schrieb:

    1. Kommt auch wieder drauf an was du erreichen willst, also welches Ziel du mit alledem verfolgst.

    Hauptziel ist vor allem, dass jemand, der von BaseFile ableitet, (der also z.B. YFile oder ZFile schreibt), auf möglichst unkomplizierte Weise viel Code-Wiederholung spart. Das ganze soll eine Library sein, wobei ich die File-Klasse gerne rein virtuell gestalten würde.


Anmelden zum Antworten