请求允许对底层结构相同的类型进行隐式转换

这种情况我碰到过好几次——明明底层存储都是一样的std::pair，只是对外的接口名字不同，却要写一堆重复的转换代码，确实闹心。下面给你几个实用的方案，按需选就行：

直接在每个结构体里写接受其他同类结构体的构造函数，直接复用底层的xy成员实现转换：

struct CartesianCoordinates {
    std::pair<double, double> xy;
    
    // 从地理坐标转换过来的构造函数
    CartesianCoordinates(const GeographicCoordinates& geo) 
        : xy(geo.xy) {}

    void x(double val) { xy.first = val; }
    double x() const { return xy.first; }
    void y(double val) { xy.second = val; }
    double y() const { return xy.second; }
};

struct GeographicCoordinates {
    std::pair<double, double> xy;
    
    // 从笛卡尔坐标转换过来的构造函数
    GeographicCoordinates(const CartesianCoordinates& cart) 
        : xy(cart.xy) {}

    void longitude(double val) { xy.first = val; }
    double longitude() const { return xy.first; }
    void latitude(double val) { xy.second = val; }
    double latitude() const { return xy.second; }
};

这样就能直接用隐式转换了：

CartesianCoordinates cart;
cart.x(10.0); cart.y(20.0);
// 隐式转换为地理坐标
GeographicCoordinates geo = cart;

优点是简单直接，缺点是结构体多了之后，要写大量重复的构造函数。

和构造函数思路类似，但换成在结构体里定义转换到其他类型的运算符：

struct CartesianCoordinates {
    std::pair<double, double> xy;
    
    // 转换为地理坐标的运算符
    operator GeographicCoordinates() const {
        GeographicCoordinates geo;
        geo.xy = this->xy;
        return geo;
    }

    // 原有的getter/setter
    void x(double val) { xy.first = val; }
    double x() const { return xy.first; }
    void y(double val) { xy.second = val; }
    double y() const { return xy.second; }
};

struct GeographicCoordinates {
    std::pair<double, double> xy;
    
    // 转换为笛卡尔坐标的运算符
    operator CartesianCoordinates() const {
        CartesianCoordinates cart;
        cart.xy = this->xy;
        return cart;
    }

    // 原有的getter/setter
    void longitude(double val) { xy.first = val; }
    double longitude() const { return xy.first; }
    void latitude(double val) { xy.second = val; }
    double latitude() const { return xy.second; }
};

使用方式和方案1完全一致，区别在于转换的发起逻辑，适合你更关注从当前类型"转出"的场景。

如果你的结构体数量很多，上面两种方式的重复代码会让人崩溃。可以用CRTP（奇异递归模板模式）封装一个通用基类，一次性搞定所有转换逻辑：

template<typename Derived>
struct CoordinateBase {
    std::pair<double, double> xy;

    // 通用转换：支持转换到任意其他CoordinateBase派生类
    template<typename OtherDerived>
    operator OtherDerived() const {
        OtherDerived other;
        other.xy = this->xy;
        return other;
    }

protected:
    // 保护构造函数，避免直接实例化基类
    CoordinateBase() = default;
};

struct CartesianCoordinates : CoordinateBase<CartesianCoordinates> {
    void x(double val) { xy.first = val; }
    double x() const { return xy.first; }
    void y(double val) { xy.second = val; }
    double y() const { return xy.second; }
};

struct GeographicCoordinates : CoordinateBase<GeographicCoordinates> {
    void longitude(double val) { xy.first = val; }
    double longitude() const { return xy.first; }
    void latitude(double val) { xy.second = val; }
    double latitude() const { return xy.second; }
};

这样不管你新增多少个同类型的坐标结构体，都自动支持互相转换，完全不用重复写转换代码，非常适合大规模场景。

• 隐式转换的风险：隐式转换虽然方便，但可能导致意外的类型匹配（比如函数重载时选错版本）。如果担心这个，可以把构造函数或转换运算符声明为explicit，然后用static_cast<GeographicCoordinates>(cart)这种显式转换，安全性更高。
• 私有成员的处理：如果你的xy成员是私有的，记得在基类里提供protected的访问接口（比如std::pair<double, double>& get_xy()），或者给基类加友元声明，确保转换逻辑能访问到底层数据。

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