面向对象编程中多表示数学对象的合理建模问询——以椭圆为例

背景 #

椭圆存在两种常见的数学表示形式：

• 一种是通过**中心点坐标(x0,y0)、长短半轴(a,b)及倾斜角(phi)**定义；
• 另一种是通过圆锥曲线系数(A,B,C,D,E,F)，由方程 Ax²+Bxy+Cy²+Dx+Ey+F=0 定义。

针对这两种表示，以下是两种面向对象建模方案，以及对应的分析和选择建议。

两种建模方案 #

方案一：单一Ellipse类维护两种表示 #

定义一个统一的Ellipse类，同时存储两种表示形式的结构数据，并实现相互转换方法，代码如下：

struct EllipseCenterSemiAxisTilt {
    // 中心点坐标
    double x0;
    double y0;

    // 长短半轴
    double a;
    double b;

    // 倾斜角
    double phi;
};

struct EllipseConicCoeff
{
    // 圆锥曲线通用方程：ax² + 2bx + cy² + 2dx + 2fy + g = 0
    double a;
    double b;
    double c;
    double d;
    double f;
    double g;
};

class Ellipse
{
public:
    Ellipse(EllipseCenterSemiAxisTilt centerSemiAxisTilt) 
        : m_centerSemiAxisTilt(centerSemiAxisTilt), 
          m_ConicCoeff(CenterSemiAxisTiltToConicCoeff(centerSemiAxisTilt)) {}
    Ellipse(EllipseConicCoeff ConicCoeff) 
        : m_centerSemiAxisTilt(ConicCoeffToCenterSemiAxisTilt(ConicCoeff)), 
          m_ConicCoeff(ConicCoeff){}

    EllipseConicCoeff CenterSemiAxisTiltToConicCoeff(EllipseCenterSemiAxisTilt CenterSemiAxisTilt);
    EllipseCenterSemiAxisTilt ConicCoeffToCenterSemiAxisTilt(EllipseConicCoeff ConicCoeff);
private:
    EllipseCenterSemiAxisTilt m_centerSemiAxisTilt;
    EllipseConicCoeff m_ConicCoeff;
};

该方案的核心是无论用户用哪种形式创建椭圆，类内部同时维护两种表示，但可能存在存储冗余。

方案二：基类+派生类分表示实现 #

定义一个抽象基类EllipseClass，再针对两种表示形式分别创建派生类，代码如下：

struct EllipseCenterSemiAxisTilt {
    // 中心点坐标
    double x0;
    double y0;

    // 长短半轴
    double a;
    double b;

    // 倾斜角
    double phi;
};

struct EllipseConicCoeff
{
    // 圆锥曲线通用方程：ax² + 2bx + cy² + 2dx + 2fy + g = 0
    double a;
    double b;
    double c;
    double d;
    double f;
    double g;
};

class EllipseClass
{
    // 抽象基类，可定义椭圆通用操作的纯虚函数
};

class EllipseClassConicCoeff : public EllipseClass
{
public:
    EllipseClassConicCoeff(EllipseConicCoeff conicCoeff) : m_conicCoeff(conicCoeff) {}
private:
    EllipseConicCoeff m_conicCoeff;
};

class EllipseClassCenterSemiAxisTilt : public EllipseClass
{
public:
    EllipseClassCenterSemiAxisTilt(EllipseCenterSemiAxisTilt CenterSemiAxisTilt) 
        : m_CenterSemiAxisTilt(CenterSemiAxisTilt) {}
private:
    EllipseCenterSemiAxisTilt m_CenterSemiAxisTilt;
};

该方案的核心是每种表示形式对应一个派生类，仅存储自身需要的数据，避免冗余，但需要处理多态性问题。

方案分析与选择建议 #

方案一的优缺点 #

• 优点：封装性强，用户无需关心转换细节，对外只需要和Ellipse类交互；当需要使用不同表示形式的操作时（比如用圆锥曲线方程判断点是否在椭圆内，用中心半轴形式计算顶点坐标），可以直接调用，无需临时转换，性能更优。
• 缺点：存在固定的存储冗余，即使场景中只需要一种表示形式，也会同时存储两种；另外转换过程可能带来精度损失，来回多次转换时问题更明显。

方案二的优缺点 #

• 优点：按需存储，仅保留当前表示形式的数据，内存占用更优；派生类职责单一，各自专注自身表示的逻辑。
• 缺点：原代码中的基类为空，缺乏统一接口，导致后续实现椭圆通用操作（如判断点是否在椭圆内、绘制椭圆）时，需要为每个派生类重复编写代码；如果需要在两种表示间转换，用户需要显式处理，易用性较差。若要解决这个问题，需在基类中定义纯虚函数（如bool isPointInside(double x, double y)），让派生类实现，增加了设计复杂度。

选择建议 #

1. 优先考虑优化后的方案一（延迟转换）：
   如果场景中需要在两种表示间切换，或者不确定后续操作会用到哪种形式，推荐对方案一做延迟转换优化——仅存储初始的表示形式，当需要另一种形式时才计算并缓存，兼顾内存占用和易用性：

   struct EllipseCenterSemiAxisTilt {
       double x0;
       double y0;
       double a;
       double b;
       double phi;
   };
   
   struct EllipseConicCoeff {
       double a;
       double b;
       double c;
       double d;
       double f;
       double g;
   };
   
   class Ellipse
   {
   public:
       Ellipse(EllipseCenterSemiAxisTilt centerSemiAxisTilt) 
           : m_centerForm(centerSemiAxisTilt), m_hasCenterForm(true), m_hasConicForm(false) {}
       Ellipse(EllipseConicCoeff conicCoeff) 
           : m_conicForm(conicCoeff), m_hasCenterForm(false), m_hasConicForm(true) {}
   
       // 获取中心半轴形式，按需转换
       const EllipseCenterSemiAxisTilt& getCenterForm() {
           if (!m_hasCenterForm) {
               m_centerForm = ConicCoeffToCenterSemiAxisTilt(m_conicForm);
               m_hasCenterForm = true;
           }
           return m_centerForm;
       }
   
       // 获取圆锥曲线系数形式，按需转换
       const EllipseConicCoeff& getConicForm() {
           if (!m_hasConicForm) {
               m_conicForm = CenterSemiAxisTiltToConicCoeff(m_centerForm);
               m_hasConicForm = true;
           }
           return m_conicForm;
       }
   
   private:
       EllipseCenterSemiAxisTilt m_centerForm;
       EllipseConicCoeff m_conicForm;
       bool m_hasCenterForm;
       bool m_hasConicForm;
   
       // 转换实现函数
       EllipseConicCoeff CenterSemiAxisTiltToConicCoeff(EllipseCenterSemiAxisTilt centerForm);
       EllipseCenterSemiAxisTilt ConicCoeffToCenterSemiAxisTilt(EllipseConicCoeff conicForm);
   };
   

2. 选择方案二的场景：
   如果你的业务场景非常单一，绝大多数操作只用到其中一种表示形式，且对内存占用敏感，可以选择方案二，但必须完善基类的抽象接口，定义椭圆的通用操作作为纯虚函数，让派生类各自实现，保证多态性，避免代码重复。

类似场景参考 #

这种多表示形式的数学对象（比如复数的直角坐标/极坐标表示），核心设计原则是平衡易用性、性能和内存占用，优先保证对外接口的简洁性，再根据实际场景优化内部存储逻辑。

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