C++中如何抽象类内两个略有差异的相似成员函数？

假设我有一个类，实现了若干相似方法，为简化问题，这些方法的返回类型和参数类型均相同。

头文件：

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

实现代码：

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

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

（注：原代码里的Myharacter是笔误，已修正为MyCharacter）

这两个方法高度相似，仅方法名中的方向（此处为Forward和Right）以及内部调用的一个函数名称不同。请问该如何抽象它们的通用结构？

好问题！这种重复代码的场景，我们可以通过提取通用逻辑+传递核心差异点来优雅地抽象，这里有几种实用的方案，你可以根据实际需求选择：

方案1：提取私有辅助方法（最通用易读） #

最直接的思路是把重复的AddMovementInput逻辑抽成一个私有辅助函数，让原来的两个移动方法只负责提供对应的方向向量：

修改后的头文件： #

protected:
    void MoveForward(float Magnitude);
    void MoveRight(float Magnitude);
private:
    // 通用移动逻辑，接收方向向量和幅度
    void MoveInDirection(const FVector& Direction, float Magnitude);

修改后的实现代码： #

void MyCharacter::MoveInDirection(const FVector& Direction, float Magnitude) {
    AddMovementInput(Direction * Magnitude);
}

void MyCharacter::MoveForward(float Magnitude) {
    MoveInDirection(GetActorForwardVector(), Magnitude);
}

void MyCharacter::MoveRight(float Magnitude) {
    MoveInDirection(GetActorRightVector(), Magnitude);
}

这种方式既保留了原来清晰的对外接口，又彻底消除了重复代码——后续如果要加MoveUp这类新的移动方法，只需要一行代码调用辅助函数就行，维护成本极低。

方案2：用成员函数指针传递方向获取逻辑（更灵活） #

如果后续可能需要动态切换方向获取逻辑，或者有更多自定义方向的需求，可以把获取方向的成员函数作为参数传递：

修改后的头文件： #

protected:
    void MoveForward(float Magnitude);
    void MoveRight(float Magnitude);
private:
    // 定义方向获取函数的指针类型
    using DirectionGetter = FVector (MyCharacter::*)() const;
    void MoveWithGetter(DirectionGetter GetDirectionFunc, float Magnitude);

修改后的实现代码： #

void MyCharacter::MoveWithGetter(DirectionGetter GetDirectionFunc, float Magnitude) {
    // 通过成员函数指针调用获取方向的方法
    AddMovementInput((this->*GetDirectionFunc)() * Magnitude);
}

void MyCharacter::MoveForward(float Magnitude) {
    MoveWithGetter(&MyCharacter::GetActorForwardVector, Magnitude);
}

void MyCharacter::MoveRight(float Magnitude) {
    MoveWithGetter(&MyCharacter::GetActorRightVector, Magnitude);
}

这种方式灵活性拉满，但可读性比第一种稍弱，适合方向逻辑多变的场景。

方案3：Unreal专属优化——输入绑定阶段统一处理 #

如果这是Unreal引擎的项目，其实还可以在输入绑定环节就统一处理，省去单独的MoveForward/MoveRight方法：

实现代码（在SetupPlayerInputComponent中）： #

void MyCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) {
    Super::SetupPlayerInputComponent(PlayerInputComponent);
    
    // 绑定输入轴时直接传递对应的方向向量
    PlayerInputComponent->BindAxis(
        "MoveForward", 
        this, 
        &MyCharacter::MoveInDirection, 
        GetActorForwardVector()
    );
    PlayerInputComponent->BindAxis(
        "MoveRight", 
        this, 
        &MyCharacter::MoveInDirection, 
        GetActorRightVector()
    );
}

// 通用移动方法
void MyCharacter::MoveInDirection(float Magnitude, const FVector& Direction) {
    AddMovementInput(Direction * Magnitude);
}

这种方式适合从项目初期就规划统一输入处理的场景，能进一步简化类的接口。

总的来说，方案1是最推荐的通用方案——兼顾可读性和可维护性，除非你有特殊的动态需求，否则优先用它就好。

内容的提问来源于stack exchange，提问作者ThinkingInBits