C++中如何为同一个类定义不同的类型

我希望有几种类型共享相同的实现，但在 C++ 中仍然是不同的类型。

为了用一个简单的例子来说明我的问题，我想要一个苹果、橙子和香蕉的类，它们都具有相同的操作和相同的实现。我希望它们有不同的类型，因为我想通过类型安全来避免错误。

class Apple {
     int p;
public:
     Apple (int p) : p(p) {}
     int price () const {return p;}
}

class Banana {
     int p;
public:
     Banana (int p) : p(p) {}
     int price () const {return p;}
}

class Orange ...

为了不重复代码，看起来我可以使用基类 Fruit 并从中继承：

class Fruit {
     int p;
public:
     Fruit (int p) : p(p) {}
     int price () const {return p;}
}

class Apple: public Fruit {};
class Banana: public Fruit {};
class Orange: public Fruit {};

但是，构造函数不是继承的，我必须重写它们。

是否有任何机制（typedef、模板、继承...）可以让我轻松地拥有具有不同类型的相同类？

一种常见的技术是拥有一个类模板，其中模板参数仅充当唯一标记（“标签”）以使其成为唯一类型：

template <typename Tag>
class Fruit {
    int p;
public:
    Fruit(int p) : p(p) { }
    int price() const { return p; }
};

using Apple = Fruit<struct AppleTag>;
using Banana = Fruit<struct BananaTag>;

请注意，标签类甚至不需要定义，就足够了declare唯一的类型名称。这是有效的，因为标签实际上是used模板中的任何位置。并且您可以声明类型名称inside模板参数列表（向@Xeo 致敬）。

The using语法为 C++11。如果您无法使用 C++03，请改为这样写：

typedef Fruit<struct AppleTag> Apple;

如果通用功能占用大量代码，那么不幸的是，这会在最终的可执行文件中引入大量重复代码。可以通过使用实现该功能的公共基类，然后从它派生一个专门化（您实际实例化）来防止这种情况。

不幸的是，这需要您重新实现所有不可继承的成员（构造函数、赋值……），这本身就会增加一点开销——所以这只对大型类有意义。这里应用到上面的例子：

// Actual `Fruit` class remains unchanged, except for template declaration
template <typename Tag, typename = Tag>
class Fruit { /* unchanged */ };

template <typename T>
class Fruit<T, T> : public Fruit<T, void> {
public:
    // Should work but doesn’t on my compiler:
    //using Fruit<T, void>::Fruit;
    Fruit(int p) : Fruit<T, void>(p) { }
};

using Apple = Fruit<struct AppleTag>;
using Banana = Fruit<struct BananaTag>;