seit geschlagenen zwei Stunden suche ich nach der passenden Syntax, kann sie aber nicht finden und mir gehen die Googlebegriffe aus. Inzwischen bin ich bei der "probiere einfach einmal alles aus"-Methode angekommen.

Könnt ihr vielleicht einmal hierauf einen Blick werfen und mir sagen wie man dieses am besten löst:

Grundsätzlich habe ich die Klasse A

template
<
    int i,
    class c
>
class A
{
    //Wie wird hier die Funktion deklariert?
}

Und für diese Klasse möchte ich nun eine Funktion foo schreiben die zwei Parameter von Typ A entgegen nimmt. Könnt ihr mir sagen wie dieses möglich ist bzw. ob es möglich ist?

template
<
    int i,
    class c
>
void A<i,c>::foo(/* und hier weiß ich nicht wie es weiter geht*/)

Viele Grüße
MM

template
<
    int i,
    class c
>
class A
{
    //Wie wird hier die Funktion deklariert?
}

Ganz einfach:

template <int i, class c>
class A
{
  void foo(); 
  //oder mit Argumentliste: 
  void bar(int myI, std::string mystring);
}; //Semikolon nicht vergessen!

template <int i, class c>
void A<i,c>::foo() 
{
  /* ... */
}

template <int i, class c>
void A<i,c>::bar(int myI, std::string mystring) 
{
  /* ... */
}

oh, ich glaube da hab ich mich nicht ganz so gut ausgedrückt. Die Funktion foo soll zwei Argumente von Typ A entgegen nimmt. Also der Klasse selber.

Hast du dafür auch eine Idee?

Viele Grüße
MM

template<typename T>
class foo {
public:
  int  operator-(foo const& rhs);
  //             ^^^
  //            foo<T>

  bool dings(foo<int> const& xxx);
};

template<typename T>
int foo<T>::operator-(foo const& rhs) {
  //                  ^^^
  //                 foo<T>
  return 23;
}

template<typename T>
bool foo<T>::dings(foo<int> const& xxx) {
  return false;
}

Außerdem heißt es offiziell "class template" und "function template", wortlich übersetzt: "Klassen-Schablone" und "Funktions-Schablone". "template class" (Schablonenklasse) kann missverstanden werden. Meint man damit die ganze Familie von Klassen oder nur eine "Spezialisierung"?

Gruß,
SP

ohhh du möchtest mich ärgern, oder?

Viele grüße
MM

ohhh du möchtest mich ärgern, oder?

Denke nicht, dass er das möchte. Was bringt dich auf den Gedanken? Ich denke er möchte vor allem klarmachen, dass man sich gerade bei solchen Feinheiten korrekt ausdrücken muss um nicht missverstanden zu werden.

Okay, Ich probiere es besser zu erklären.

Ich habe ein Klassen Template A und dieses sieht wie folgt aus:

template
<
    int i,
    class c
>
class A
{

}

Nun möchte ich eine Funktion foo hinzufügen, welche zwei Parameter hat und zwei Argumente von dem Klassen Template A entgegen nehmen. Wichtig für mich ist, dass die Template Parameter nicht gleich sein müssen.

sprich

template
<
    int i,
    class c
>
void A<i,c>::foo(A<i,c> lhs, A<i,c> rhs)
{
}

möcht ich nicht habe, da dort immer i und c identisch sind.

template
<
    int i,
    class c
>
void A<i,c>::foo(A<i1,c1> lhs, A<i2,c2> rhs)
{
}

So etwas möchte ich haben. Ist ungefähr klar, auf was ich abziele?

Viele Grüße
MM

template <int i, class c>
class A
{
  template<int i1, class c1, int i2, class c2>
  void foo(A<i1,c1> lhs, A<i2,c2> rhs);
};

template <int i, class c>
template <int i1, class c1, int i2, class c2>
void A<i, c>::foo(A<i1,c1> lhs, A<i2,c2> rhs)
{
  /*...*/
}

so wie ich deinen ersten Beitrag verstanden habe, möchtest du eine Funktion haben, welche selber wiederum Parameter vom Typ A<c, i> hat:

template<int i, typename c>
void A<i,c>::foo(A<i,c> a1, A<i,c> a2)
{
  // ...
}

Wenn du jedoch möchtest, daß die Parameter auch noch unterschiedlich (bezogen auf die Template-Parameter) sind, so benötigst du Element-Templates:

template
<
    int i,
    typename c // ich benutze lieber typename statt class -)
>
template<int i1, typename c1, int i2, typename c2>
void A<i,c>::foo(A<i1,c1> lhs, A<i2,c2> rhs)
{
}

Edit: meine zweite Vermutung war also richtig...

ohhh du möchtest mich ärgern, oder?

Eigentlich nicht. Ich war im Glauben, Deine Frage beantwortet zu haben. Ich habe Dich zumindest auf die Feinheiten der Terminologie aufmerksam gemacht.

MrMilk schrieb:

Nun möchte ich eine Funktion foo hinzufügen, welche zwei Parameter hat und zwei Argumente von dem Klassen Template A entgegen nehmen.

Man kann einer Funktion kein "Klassen Template" übergeben!

MrMilk schrieb:

Wichtig für mich ist, dass die Template Parameter nicht gleich sein müssen.

Aha! Du meinst also, die Funktion soll zwei Objekte beliebiger Spezialisierungen des Klassentemplates A entgegennehmen. Dann sag das auch!

Gruß,
SP

MrMilk schrieb:

Wichtig für mich ist, dass die Template Parameter nicht gleich sein müssen.

Aha! Du meinst also, die Funktion soll zwei Objekte beliebiger Spezialisierungen des Klassentemplates A entgegennehmen. Dann sag das auch!

Genau das meinte ich mit dem Korrekten Ausdrücken bei den gewissen Feinheiten

Wieder etwas neues gelernt.

Viel Grüße
MM