Question

简短版本：

重点是实例的（复杂）状态可以通过类定义之外的函数来改变，因此可以将类扩展为具有各种内部状态而不会污染类定义许多国家制定者。

假设以下代码：

 class bar
 {
      virtual void ChangeState()=0;
 }
 class foo:bar
 {
 private:
      int b;
 public:
      void ChangeState() {b=3;}
 }

我想要做的是创建不同的函数，然后在运行时将它们传递给函数，例如

foo.ChangeState(); //b is 3 now
void foo::(?)ChangeState2(){ b=2; };
foo.ChangeState=ChangeState2;
foo.ChangeState(); //b is 2 now

这样的构造可以用C ++实现，而不使用hacks吗？

Answer 1

简短回答：那是不可能的。

您可以做的是定义多个类，并根据某些运行时条件在它们之间进行选择。当然，这个对象不一定是完整的类，我们可以这样做：

 class foo: public bar
 {
    private:
       class ChangeState
       {
         public:
           virtual void DoChangeState(foo *f) = 0;
       };
       class ChangeState2
       {
         public:
           virtual void DoChangeState(foo *f) { f->b = 2 } ;
       };
       class ChangeState3 : public ChangeState
       { 
         public:
           virtual void DoChangeState(foo *f) { f->b = 3 } ;
       };
   ChangeState *stateChanger

   public:
      foo() { stateChanger = new ChangeState3; }
      void SetStateChange2() { delete stateChanger; stateChanger = new ChangeState2; }
      ~foo() { delete stateChanger; }
      void ChangeState() { stateChanger->DoChangeState(this); }
};

我确定这个主题还有其他变种（你可能应该使用智能指针）。

Answer 2

也许，这会有所帮助：

#include <iostream>

namespace so
{

class B
{
  friend void change_1( B * );
  friend void change_2( B * );
  friend void change_3( B * );

  int i;
 public:
  B() : i{ 0 } {}

  void change_state( void (*_function)( B * ) )
  {
   _function( this );

   std::cout << i << std::endl;
  }
};

void change_1( B * _object )
{
 _object->i = -1;
}
void change_2( B * _object )
{
 _object->i = -2;
}
void change_3( B * _object )
{
 _object->i = -3;
}

} //namespace so

int main()
{
 so::B b{ };

 b.change_state( so::change_1 );
 b.change_state( so::change_2 );
 b.change_state( so::change_3 );

 return( 0 );
}

Answer 3

您无法使用所描述的语法在运行时更改行为。但是，如果您希望通过使用函数指针获得类似的东西，则可以。

但如果我理解你想要正确完成的事情，我会考虑实施strategy pattern

如何在运行时更改方法的行为？

3 个答案: