Fehlermeldung, wenn Template-Code verwendet wird

Hallo,

wie kann ich eine Fehlermeldung ausgeben, wenn bestimmter Code eingebunden wird?

Der folgende Code wird ja wegen der Template-Spezialisierung nicht verwendet, aber trotzdem meldet der Compiler einen Fehler.

Er soll aber nur einen Fehler melden, wenn dieser Code auch eingefügt wird.

#include <iostream>

template<typename T>
class Foo{
public:
        void foo(){
                //std::cout << "T" << std::endl;
                #error not defined for T
        }
};

template<>
class Foo<int>{
public:
        void foo(){
                std::cout << "int" << std::endl;
        }
};

int main(){
        Foo<int> foo;
        foo.foo();
}

Wie kann ich mein gewünschtes Verhalten verwirklichen?
Kann ich auch irgendetwas verwirklichen, dass er den entsprechenden Klassenamen ausgibt, statt T?

Gruß,
MaPoX

Skym0sh0

mh du könntest template spezialisierungen machen die einen compiler fehler verursachen. weil templates werden ja nur übersetzt wenn sie gebraucht werden, dementsprechend werden ein paar templates kompiliert und genutzt während deine eine spezialisierung einen fehler verursacht wenn sie genutzt wird

beispiel:

template<typename T>
T foo(T const& x)
{
     return x;
}

template<>
char foo(char const& x)
{
     .;sfreturn;;
}

int main()
{
    cout << foo<int>(5) << endl; // ok
    cout << foo<double>(1.0) << endl; // ok
    cout << foo<char>('s') << endl; // fehler!
    return 0x0;
}

wobei sicher bin ich mir nicht, da ich nicht die nötige übung und erfahrung habe mit templates

MaPoX

Skym0sh0 schrieb:

mh du könntest template spezialisierungen machen die einen compiler fehler verursachen. weil templates werden ja nur übersetzt wenn sie gebraucht werden, dementsprechend werden ein paar templates kompiliert und genutzt während deine eine spezialisierung einen fehler verursacht wenn sie genutzt wird

Ungültigen Code kann ich natürlich dort reinschreiben, aber ich würde eine Fehlermeldung bevorzugen

btw: Warum die Fehlermeldung immer erscheint ist mir klar...

HighLigerBiMBam

Ich würde einen Linker-Fehler erzeugen und keinen Compile-Fehler.

template<>
char foo(char const& x);

volkard

HighLigerBiMBam schrieb:

Ich würde einen Linker-Fehler erzeugen und keinen Compile-Fehler.
template<>
char foo(char const& x);

Find ich nett.
Erweiterung zu Linkerfehlermeldung mit Freitext:

template<typename T>
T foo(T const& x)
{
     return x;
}

void volkard_ist_doof();

template<>
inline char foo(char const& x){
    volkard_ist_doof();
    return 0;
}

HighLigerBiMBam

Gleicher Fehler nur mit anderer Signatur.

MaPoX

Jo...
Linker-Fehler klingt gut

Signatur-Missbrauch

Nexus

MaPoX schrieb:

Jo...
Linker-Fehler klingt gut

Nein, Linkerfehler ist schlecht. Lieber den Fehler bereits zur Kompilierzeit erkennen. Sonst kriegst du z.B. Probleme, wenn du eine statische Bibliothek erzeugst, deren Symbole erst beim Anwender aufgelöst werden.

static_assert ist, was du suchst. Im momentanen C++-Standard kannst du auf Boost oder Loki zurückgreifen.

MaPoX

Nexus schrieb:

MaPoX schrieb:

Jo...
Linker-Fehler klingt gut

Nein, Linkerfehler ist schlecht. Lieber den Fehler bereits zur Kompilierzeit erkennen. Sonst kriegst du z.B. Probleme, wenn du eine statische Bibliothek erzeugst, deren Symbole erst beim Anwender aufgelöst werden.

static_assert ist, was du suchst. Im momentanen C++-Standard kannst du auf Boost oder Loki zurückgreifen.

Guter Einwand