C++ 有趣的问题是运算符重载

可能重复：

<>我尝试在C++中使用运算符重载和泛型，我尝试编译时，似乎有3个小错误。使用模板D创建一个名为Grandeur的类，然后我从这个类继承了3个类，分别是

Temps（time）

，

Longueur（size）

，

Vitesse（speed）

，我试图重载操作符，比如当我执行

Temps+Temps->Temps时，Vitesse+Vitesse=Vitesse，Longueur+Longueur->Longueur，Longueur/Time->vites

等。 为了避免为相同类型的操作编写3次相同的函数，我使用模板来利用泛型。但是当我试图编译时，我有一个错误。这是我的密码：

typedef double Longueur;
typedef double Temps;
typedef double Vitesse;



template<typename D>
class Grandeur {
  protected :
    double val; const char* unite;



  public :
    Grandeur(double qqc) : val(qqc) {}
    Grandeur(int qqc) : val(qqc) {}
    Grandeur(long qqc) : val(qqc) {}
    Grandeur(float qqc) : val(qqc) {}

    inline friend D operator+ (const D a, const D b) {
      return D (a.val + b.val);
    }

    inline friend D operator- (const D a, const D b) {
      return D (a.val - b.val);
    }

    inline friend double operator* (const D a, const D b) {
      return a.val * b.val;
    }

    inline friend double operator/ (const D a, const D b) {
      return a.val / b.val;
    }

    inline friend D operator* (D a, const int b) {
      return D (a.val * b);
    }

    inline friend D operator/ (const D a, const int b) {
      return D (a.val / b);
    }

    inline friend ostream& operator<< (ostream& os, D d) {
      return os << d.val << d.u;
    }

    class Temps : public Grandeur<Temps> {
    public:


  };

  class Vitesse : public Grandeur<Vitesse> {
    public:


  };

  class Longueur : public Grandeur<Longueur> {
    public:

  };

};




inline Longueur operator* (const Vitesse v, const Temps t) {
  return Longueur(v.val * t.val);
}

inline Vitesse operator/ (const Longueur l, const Temps t) {
  return Vitesse(l.val / t.val);
}

inline Temps operator/ (const Longueur l, const Vitesse v) {
  return Temps(l.val / v.val);
}

typedef-double-Longueur；
typedef双温；
typedef双维特斯；
模板
阶级气派{
受保护的：
双值；常量字符*单位；
公众：
宏伟（双qqc）：val（qqc）{}
宏伟（内部qqc）：val（qqc）{}
宏伟（长qqc）：val（qqc）{}
宏伟（浮动qqc）：val（qqc）{}
内联友元D运算符+（常数D a，常数D b）{
返回D（a.val+b.val）；
}
内联友元D运算符-（常数D a，常数D b）{
返回D（a.val-b.val）；
}
内联友元双运算符*（常数D a，常数D b）{
返回a.val*b.val；
}
内联友元双运算符/（常数D a，常数D b）{
返回a.val/b.val；
}
内联友元D运算符*（DA，常量int b）{
返回D（a.val*b）；
}
内联友元D运算符/（常数D a，常数int b）{
返回D（a.val/b）；
}
inline friend ostream&operator您正在全局范围内声明运算符，因此编译器无法使用类型
Vitesse
等。为什么不将子类移到
Grandeure
的定义之外

编辑以供评论：
您正试图使用具有双值的运算符，但您的子类不会自动继承隐式转换。您需要在每个子类中定义它们，并将参数传递给父模板类。
您在全局范围内声明运算符，因此类型
Vitesse
等对您不可用编译器。为什么不将子类移到Grandeum的定义之外呢

编辑以供评论：
您试图使用具有双值的运算符，但隐式转换不会自动由子类继承。您需要在每个子类中定义它们，并将参数传递给父模板类。
您用作参数类型的类不存在于该范围内。好的，我现在明白了。但因为我使用了generi城市我不能明确地写它。我能做什么？我不知道如何改变它。只需将
class Vitesse:public grandeum{…}
和
class Longueur:public grandeum{…}
移出
模板class grandeum{…}
。您用作参数类型的类不存在于该范围内。好的，我现在明白了。但是由于我使用泛型，我无法显式地编写它。我能做什么？我不知道如何更改它。只需移动
类Vitesse:public grandeum{…}
和
类Longueur:public grandeum{…}
超出
模板类Grandeur{…}
。如果这样做，我会得到：grandeurs.h:35:26:错误：没有匹配函数用于调用'Longueur:：Longueur（double）'grandeurs.h:35:26:注意：候选对象是：grandeurs.h:57:9:注意：Longueur:：Longueur（）grandeurs.h:57:9:注意：候选者需要0个参数，1个提供grandeurs.h:57:9:注意：Longueur:：Longueur（const Longueur&）grandeurs.h:57:9:注意：没有已知的参数1从'double'到'const Longueur&'的转换，如果我这样做，我会得到：grandeurs.h:35:26:错误：对'Longueur:：Longueur（double）的调用没有匹配函数“Grandeus.h:35:26:注意：候选者是：Grandeus.h:57:9:注意：Longueur:：Longueur（）Grandeus.h:57:9:注意：候选者期望0个参数，1个提供了Grandeus.h:57:9:注意：Longueur:：Longueur（const Longueur&）Grandeus.h:57:9:注意：参数1从“double”到“const Longueur&”没有已知的转换