在静态类函数成员中获取类对象指针

2 回答

• 1

  做你要求的事情并不难;它可能看起来像这样：

  class Foo {
  private:
      int bar_;
      static Foo* pFoo;
  
  public:
      explicit Foo( int a ) : bar_( a ) {
          pFoo = this;
      }
  
      static void printBar() {
          std::cout << pFoo->bar_ << '\n';
      }
  };
  
  Foo* Foo::pFoo = nullptr;
  
  int main() {
      Foo f( 3 );
      f1.printBar();
  
      return 0;
  }
  

  -Output-

  3
  

  ---

  这可以工作，但你必须谨慎静态指针的工作方式 . 以此程序为例：

  int main() {
      Foo f1( 3 );
      f1.printBar();
  
      Foo f2( 8 );
      f2.printBar();
  
      return 0;
  }
  

  -Output-

  3
  8
  

  ---

  好的，我们有2个 Foo 个实例; f1 和 f2 并分别输出 3 和 8 ;那为什么我们需要谨慎？让我们再次运行上面的内容，但添加了一行编码 .

  int main() {
      Foo f1( 3 );
      f1.printBar();
  
      Foo f2( 8 );
      f2.printBar();
  
      // call f1's printBar() again
      f1.printBar(); // What do you think the output will be? 
      // I will tell you that it is not 3!
  
      return 0;
  }
  

  -Output-

  3
  8
  8
  

  ---

  这可能是你正在寻找的，但你必须是一个类的成员静态指针的良心，以及它们如何与一个类的多个实例行为 .

  在上面的示例中， f1 的成员 bar_ 在其构造函数中设置为 3 ，然后将静态指针设置为this . 然后当我们创建 f2 并使用值 8 调用它的构造函数时;它将 f2 的 bar_ 设置为 8 ，然后再次设置 static pointer . 由于 static storage ，这也恰好将 f1 的 bar 从 3 更改为 8 . 这是你需要注意的事情！

  ---

  即使您在初始化值之后通过类的范围解析运算符调用静态方法，它仍将产生相同的结果 .

  int main() {
      Foo f1( 3 );
      f1.printBar();
  
      Foo f2( 8 );
      f2.printBar();
  
      f1.printBar(); 
  
      Foo::printBar();
  
      return 0;
  }
  

  -Output-

  3
  8
  8
  8
  

  ---

  这只是类的成员静态指针如何工作的一般概念，以及静态方法 .

  ---

  用户Alan Birtles提到了我在写这个答案时没有想到的警告或陷阱 . 他说：

  请注意，如果最近创建的对象已被销毁，则回调将具有未定义的行为 .

  回复于 2024-04-25T20:51:08+08:00
• 0

  一种选择是使用标记结构作为模板参数，为每个回调生成不同的类型：

  #include <iostream>
  #include <string>
  #include <memory>
  
  template < typename T >
  class Foo
  {
  public:
      static void test()
      {
          std::cout << instance() << "\n";        
      }
  
      static std::shared_ptr< Foo< T > > instance()
      {
          static std::shared_ptr< Foo< T > > foo( new Foo< T >() );
          return foo;
      }
  
  private:
      Foo() {}
  };
  
  struct instance1 {};
  struct instance2 {};
  
  typedef void(*callback_t)();
  
  int main()
  {
      callback_t callback1 = Foo< instance1 >::test;
      callback_t callback2 = Foo< instance2 >::test;
      callback1();
      callback2();
  }
  

  我已经使用了共享指针来确保在执行回调时仍然存在创建的对象（注意这些将在程序的生命周期中存在） . 如果你想自己控制生命周期，你可以使用弱指针代替：

  #include <iostream>
  #include <string>
  #include <memory>
  
  template < typename T >
  class Foo
  {
  public:
      static void test()
      {
          std::cout << instance() << "\n";        
      }
  
      static std::shared_ptr< Foo< T > > instance()
      {
          static std::weak_ptr< Foo< T > > foo;
          std::shared_ptr< Foo< T > > result = foo.lock();
          if ( !result )
          {
              // will need a mutex here in multi-threaded applications
              result.reset( new Foo< T >() );
              foo = result;
          }
          return result;
      }
  
  private:
      Foo() {}
  };
  
  struct instance1 {};
  struct instance2 {};
  
  typedef void(*callback_t)();
  
  int main()
  {
      {
          auto foo = Foo< instance1 >::instance();
          callback_t callback1 = decltype(foo)::element_type::test;
          callback1();
      }
      {
          auto foo = Foo< instance2 >::instance();
          callback_t callback2 = decltype(foo)::element_type::test;
          callback2();
      }
      {
          auto foo = Foo< instance1 >::instance();
          // using a different object to callback1
          callback_t callback3 = decltype(foo)::element_type::test;
          callback3();
      }
  }
  

  如果在没有活动对象的情况下调用回调，则将创建并销毁新对象，而不是使程序崩溃 .

  回复于 2024-04-25T20:51:08+08:00