我可以根据 class 声明不同的 typedef 吗？

Question

是否可以根据实例化派生 class 的不同类型定义？

假设我有一个带有虚函数 func() 的父 class、两个 int 成员和一个 myType 类型的向量，以及两个子 classes，这共享相同的 int 成员和 vector，但它们对 func() 的实现要求 myType 略有不同。

例如：

class Parent {
  protected:
    int myMember;
    int myOtherMember;
    std::vector<myType> vec;

  public:
    Parent(variable);
    virtual int func() = 0;
}

class Child1 : public Parent {
  private:
    typedef <some type definiton> myType;

  public:
    Child1(variable) : Parent(variable){};
    int func() {return someFunc();};
}

class Child2 : public Parent {
  private:
    typedef <some other type definiton> myType;

  public:
    Child2(variable) : Parent(variable){};
    int func() {return someOtherFunc();};
}

我可以做这样的事情吗？当我尝试它时，它在头文件中创建了一个循环依赖，因为 class Parent 需要首先包含，但随后需要定义 myType。

有没有一种方法可以根据 class 向前声明 myType？或者我只需要在每个 class 中包含一个不同的 myType 向量，就像这样：

class Parent {
  protected:
    int myMember;
    int myOtherMember;

  public:
    Parent(variable);
    virtual int func() = 0;
}

class Child1 : public Parent {
  private:
    typedef <some type definiton> myType;
    std::vector<myType> vec;

  public:
    Child1(variable) : Parent(variable){};
    int func() {return someFunc();};
}

class Child2 : public Parent {
  private:
    typedef <some other type definiton> myType;
    std::vector<myType> vec;     

  public:
    Child2(variable) : Parent(variable){};
    int func() {return someOtherFunc();};
}

Answer 1

这就是模板的用途：

<template typename T>
class Child : public Parent {
private:
    std::vector<T> vec;
public:
    Child(variable) : Parent(variable) {};
    int func() { return someOtherFunc(); };
}

然后 Child 声明如下：

Child<int> myChildInstance(10);

Answer 2

这是 template男人的工作！

首先我们声明Parent

template <class TYPE>
class Parent {
  protected:
    int myMember;
    int myOtherMember;
    std::vector<TYPE> vec;

  public:
    Parent(TYPE variable);
    virtual int func() = 0;
};

不幸的是，Child1 中包含的自定义类型不适合这种方法，因为在我们可以专门化模板之前需要声明该类型。我在这里使用 int 和 double 是为了方便。根据需要更换。

using Child1Type = int;
// or typedef int Child1Type; pre-C++11
class Child1 : public Parent<Child1Type> {
  public:
    Child1(Child1Type variable) : Parent(variable){};
    int func() {return someFunc();};
};

using Child2Type = double;
class Child2 : public Parent<Child2Type> {

  public:
    Child2(Child2Type variable) : Parent(variable){};
    int func() {return someOtherFunc();};
};

编辑

因为没有早点得到这个而自责（并且浪费了太多时间，因为我知道这是可能的，但我的想法是错误的）

在Parent中声明类型up。根据需要能够查看类型的人员设置访问权限。这里我做了Typepublic来测试main。该类型在 Parent 中声明，并且对子对象可见（并且通过因为它是 public）。

还去掉了所有不是立即需要的东西，并使用了固定宽度的整数类型，这样我就可以轻松地展示差异。

我认为这正是 Pixelchemist 所暗示的。

template <class TYPE>
class Parent {
  public:
    using Type = TYPE; // declare Type here
  protected:
    int myMember;
    int myOtherMember;
    std::vector<Type> vec; // visible here

  public:
    Parent(Type variable); // here
    virtual ~Parent(){}
    virtual int func() = 0;
};

class Child1 : public Parent<uint16_t> { // complicated type needs to be reproduced 
                                         // only once, here in the specialization
  public:
    Child1(Type variable) : Parent(variable){};
};

class Child2 : public Parent<uint32_t> {

  public:
    Child2(Type variable) : Parent(variable){};
};

int main()
{
    // and visible way down here in main through Child1 and Child2
    std::cout << "Child 1: " << sizeof(Child1::Type) << std::endl; 
    std::cout << "Child 2: " << sizeof(Child2::Type) << std::endl;
}

输出为

Child 1: 2
Child 2: 4

Answer 3

您可以简单地使用模板：

template<class T>
struct Base
{
  std::vector<T> v;
};

struct D1 : public Base<int>
{
  // all stuff in here comes into play when deriving from Base is already done
  // Thus, compiler cannot know any typedefs from here inside Base...
};

struct D2 : public Base<double>
{
};

您不能使用基 class 派生的 typedef。请参阅。

我可以根据 class 声明不同的 typedef 吗？

Can I declare a different typedef depending on class?

c++

typedef

forward-declaration

编辑