Explizit spezialisierte Templates



  • Hallo Zusammen,
    bin gerade am verzweifeln. Folgendes Problem

    Header-Datei

    #define MAX_STRUCT 10
    
    struct TestStruct1{
    	int  iValue1;
    	int  iValue2;
    	bool bValue3;
    	int  iCheckValue1;
    	int  iValue4;
    };
    
    struct TestStruct2{
    	int   iValue1;
    	float dValue2;
    	bool  bValue3;
    	int   iCheckValue1;
    	int   iValue4;
    };
    
    struct TestStruct3{
    	int  iValue;
    	int  iValue2;
    	bool bValue3;
    	int  iCheckValue1;
    	int  iValue4;
    	int  iValue5;
    	int  iValue6;
    };
    
    class TTestTemplateClass
    {
    private:	// Anwender-Deklarationen
    	TestStruct1 Test1[MAX_STRUCT];
    	TestStruct2 Test2[MAX_STRUCT];
    	TestStruct3 Test3[MAX_STRUCT];
    	template <class T> void __fastcall vCheckValue(T* Struct);
    	template <class T> void __fastcall vInitializeValue(T* Struct);
    	template<class T>  void __fastcall vInitStruct(T* Struct);
    
    public:		// Anwender-Deklarationen
    __fastcall TTestTemplateClass();
    };
    
    template <> void __fastcall TTestTemplateClass::vInitializeValue <  TestStruct3 *  >  ( TestStruct3* Struct );
    

    CPP-Datei

    __fastcall TTestTemplateClass::TTestTemplateClass()
    {
      vInitStruct(Test1);
      vInitStruct(Test2);
      vInitStruct(Test3);
      vCheckValue(Test1);
      vCheckValue(Test2);
      vCheckValue(Test3);
    }
    
    template<class T> void __fastcall TTestTemplateClass::vCheckValue(T* Struct)
    {
    	if( Struct[0].iCheckValue1 == 0 )
    	{
    		vInitializeValue( &Struct[0]);
    	}
    }
    
    template<class T> void __fastcall TTestTemplateClass::vInitializeValue(T* Struct)
    {
    	Struct->iValue1 = 1;
    
    }
    
    template <> void __fastcall TTestTemplateClass::vInitializeValue < TestStruct3* > (TestStruct3* Struct)
    {
    	Struct->iValue = 1;
    
    }
    
    template<class T> void __fastcall TTestTemplateClass::vInitStruct(T* Struct)
    {
    	memset(Struct, 0, sizeof(T) *10 );
    }
    

    Laut den gefundenen Beispielen sollte es so funktionieren. Leider meckert der Compiler immer, dass die meine spezialisierte Template-Funktion kein Member der Klasse ist (E2316)! Es ist mir leider nur einmal gelungen das Projekt zu erstellen und alles hat funktioniert. d.h. alle Funktionen sind richtig aufgelöst worden und aufgerufen worden. Ich wollte jetzt die Funktionalität in das richtige Projekt übertragen, aber leider Fehlanzeige. Der Versuch das Testprojekt noch mal zu bauen hat leider nicht mehr geklappt. Wenn ich die Funktion innerhalb der Klasse deklariere quittiert es der Compiler mit (E2099) Explizite Spezifizierung nur auf Datei- oder Namenspace-Ebene zulässig! Ich arbeite mit dem C++ Builder XE.
    Was mache ich falsch und wie kann ich den Compiler davon überzeugen die explizit spezialisierte Template Funktion zu akzeptieren?

    Bin für jede Hilfe dankbar



    1. Du musst die Template-Member-Funktionen im Header implementieren.
    2. C++ bis vor C++11 erlaubt keine spezialisierte Member-Funktionen. Du kannst das aber im Builder in den Projekteinstellungen erlauben (C++ Kompatibilität: Explizite Template-Spezialisierung als Member-Funktion)


  • Hallo DocShoe,
    erst Mal vielen Dank für die Antwort. Die Projekteinstellung hatte mich mit diesem Problem nicht weiter gebracht, die hat nur dafür gesorgt, dass der Fehler E2099 nicht mehr erschienen ist. Wie so oft hatte auch in meinem Fall der Compiler Recht behalten. Ich habe versehentlich (unwissentlich) einen Zeiger auf die Struktur deklariert! Mit

    template <> void __fastcall TTestTemplateClass::vInitializeValue <  TestStruct3 >  ( TestStruct3* Struct );
    

    ist jetzt auch der Compiler zufrieden.

    Vielen Dank noch mal für die Hilfe


Log in to reply