Question

我有两个类，一个顶点和一个向量，我试图使用运算符来简化生活。如果你要检查下面给出的向量和顶点类，我试图在顶点和向量中实现运算符。

例如 VertexA + VertexB = VectorC //没用那么多......

VertexA-VertexB = VectorC //可以经常使用

VertexA + VectorB = VertexC //可以经常使用

VertexA-VectorB = VertexC //可以经常使用

VectorA + VectorB = VectorC //使用

VectorA-VectorB = VectorC // used

VectorA + VertexB = VertexC //使用

VectorA-VertexB = VertexC //使用

如果您发现存在循环依赖关系。为了使一个类的运算符按值返回（而不是通过引用或指针）

我知道一个解决方法，将顶点表示为向量。但是我想知道是否有不同的解决方案，因为我喜欢这两个不同的类只是为了清晰。

#ifndef decimal
    #ifdef PRECISION
        #define decimal double
    #else
        #define decimal float
    #endif
#endif
class Vector;
class Vertex{
public:
    decimal x,y;
    const Vertex operator+(const Vector &other);
    const Vertex operator-(const Vector &other);
    const Vector operator+(const Vertex &other);
    const Vector operator-(const Vertex &other);
};

class Vector{
public:
    decimal x,y;
    const Vector operator+(const Vector &other) const {
        Vector result;
        result.x=this->x+other.x;
        result.y=this->y+other.y;
        return result;
    }
    const Vector operator-(const Vector &other) const {
        Vector result;
        result.x=this->x-other.x;
        result.y=this->y-other.y;
        return result;
    }
    const Vertex operator+(const Vertex &other) const {
        Vertex result;
        result.x=this->x+other.x;
        result.y=this->y+other.y;
        return result;
    }
    const Vertex operator-(const Vertex &other) const {
        Vertex result;
        result.x=this->x-other.x;
        result.y=this->y-other.y;
        return result;
    }
    decimal dot(const Vector &other) const{
        return this->x*other.x+this->y*other.y;
    }
    const decimal cross(const Vector &other) const{
        return this->x*other.y-this->y*other.x;
    }
};

Answer 1

为了使这类事物的代码（算术数据类型）易于编写，通常我使用一组称为“运算符重载助手”的模板，如Boost operators header。结帐my implementation。

这种方法的优点是运算符的实现是连贯的（operator+=实现与operator+实现一致，等等。）

在您的情况下，如果您只实施Vertex& operator+=(const Vector& other)，Vertex& operator-=(const Vector& other)，Vector& operator+=(const Vector& other)和Vector& operator-=(const Vector& other);你报了你的第3至第5案件。怎么样？

检查此代码：

//Forward declaration needed:
class Vector;

struct Vertex : public dl32AdditionHelper<Vertex , Vector , true>,      //The last parameter is used to enable operator+ simmetry. That is, this covers cases 3 and 7.
                public dl32SubstractionHelper<Vertex , Vector , false>, //This covers case 4 (Simmetry si not enabled, see note bellow).
{
    float x , y;

    //For Vertex + Vector = Vertex
    Vertex& operator+=(const Vector& other)
    {
        x += other.x;
        y += other.y;

        return *this;
    }

    //For Vertex - Vector = Vertex
    Vertex& operator-=(const Vector& other)
    {
        x += other.x;
        y += other.y;

        return *this;
    }
};

struct Vector : public dl32AdditionHelper<Vector>,     //This covers case 5.
                public dl32SubstractionHelper<Vector>, //This covers case 6.
{
    float x , y;

    //For Vector + Vector = Vector
    Vector& operator+=(const Vector& other)
    {
        x += other.x;
        y += other.y;

        return *this;
    }

    //For Vector - Vector = Vector
    Vector& operator-=(const Vector& other)
    {
        x += other.x;
        y += other.y;

        return *this;
    }
};

多数人。

对称性注释：对称属性意味着对于给定的运算符＃，操作a＃b等于b＃a。算术助手使用此功能来提供对称运算符。例如，矩阵代数：m1 + m2 == m2 + m1，因此operator+(const matrix_type_2& m1 , const matrix_type_1& m2)实现为m2 + m1（对operator+(const matrix_type_1& m1 , const matrix_type_2& m2)的调用）。如您所见，对称性不适用于案例8.

我的帮助器实现使用第一个参数的类型作为运算符的返回类型。这就是为什么你的其他案件没有被涵盖的原因。但是这种情况意味着从Vector转换到Vertex或/和反之亦然。如果您修改实现以执行此操作，则可以涵盖所有情况。

Answer 2

前方声明实际上解决了我的问题。我得到的编译问题是因为我的函数签名没有以一种不明显的方式正确匹配。

固有循环依赖C ++顶点和向量

2 个答案: