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

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

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...

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

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;
}

Signatur-Missbrauch

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 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