//in *.h
template <typename T>
class Matrix
{
private:
 //...
public:
 //...
template <typename T2>
T2 operator * (T2 & other);
};

Wenn ich die Definition in die *.h - File packe, dann kompiliert das ganze auch wunderbar, allerdings ist es ein Problem, wenn ich die Definition in die cpp-File stecke, da ich ja in diesem Fall die Datentypen angeben muss (was ich eigentlich auch will) für welche die Methode definiert ist, da diese beim kompilieren erstellt werden können. Was ich in der *.cpp File habe (ich habe keine Ahnung, ob das gültige oder passende Syntax ist, der erste Teil wird zumindest kompiliert):

template <typename T>
template <typename T2>
T2 Matrix<T>::operator * (T2 & other)
{
  //tu irgendwas
}

Soweit geht das auch noch, was allerdings jetzt das Problem aus macht sind die expliziten Deklarationen der Methoden, die ich nun benötige. Ich wollte zum Beispiel die Methode nun für int als T2 deklarieren und habe das natürlich in der *.cpp File (in der auch die template-Methode definiert ist), versucht, hat allerdings nicht geklappt:

template <typename T> int Matrix<T>::operator *<int> (int & other);

So und noch einige andere Versuche, wie:

template <typename T> template int Matrix<T>::operator *<int> (int & other);
template <typename T> template<int> int Matrix<T>::operator * (int & other);

Weiß irgendwer ob das überhaupt so geht, oder bin ich gezwungen, das alles im Header zu halten (was mir persönlich nicht gefallen würde, da ich eben die Spezialisierungen ausschließlich für ein paar Datentypen hätte)

Zweitens: Ich würde es ja spontan so machen:

template <typename T> template<> int Matrix<T>::operator * (int & other);

(bin mir aber nicht 100% sicher, ob das stimmt)

template <typename T> int Matrix<T>::operator *<int> (int & other);

So und noch einige andere Versuche, wie:

template <typename T> template int Matrix<T>::operator *<int> (int & other);
template <typename T> template<int> int Matrix<T>::operator * (int & other);

Weiß irgendwer ob das überhaupt so geht, oder bin ich gezwungen, das alles im Header zu halten (was mir persönlich nicht gefallen würde, da ich eben die Spezialisierungen ausschließlich für ein paar Datentypen hätte)

du kannst eine datei mit template-definitionen erstellen und diese am ende des headers inkludieren, dann hast du's auch getrennt.

was du suchst, nennt sich übrigens funktionsüberladung

//in der klasse:
template <class T> void foo (T const& other);
void foo (int other);

//definition:
template <class T>
void X<T>::foo (int other)
{
//...
}

template <typename T> template<> int Matrix<T>::operator * (int & other);

Muss man Spezialisierungen von template member functions in templates nicht sowieso immer in der template Klasse (also implizit inline) definieren?
Anders gesagt: AFAIK geht das garnicht, egal mit welcher Syntax

Vorden schrieb:

template <typename T> int Matrix<T>::operator *<int> (int & other);

So und noch einige andere Versuche, wie:

template <typename T> template int Matrix<T>::operator *<int> (int & other);
template <typename T> template<int> int Matrix<T>::operator * (int & other);

Weiß irgendwer ob das überhaupt so geht, oder bin ich gezwungen, das alles im Header zu halten (was mir persönlich nicht gefallen würde, da ich eben die Spezialisierungen ausschließlich für ein paar Datentypen hätte)

du kannst eine datei mit template-definitionen erstellen und diese am ende des headers inkludieren, dann hast du's auch getrennt.

was du suchst, nennt sich übrigens funktionsüberladung

//in der klasse:
template <class T> void foo (T const& other);
void foo (int other);

//definition:
template <class T>
void X<T>::foo (int other)
{
//...
}

erm, dass ich so was wie funktionsüberladung suche, wusste ich schon, aber, wie hustbaer sagte, geht es offensichtlich nicht... ich habe das gefühl, du (queer_boy) hast nicht verstanden, um was es mir ging, scheinbar gehts leider nicht so, wie ich mir das vorgestellt hatte, ich mein, für klassen z.b. kann man ja wunderbar in der *.cpp forward-deklarationen vornehmen in der form:

template class Matrix<int>;

das ist eigentlich das, was ich für funktionen gesucht habe, aber scheinbar geht es nicht so unbedingt, dann kommt des halt in den header, da gehts auch, wenn auch nicht exakt so, wie ich das wollte. schade eigentlich, aber thx. falls noch irgendwem was dazu einfällt, bitte einfach posten, ansonsten auch danke

erm, dass ich so was wie funktionsüberladung suche, wusste ich schon, aber, wie hustbaer sagte, geht es offensichtlich nicht...

Nönönö, Überladung != Spezialisierung.

Überladen kannst du schon:

#include <iostream>

template <class T> class foo
{
public:
    // NOTE: hier drinnen heisst foo ohne template klammern automatisch immer foo<T>.
    template <class U> foo operator *(U u); // das template

    template <> foo operator *<double>(double d) // spezialisierung inline (hier geht das, ausserhalb der deklaration von foo nicht)
    {
        std::cout << "spezialisierung inline\n";
        return foo();
    }

    foo operator *(int i); // der non-template-overload
};

// definition des templates
template <class T> template <class U> foo<T> foo<T>::operator *(U u)
{
    // ...
    std::cout << "template ausserhalb\n";
    return foo<T>();
}

// definition des overloads
template <class T> foo<T> foo<T>::operator *(int i)
{
    // ...
    std::cout << "overload ausserhalb\n";
    return foo<T>();
}

int main()
{
    foo<char> f;
    f = f * "sepp"; // template ausserhalb
    f = f * 10.0; // spezialisierung inline
    f = f * 10; // overload ausserhalb

    return 0; 
}

template class Matrix<int>;

Eieieiei.
DAS ist keine Spezialisierung sondern eine explizite Instanzierung.
Und DAS geht auch:

// Mit "foo" aus dem letzten Beispiel:

template foo<int> foo<int>::operator *<short>(short s); // explizite Instanzierung des templates

#include <iostream>

template <class T> class foo
{
public:
    // NOTE: hier drinnen heisst foo ohne template klammern automatisch immer foo<T>.
    template <class U> foo operator *(U u); // das template

    template <> foo operator *<double>(double d) // spezialisierung inline (hier geht das, ausserhalb der deklaration von foo nicht)
    {
        std::cout << "spezialisierung inline\n";
        return foo();
    }
  [...]
};

vielleicht sehe ich tatsächlich nicht genau, worauf der OP hinauswollte. aber wieso sollte das funktionieren? sollte das nicht eigentlich verboten sein? eine explizite spezialisierung (genauer: die deklaration einer expliziten spezialisierung, damit auch die definition) eines member templates kann doch nur im namensbereich der übergeordneten (template oder nicht)-klasse auftreten.

ich habe das gefühl, das hier etwas in der art gesucht wird, wie CStoll schon gemeint hat

CStoll schrieb:

template <typename T> template<> int Matrix<T>::operator * (int & other);

auf dein beispiel umgelegt, so etwas: (ich lasse mal zur übersichtlichkeit den code für die überladene funktion weg)

#include <iostream>

template <class T> class foo
{
public:
    // NOTE: hier drinnen heisst foo ohne template klammern automatisch immer foo<T>.
    template <class U> foo operator *(U u); // das template

   //folgendes funktioniert nicht dank 14.7.3/2
   /* template <> foo operator *<double>(double d) // spezialisierung inline (hier geht das, ausserhalb der deklaration von foo nicht)
    {
        std::cout << "spezialisierung inline\n";
        return foo();
    } */
};

//also muss man die explizitie spezialisierung außerhalb der klasse vornehmen (CStolls Idee)
template <class T>
template <>
foo<T> foo<T>::operator * <double> (double d)
{
}

nur leider funktioniert das auch nicht, da bei einer expliziten spezialisierung eines member-templates die sie einschließende klasse auch explizit spezialisiert werden muss. also nur so:

template <>
template <>
foo<int> foo<int>::operator * (int);

aber ich muss zugeben, dass das nicht ganz mein spezialgebiet ist.

nach ein bisschen nachforschung scheinen hier verschiedene compiler-hersteller selbst keine einheitliche meinung zu haben. 14.3.7/18 spricht nur von klassentemplates, nicht aber von funktionstemplates. 14.3.7/1 würde die explizite spezialisierung auch erlauben. irgendwo ist da der hund drin...

//zum einen:
template <typename T>
class Matrix
{
private:
//...
template <typename T2>
T2 operator * (T2 &other)
{
 //... do the mul
}
//...
public:
int operator * (int &);
double operator * (double &);
//...
};

und dann in der *.cpp die Methoden definiert also für int und double, die jeweils bloß die andere mit

return operator *<int>(val);

aufrufen im Endeffekt.
Is aber jetz auch noch ungetesteter code, weiß net genau, ob des funktioniert, hab leider auch grad meinen compiler hier net zur hand, macht aber, denke ich, sinn der code so

(PS: quelle) das liegt wahrscheinlich auch an der absolut und überaus einfach verständlichen regel des 14.3.7/18. wie auch immer, was man dagegen tun kann, ist eine funktionsüberladung, wie ich schon gesagt habe.

nach ein bisschen nachforschung scheinen hier verschiedene compiler-hersteller selbst keine einheitliche meinung zu haben. 14.3.7/18 spricht nur von klassentemplates, nicht aber von funktionstemplates. 14.3.7/1 würde die explizite spezialisierung auch erlauben. irgendwo ist da der hund drin...

Bei mir gibt es keinen Abschnitt 14.3.7