C++：如何在父类中定义抽象类，使子类可实现自定义邻域逻辑？

我近期刚从Julia转用C++，对部分概念尚不熟悉，若术语使用有误敬请谅解。我正在用C++实现一种元启发式算法，希望定义一个抽象类，让每个邻域都必须实现该类。每个邻域都有专属参数（对应待修改/更新的解向量索引，部分仅需1个参数，部分需多个），且各自拥有评估方法（返回参数变更带来的损失/收益）与执行变更的move方法。

我已有如下思路，但不确定是否正确及如何完善，是否应使用模板？若使用该如何操作？相关代码如下：

class Neighborhood
{
public:
    class NeighborhoodArgs
    {

    };

    virtual void move(NeighborhoodArgs args);
    virtual double evaluate(NeighborhoodArgs args);

private:
    Data& data;
    Parameters& parameters;
};

#include "Neighborhood.h"

class TwoOptNeighborhood : Neighborhood
{
public:
    class TwoOptArgs : NeighborhoodArgs
    {
        int pos1;
        int pos2;
    };

    void move(TwoOptArgs args) override;
    double evaluate(TwoOptArgs args) override;
};

你的思路方向正确，但现有代码存在几个关键问题，同时可以通过模板基类或多态参数类实现需求，以下是具体说明：

1. 现有代码的核心问题 #

• 虚函数重写失败：派生类的move(TwoOptArgs)与基类move(NeighborhoodArgs)签名不一致，这不是重写而是隐藏基类函数，编译器会报错（开启override检查时）。C++虚函数重写要求签名完全匹配。
• 引用成员未初始化：Neighborhood中的Data&和Parameters&是引用类型，必须在构造函数初始化列表中赋值，否则无法编译。
• 继承权限错误：默认的私有继承会让基类public成员在派生类中变为私有，应改为public继承。

2. 推荐方案：模板基类（编译期类型安全） #

每个邻域的参数类型固定且专属，模板基类可在编译期绑定参数类型，避免运行时开销，同时保证类型安全。

模板基类定义 #

// Neighborhood.h
// 假设Data和Parameters是你已定义的业务类型
class Data {};
class Parameters {};

template<typename ArgsType>
class Neighborhood
{
public:
    // 构造函数初始化引用成员
    Neighborhood(Data& d, Parameters& p) : data(d), parameters(p) {}

    // 纯虚函数，强制派生类实现
    virtual void move(const ArgsType& args) = 0;
    virtual double evaluate(const ArgsType& args) = 0;

protected:
    // 设为protected方便派生类访问业务数据
    Data& data;
    Parameters& parameters;
};

TwoOpt邻域实现 #

// TwoOptNeighborhood.h
#include "Neighborhood.h"

// 定义TwoOpt专属参数结构
struct TwoOptArgs
{
    int pos1;
    int pos2;
};

class TwoOptNeighborhood : public Neighborhood<TwoOptArgs>
{
public:
    // 传递基类所需的引用参数
    TwoOptNeighborhood(Data& d, Parameters& p) : Neighborhood<TwoOptArgs>(d, p) {}

    // 重写基类虚函数
    void move(const TwoOptArgs& args) override
    {
        // 实现TwoOpt的解修改逻辑，可直接访问基类的data和parameters
    }

    double evaluate(const TwoOptArgs& args) override
    {
        // 实现参数变更的收益/损失评估逻辑
        return 0.0; // 示例返回值
    }
};

单参数邻域示例（比如Swap邻域） #

// SwapNeighborhood.h
#include "Neighborhood.h"

struct SwapArgs
{
    int pos;
};

class SwapNeighborhood : public Neighborhood<SwapArgs>
{
public:
    SwapNeighborhood(Data& d, Parameters& p) : Neighborhood<SwapArgs>(d, p) {}

    void move(const SwapArgs& args) override
    {
        // 实现单位置交换逻辑
    }

    double evaluate(const SwapArgs& args) override
    {
        return 1.0; // 示例返回值
    }
};

3. 替代方案：多态参数类（支持运行时动态切换） #

如果算法需要在运行时动态切换不同邻域（比如存储Neighborhood*列表），模板基类无法直接满足（不同模板实例是独立类型），可采用参数类多态方案：

抽象基类定义 #

// Neighborhood.h
class Data {};
class Parameters {};

// 抽象参数基类，必须定义虚析构函数
class NeighborhoodArgs
{
public:
    virtual ~NeighborhoodArgs() = default;
};

// 抽象邻域基类
class Neighborhood
{
public:
    Neighborhood(Data& d, Parameters& p) : data(d), parameters(p) {}
    virtual ~Neighborhood() = default;

    virtual void move(const NeighborhoodArgs& args) = 0;
    virtual double evaluate(const NeighborhoodArgs& args) = 0;

protected:
    Data& data;
    Parameters& parameters;
};

TwoOpt邻域实现 #

#include "Neighborhood.h"
#include <stdexcept>

class TwoOptArgs : public NeighborhoodArgs
{
public:
    int pos1;
    int pos2;
};

class TwoOptNeighborhood : public Neighborhood
{
public:
    TwoOptNeighborhood(Data& d, Parameters& p) : Neighborhood(d, p) {}

    void move(const NeighborhoodArgs& args) override
    {
        // 动态转换参数类型，失败则抛出异常
        const auto* twoOptArgs = dynamic_cast<const TwoOptArgs*>(&args);
        if (!twoOptArgs)
        {
            throw std::invalid_argument("TwoOptNeighborhood received invalid argument type");
        }
        // 实现具体逻辑
    }

    double evaluate(const NeighborhoodArgs& args) override
    {
        const auto* twoOptArgs = dynamic_cast<const TwoOptArgs*>(&args);
        if (!twoOptArgs)
        {
            throw std::invalid_argument("TwoOptNeighborhood received invalid argument type");
        }
        return 0.0;
    }
};

该方案需运行时类型转换，有一定性能开销，适合需要动态多态的场景。

内容的提问来源于stack exchange，提问作者Lucas Ximenes Guilhon