template< typename T>
void
foo( const T& t);

 template<>
void
foo( const char*const&)
{
}

int main()
{   
  foo( "bla");
}

Fehlermeldung bei VC:

Nicht aufgelöstes externes Symbol '"void __cdecl foo<char const [4]>(char const (&)[4])" (??$foo@$$BY03$$CBD@@YAXAAY03$$CBD@Z)', verwiesen in Funktion '_main'

Den BCB 'überred ich dazu, wenn ich

template<>
void
foo( char*const&)
{
}

mache. Warum auch immer. Bei VC++ ändert das aber auch nix.
Was mach ich, wenn meine Template-Funktoin const T& kriegt, ich das ganze aber für T=const char* spezialisieren muss???

template<>
void foo(const char *& const str) {
  //..irgendwas machen
}

template<>
void foo(const char * const str) {
  //..irgendwas machen
}

template<>
void foo(const char *str) {
  //..irgendwas machen
}

Versuchs jetzt mit ner normalen Überladung

void foo(const char *) { 
  //..irgendwas machen 
}

//oder
template<> 
void foo(const char * const&) { 
  //..irgendwas machen 
}

Geht beides. Im Beispiel ... Mal schauen, was ich mir damit für neue Probs einhandle.

Prinzipiell tät mich aber schon interessieren, warum das nicht geht. Standard-Conform wärs ja wohl, oder?

Voila:

7,8 h für die Portierung eines nicht so kleinen Konsolen-Projekts von Borland C++-Builder 5.5 nach VC 7.1. Zumindest compiliert und linkt es jetzt. 0 Fehler, 0 Warnungen. Hoffe keine Laufzeitfehler eingebaut zu haben. *puh* (ich mach das bestimmt nicht freiwillig)

namespace help
{
    template<class T,class U>
    struct specialise_h
    {
        typedef void ret;
        static ret foo(T t,U u)
        {
            //...
        };
    };

    template<class T,class U>
    struct specialise_h<const T&, U>
    {
        typedef bool ret;
        ret foo(const T& t,U u)
        {
            //...
            return x;
        };
    };
};

template<class T,class U>
typename help::specialie_h<T,U>::ret foo(T t,U u)
{
    return help::specialise_h::foo(t,u);
};

Prinzipiell tät mich aber schon interessieren, warum das nicht geht. Standard-Conform wärs ja wohl, oder?

Das geht nicht, da bei Referenzparametern in Templates kein "decaying" stattfindet.
Was soviel bedeutet wie, dass ein Array in diesem Fall nicht in "Zeiger auf das erste Element" zerfällt. Dies wäre aber nötig, da ein Stringliteral den Typ const char[] hat und nicht const char*.

Für ein Stringliteral wird hier also das Base-Template und nicht die Spezialisierung ausgewählt. Weist du hingegen das Stringliteral zuvor einer Variablen vom Typ const char* zu, dann wird auch die Spezialisierung aufgerufen.

Heißt das, er müsste noch für const char[] spezialisieren?

Der Typ von T ist hier const char[N], wobei N die Länge des Stringliterals ist. Für diesen Typen kannst du die Funktion so aber nicht spezialisieren, da du N nicht zur Verfügung hast.

Also: solange das Base-Template einen Referenzparameter enthält ist eine Spezialisierung für Stringliterale nicht möglich, da es für Funktionen keine partielle Spezialisierung gibt.

Man könnte die Funktion allerdings entsprechend überladen:

template <int N>
void foo(const char (&a)[N]);

Wobei eine Überladung für const char* hier sicher angebrachter wäre.

MfG Spacelord