在c ++中抽象两个稍有不同的函数的最佳方法是什么？

Question

Let's say I have a class which implements any number of similar methods, same return type and same parameter type to keep it simple.

Header:

protected:
  void MoveForward(float Magnitude);
  void MoveRight(float Magnitude);

Implementation:

void MyCharacter::MoveForward(float Magnitude) {
  AddMovementInput(GetActorForwardVector() * Magnitude);
}

void Myharacter::MoveRight(float Magnitude) {
  AddMovementInput(GetActorRightVector() * Magnitude);
}

Very similar methods, but only differing by the direction (Forward and Right in this case) in the method name, and the name of one of the internal functions.

What is the best way to abstract the common generic structure here?

Answer 1

You can do it in multiple ways, personally I've used an approach similar to the following:

enum class Direction { LEFT, RIGHT, TOP, BOTTOM };

class MyCharacter {
   template<Direction DIR> Vector MyCharacter::getVector() const;

   template<Direction DIR> void move() {
     AddMovementInput(getVector<Dir>() * magnitude);
   }
}

template<> Vector MyCharacter::getVector<Direction::LEFT>() const { ... }
template<> Vector MyCharacter::getVector<Direction::RIGHT>() const { ... }

Of course you can do the same exact thing without templates but I guess that you know what you are doing if you are specifically needing them.

Mind that you could directly pass the function as a template argument but I found it less clear, something like:

float GetActorForwardVector() { return 3.0f; }

class Foo
{
public:
  template<float (*F)()> float move() { return F(); }
  inline float moveLeft() { return move<GetActorForwardVector>(); }
};

int main()
{
  Foo foo;
  std::cout << foo.moveLeft();
}

Answer 2

To be honest you should not generalize at this level of algorithm. You just get a vector and scale it with a constant. If you were doing something more complex, then it would be another story. My first and foremost suggestion is let it stay this way.

Second, if you insist on generalization here it is (I assume GetXVector methods are class member):

class Foo
{
protected: 
    void MoveForward(float x) { Move(&Foo::GetActorForwardVector, x); }
    void MoveRight(float x) { Move(&Foo::GetActorRightVector, x); }
private:
    template<typename GetDirectionFunc>
    void Move(GetDirectionFunc getDirection, float x)
    {
        AddMovementInput((this->*getDirection)() * x);
    }
};

I prefer your original code.

Answer 3

You could use tag-dispatching.

Create the tag classes with same static member functions which implement the specific behavior:

namespace Direction {
struct Forward
{
    static Vector actorVector() { return GetActorForwardVector(); }
};

struct Right
{
    static Vector actorVector() { return GetActorRightVector(); }
};
} // namespace Direction

In your class, implement a template move function which takes an instance of the Direction class, but doesn't use it. Instead it calls the static member function of the tag class.

class MyCharacter
{
public:

    template< typename Direction >
    void move( const float magnitude, const Direction )
    {
        AddMovementInput( Direction::actorVector() * magnitude );
    }
};

Usage example:

MyCharacter mc;

mc.move( 10.0, Direction::Forward() );

If you want to create more directions, only a new tag class is needed which implements the static member function.

Answer 4

Templates are not meant to be used when you handle different values (forward, right), they meant to handle different types (int, double). You can use one generic Move function with arguments:

void Move(int x, int y);

// Move forward
Move (0, 1);

// Move right
Move (1, 0);

You can use function pointers to combine move direction and corresponding function in a struct:

struct MOVE_INFO
{
    int x;
    int y;
    void (*GetVector)(void);
}

void Move(MOVE_INFO mv)
{
    ...
    mv.GetVector();
    ...
}

main()
{
    MOVE_INFO forward = {0, 1, SomeLib::GetForwardVector};
    MOVE_INFO right = {1, 0, SomeLib::GetRightVector};

    // Move Forward
    Move(forward);

    // Move Right
    Move(right);
}