从派生类调用时推断“this”指针类型？

Question

我在基类中有一个方法，它需要将类型传递给它以进行一些与类型相关的操作（查找、大小和一些方法调用）。目前它看起来像这样：

class base
{
    template<typename T>
    void BindType( T * t ); // do something with the type
};

class derived : public base
{
    void foo() { do_some_work BindType( this ); } 
};

class derivedOther : public base 
{
    void bar() { do_different_work... BindType( this ); } 
};

但是，我想知道是否有一种方法可以获取调用者的类型而无需传递它，以便我的调用点代码变为：

class derived : public base
{
  void foo() { BindType(); } 
};

没有明确的 this 指针。我知道我可以将模板参数显式提供为BindType<derived>()，但是有没有办法以某种其他方式提取调用者的类型？

Answer 1

没有什么神奇的方法可以获取调用者的类型，但是您可以使用 CRTP（正如评论中提到的那样）来自动执行此行为，但代价是一些代码复杂性：

class base
{
    template<typename T>
    void BindType(); // do something with the type
};

template <class T>
class crtper : base
{
     void BindDerived { BindType<T>(); }
}

class derived : public crtper<derived>
{
    void foo() { do_some_work BindDerived(); } 
};

class derivedOther : public crtper<derivedOther>
{
    void bar() { do_different_work... BindDerived(); } 
};

编辑：我应该提一下，我本来希望foo 是一个虚函数，在base 中没有实现而定义。这样您就可以直接从界面触发操作。尽管您的真实代码中可能有它，但在您的示例中却没有。无论如何，这个解决方案与此完美兼容。

Edit2：问题编辑后，进行编辑以阐明该解决方案仍然适用。

Answer 2

如果您想避免使用BindType<derived>()，请考虑（有点冗长，我同意）BindType<std::remove_reference<decltype(*this)>::type>(); 以避免传递参数。它在编译时得到解决，避免了运行时的惩罚。

class base
{
protected:
    template<typename T>
    void BindType() { cout << typeid(T).name() << endl; } // do something with the type
};

class derived : public base
{
public:
    void foo()
    {
        BindType<std::remove_reference<decltype(*this)>::type>();
    }
};

Answer 3

它不会像你期望的那样工作

foo() 的结果可能与您的预期不同：

class derived : public base           // <= YOU ARE IN CLASS DERIVED
{
public:
    void foo() { BindType( this ); }  // <= SO this IS OF TYPE POINTER TO DERIVED
};

模板参数在编译时被扣除，所以是derived*。如果您从派生自derived 的类derived_once_more 中调用foo()，它仍将使用derived* 类型。

Online demo

但是你可以去掉虚拟参数*

您可以使用decltype(this) 来表示变量的类型名。它仍然在编译时定义：

class base
{
public: 
    template<typename T>
    void BindType( ) 
    { 
         cout << typeid(T*).name()<<endl;  // just to show the type 
    }
    virtual ~base() {};                    // for typeid() to work 
};
class derived : public base
{
public: 
    void foo() { BindType<decltype(this)>( ); } 
};

Online demo

编辑：其他选择

由于模板参数需要在编译时而不是运行时提供，您可以使用：

• 模板参数推导（你的第一个代码sn-p）
• decltype (see above)
• 如果您打算在所有派生类中添加它，您可以使用宏来完成它，使用上述解决方案之一
• 您可以使用 CRTP 模式（已在另一个答案中解释过）。

Answer 4

避免 CRTP 的中间类的可能解决方案如下：

class base {
    using func_t = void(*)(void *);

    template<typename T>
    static void proto(void *ptr) {
        T *t = static_cast<T*>(ptr);
        (void)t;
        // do whatever you want...
    }

protected:
    inline void bindType() {
        func(this);
    }

public:
    template<typename T>
    base(T *): func{&proto<T>} {}

private:
    func_t func;
};

struct derived1: base {
    derived1(): base{this} {}

    void foo() {
         // ...
        bindType();
    }
};

struct derived2: base {
    derived2(): base{this} {}

    void bar() {
        // ...
        bindType();
    }
};

int main() {
    derived1 d1;
    d1.foo();

    derived2 d2;
    d2.bar();
}

基本思想是利用派生类的构造函数中的this 指针是所需类型的事实。
它们可以作为基类构造函数的参数传递，并用于专门化一个函数模板，在幕后完成这项肮脏的工作。
一旦构造函数返回，派生类的类型实际上会在基类中被删除。无论如何，proto 的特化包含该信息，它可以将基类的 this 指针转换为正确的类型。

只要需要专门化的功能很少，它就可以正常工作。
在这种情况下，只有一个函数，所以它很好地适用于这个问题。

---

您可以添加static_assert 以在T 上添加约束，例如：

template<typename T>
base(T *t): func{&proto<T>} {
    static_assert(std::is_base_of<base, T>::value, "!");
}

它需要包含<type_traits> 标头。