c++ Vorlage Spezialisierung Methode Frage

Question

Ich bin neu in C++ und ich versuche, Vorlagen zu verwenden, aber ich habe Probleme. Was ich zu tun versuche, ist: versuchen, das Quadrat einer Zahl mit Vorlage zu berechnen, und die Zahl kann grundlegende Datentypen wie int, float, sowie komplexe Zahlen sein. Ich habe auch eine komplexe Klasse mit Vorlage implementiert, und die Codes sind wie folgt:

template <typename T>
class Complex {
public:
  T real_;
  T img_;

  Complex(T real, T img) : real_(real), img_(img) { } 
};

template <typename T>
T square(T num) {
  return num * num;
}

template <>
Complex<typename T> square(Complex<typename T> num) {
  T temp_real = num.real_*num.real_ - num.img_*num.img_;
  T temp_img  = 2 * num.img_ * num.real_;
  return Complex(temp_real, temp_img);
}

Ich habe versucht, Template-Spezialisierung zu verwenden, um mit dem Sonderfall umgehen, aber es gab mir Fehler:

using ‘typename’ outside of template

und der Fehler tritt bei der Spezialisierungsmethode der Vorlage auf. Bitte weisen Sie mich auf meine Fehler hin. Danke!

Answer 1

Es scheint, dass Sie versuchen, Funktionsvorlagen teilweise zu spezialisieren, was in C++ eigentlich nicht möglich ist. Was Sie stattdessen wollen, ist, die Funktion einfach wie folgt zu überladen:

template<typename T>
T square(T num) // Overload #1
{ 
    return num * num;
}

template<typename T>
Complex<T> square(Complex<T> num) // Overload #2
{
    T temp_real = num.real_*num.real_ - num.img_*num.img_;
    T temp_img  = 2 * num.img_ * num.real_;
    return Complex<T>(temp_real, temp_img);
}

Informell wird der Compiler immer Überladung #2 über Überladung #1 wählen, wenn das Argument vom Typ Complex<T> weil es besser passt.

---

Eine andere Möglichkeit, dies zu erreichen, ist die Überladung des Multiplikationsoperators für die Complex<> Klasse mit die Definition der Multiplikation für komplexe Zahlen . Dies hat den Vorteil, dass es allgemeiner ist und man diese Idee auf andere Betreiber ausdehnen kann.

template <typename T>
class Complex
{
public:
    T real_; 
    T img_; 

    Complex(T real, T img) : real_(real), img_(img) {} 

    Complex operator*(Complex rhs) // overloaded the multiplication operator
    {
        return Complex(real_*rhs.real_ - img_*rhs.img_,
            img_*rhs.real_ + real_*rhs.img_);
    }
};

// No overload needed. This will work for numeric types and Complex<>.
template<typename T>
T square(T num)
{
    return num * num;
}

---

Da Sie neu in C++ sind, empfehle ich Ihnen dringend, sich mit ein gutes C++-Einführungsbuch . Templates und Operatorüberladung sind nicht gerade Anfängerthemen.