是否可以默认传递“this”？

Question

是否可以默认传递this？

这是我目前拥有的

class A
{
public:
    template<typename T>
    void dowithT(T t) {}
};

class B
{
public:
    A a;

    B()
    {
        //Calling 'dowithT' with 'this'
        a.dowithT(this);
    }
};

这个函数每次都需要从函数调用者那里传递this。所以想知道有没有办法封装这个任务，这样就不用把this传给dowithT了。

我试图做这样的事情：

class A
{
public:
    // '= this' doesn't compile
    template<typename T>
    void dowithT(T t = this) {}
};

class B
{
public:
    A a;

    B()
    {
        //Calling 'dowithT' without 'this'
        a.dowithT();
    }
};

不幸的是，我不能使用模板，所以我的第一个解决方案不是一个选项。

这可能吗？

编辑：我在下面用我自己的实现给出了一个具体的答案。最后还有一些我想要的细节。

Answer 1

在尝试了你提到的各种事情之后，我想自己给出我对问题的答案/解决方案，以澄清一些细节：

#include <iostream>
using namespace std;

#include <functional>

template <typename CallerType>
class AFunctionConstructor{
private:
    virtual void abstr()
    {}
public:
    
    typedef void(CallerType::*CallerTypeFunc)();

    function<void()>* constructFunction(CallerTypeFunc func)
    {
        CallerType* newMe = dynamic_cast<CallerType*> (this);
        return new function<void()>(std::bind(func,newMe));
    }       
};

class A : public function<void()>
{
protected:
    
     
public:
    A();
    A(function<void()>* func) : function<void()>(*func)
    {}

};


//  now create ressource classes
//  they provide functions to be called via an object of class A

class B : public AFunctionConstructor<B>
{
    void foo()
    {
        cout << "Foo";
    }

public:
    A a;

    B() : a(constructFunction(&B::foo)) {}
};

class C : public AFunctionConstructor < C >
{
    void bar()
    {
        cout << "Bar";
    }

public:
    A a;

    C() : a(constructFunction(&C::bar)) {}
};

int main()
{
    B b;
    C c;

    b.a(); 
    c.a();

    cout << endl;

    A* array[5];

    array[0] = &b.a;        //different functions with their ressources
    array[1] = &c.a;        
    array[2] = &b.a;
    array[3] = &c.a;
    array[4] = &c.a;

    for (int i = 0; i < 5; i++)     //this usability i wanted to provide
    {
        (*(array[i]))();
    }

    getchar();
    return 0;
}

输出：

FooBar

FooBarFooBarBar

这是我可以将其按下的有关示例。但我想这是不安全的代码。我偶然发现了其他可能的更简单的方法来实现这一点（std::function 和 lambdas 的其他用途（我可能试图在这里部分重新发明）。

起初我试图将“this”传递给function<void()>*AFunctionConstructor::constructFunction(CallerTypeFunc func)中的绑定函数 ，不过，我现在通过动态上调。 此外，AFunctionConstructor 的功能首先应该在 A 的构造函数中实现。

Answer 2

如果您希望能够传递其他值，您可以使用 B 类中的私有方法作为中继，并使用常量 nullptr 作为特殊值：

class B
{
public:
    A a;

    B()
    {
        //Calling 'dowithT' with 'this'
        innerdo();
    }
private:
    void innerdo(B *p = nullptr) {
        if (p == nullptr) p = this;
        a.dowithT(p);
    }
};

如果只需要传递this就更简单了

    void innerdo() {
        a.dowithT(this);
    }

Answer 3

您可以通过使用私有 mixin 类提供不带参数的 dowithT 方法来实现您想要的：

#include <iostream>
#include <typeinfo>

class A
{
public:
    template<typename T>
    void dowithT(T* t) {
      std::cout << "Hello, World" << typeid(*t).name() << std::endl;
    }
};

template<class Owner>
  struct calls_a
  {
    void dowithT()
    {
      auto p = static_cast<Owner*>(this);
      p->a.dowithT(p);
    }
  };

class B
  : private calls_a<B>
{
    friend calls_a<B>;
    A a;

public:
    B()
    {
        //Calling 'dowithT' with 'this'
        dowithT();
    }
};

int main()
{
  B b;

}

Answer 4

代替B 具有A 类型的成员，它可以从A继承，并使用类似"curiously recurring template pattern." 的东西

如果你不能将 A 类作为模板，你仍然可以这样做：

class A
{
    protected:
    template <class T>
    void dowithT()
    {
         T* callerthis = static_cast<T*>(this);
         // callerthis is the "this" pointer for the inheriting object
         cout << "Foo";
    }
};

class B : public A
{
    public:
    B()
    {
        dowithT<B>();
        // Or A::dowithT<B>();
    }
};

dowithT() 只能由继承类调用（因此我将其设为protected），模板参数是调用者自己的类型，否则你会破坏一切。

Answer 5

这里有一种可能性，它可能适合也可能不适合您的需求：

template<typename T>
class A
{
public:
    A(T t) : t(t) {}

    void dowithT()
    {
         cout << "Foo";
    }

private:
    T t;
};

class B
{
    public:
    A<B*> a;

    B() : a(this)
    {
        a.dowithT();
    }
};

Answer 6

this A 与 this B 不同。在您的第一个代码中，this 指的是调用者，而在第二个代码中this 指的是callee。因此，您想要做的实际上是不可能的。

Answer 7

不，这是不可能的。 this 在用作采用 T*（模板或非模板）的函数的参数时并没有什么特别之处，它只是一个指针。

Answer 8

TL;DR 不，这是不可能的。

this 在每个类中都不是同一个类型，你不能概括它，所以不，不可能。

另外，如果doWithT() 是从非成员函数调用的，this 会是什么？ nullptr?

这就是为什么它是不可能的。你必须使用template。