使用特定成员变量值创建类型的类型

最有效的方法是什么？

您可以使用非类型模板参数：

enum class FruitType {
   AppleType = 0,
   OrangeType = 1,
   BananaType = 2,
};
template <FruitType F>
class Fruit {
 public:
   FruitType fruit_type() const { return F; }
};
using Apple = Fruit<FruitType::AppleType>;
using Banana = Fruit<FruitType::BananaType>;

您是否需要实际的基类取决于您。为某些FruitTypes。

这是您想做的吗？

enum class FruitType 
{
    AppleType = 0,
    OrangeType = 1,
    BananaType = 2,
};
class Fruit 
{
public:
    virtual FruitType fruit_type() const = 0;
};
class Apple: public Fruit 
{
public:
    FruitType fruit_type() const override { return FruitType::AppleType; }
};
class Orange : public Fruit 
{
public:
    FruitType fruit_type() const override { return FruitType::OrangeType; }
};
class Banana : public Fruit 
{
public:
    FruitType fruit_type() const override { return FruitType::BananaType; }
};
int main()
{
    Fruit *somefruit = new Apple;
    std::cout << "Is Apple? " << std::boolalpha << (somefruit->fruit_type() == FruitType::AppleType) << std::endl;
    std::cout << "Is Orange? " << std::boolalpha << (somefruit->fruit_type() == FruitType::OrangeType) << std::endl;
    std::cout << "Is Banana? " << std::boolalpha << (somefruit->fruit_type() == FruitType::BananaType) << std::endl;
    return 0;
}

打印：

Is Apple? true
Is Orange? false
Is Banana? false

您的问题对要求很抽象。

尽管您的编辑澄清指导了一种方式

主要用例如下 - 在我的应用程序中，有些方法只期望苹果作为输入，或者只期望橙色作为输入，而许多不关心哪种水果的方法。

我正在考虑基于接口和 tag界面的完全不同的系统
（请参阅完整的实时演示）。

首先定义所有水果的常见接口：

// A basic interface common for all fruits
struct IFruit {
  virtual ~IFruit() {}
  virtual std::string category() const = 0;
  virtual std::string common_name() const = 0;
  virtual std::string botanical_name() const = 0;
};
// An overload for the output operator is just nifty
std::ostream& operator<<(std::ostream& os, const IFruit& fruit) {
    os << "Category       : " << fruit.category() << std::endl;
    os << "Common Name    : " << fruit.common_name() << std::endl;
    os << "Botanical Name : " << fruit.botanical_name() << std::endl;
    return os;
}

定义标签接口以区分您的特定类型（苹果，橙色）：

// Tag interfaces to distinguish (not necessarily empty)
struct IApple : public IFruit {
  virtual ~IApple() {}
};
struct IOrange : public IFruit {
  virtual ~IOrange () {}
};

这些应暗中实现IFruit接口。

现在您可以提供一个抽象基类，该类实现IFruit接口。
该基类是 abractive 在某种意义上，构造函数函数隐藏在public范围内，需要通过继承类构造函数来调用：

// Abstract base class implementation
template<class TagInterface>
class FruitBase : public TagInterface {
protected:
      std::string category_;
      std::string common_name_;
      std::string botanical_name_;
      FruitBase ( const std::string& category
                , const std::string& common_name
                , const std::string botanical_name) 
          : category_(category), common_name_(common_name)
          , botanical_name_(botanical_name) 
      {}
public:
      virtual ~FruitBase () {}
      virtual std::string category() const { return category_; }
      virtual std::string common_name() const { return common_name_; }
      virtual std::string botanical_name() const { return botanical_name_; }
};

根据需要添加其他标签接口：

 struct IDriedApple : public IApple {
     virtual ~IDriedApple() {}
     virtual int rest_humidity() const = 0;
 };

现在，您可以使用相当狭窄的类固定来创建具体实现：

// Concrete apples
struct Boskop : public FruitBase<IApple> {
public:
     Boskop() : FruitBase("Apples","Boskop","Malus domestica 'Belle de Boskoop'") {}
};
struct Braeburn : public FruitBase<IApple> {
public:
     Braeburn() : FruitBase("Apples","Braeburn","Malus domestica") {}
};
// Concrete oranges
struct Valencia : public FruitBase<IOrange> {
public:
     Valencia() : FruitBase("Oranges","Valencia","Citrus × sinensis") {}
};
struct Navel : public FruitBase<IOrange> {
public:
     Navel() : FruitBase("Oranges","Navel","Citrus × sinensis") {}
};

这是我认为您的功能声明，专门用于服用 apples 或 oranges 仅：

void aFunctionThatTakesOnlyApples(IApple& anApple) {
    std::cout << "This is an apple:" << std::endl;
    std::cout << anApple;
}
void aFunctionThatTakesOnlyOranges(IOrange& anOrange) {
    std::cout << "This is an orange:" << std::endl;
    std::cout << anOrange << std::endl;
}

这是一个简单的模板函数，用于查询IFruit的已知实例，用于实现特定的 tag接口： 模板 taginterface* querytaginterface（ifruit* frual）{ 返回Dynamic_cast（水果）; }

这就是您在行动中使用所有这些的方式：

int main() {
    std::vector<std::unique_ptr<IFruit>> allFruits;
    allFruits.push_back(std::make_unique<Boskop>());
    allFruits.push_back(std::make_unique<Braeburn>());
    allFruits.push_back(std::make_unique<Valencia>()); 
    allFruits.push_back(std::make_unique<Navel>());
    for(auto& fruit : allFruits) {
        if(IApple* anApple = queryTagInterface<IApple>(fruit.get())) {
            aFunctionThatTakesOnlyApples(*anApple);
        }
        if(IOrange* anOrange = queryTagInterface<IOrange>(fruit.get())) {
            aFunctionThatTakesOnlyOranges(*anOrange);
        }
        std::cout << "-----------------------------------------------" << std::endl;
    }    
}

将水果传递到只期望苹果的方法感觉不安全/晦涩难懂，与此同时，有许多方法不在乎哪种类型是什么类型，因此拥有3种不同类型的方法也不是一个好选择。

我应该注意，我仍然不明白是什么使苹果和 oranges fuits 他们真的应该得到自己的类型。但是，这可能适用于多态类设计的不抽象隐喻，对具体类别的层次结构有用。