Inherent Circular Dependency C++ Vertex and Vectors

Question

I have two classes, a vertex and a vector, I am trying to use operators to make life simpler. If you'll examine the vector and vertex classes presented below I'm trying to implement operators in both vertex and vector.

For example VertexA+VertexB = VectorC //Isn't used that much...

VertexA-VertexB = VectorC //Could be used very frequently

VertexA+VectorB = VertexC //Could be used very frequently

VertexA-VectorB = VertexC //Could be used very frequently

VectorA+VectorB = VectorC //used

VectorA-VectorB = VectorC //used

VectorA+VertexB = VertexC //used

VectorA-VertexB = VertexC //used

If you'll notice there is a circular dependency. In order for the operators of one class to return by value( not by reference or pointer)

I know one work around, express vertexes just as vectors. However I was wondering if there was a different solution because I like the two different classes just for clarity.

#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;
    }
};

A vertex is a position in space represented by a vector starting at the origin. Many librairies define only one type as they behave the same way. Do you have any particular reason for needing both? — anthonyvd, Jul 02 '13 at 20:32
I don't understand why you want to add Vertex to Vector and vice-versa. — crowder, Jul 02 '13 at 20:37
You seem to have this working by means of forward declaration. Are you looking for a third solution? — Beta, Jul 02 '13 at 20:39
Perhaps `typedef Vector Vertex` if you want clarity without the extra complexity. — Aurelius, Jul 02 '13 at 20:40
http://stackoverflow.com/questions/553682/when-to-use-forward-declaration — catscradle, Jul 02 '13 at 20:41
If you don't want the circular dependency, why not defining your operators like this: `Vector operator+(const Vertex& left, const Vertex& right)`? — Taylor Brandstetter, Jul 02 '13 at 21:33
Adding two `Vertex` objects and getting a `Vector` doesn't make as much sense mathematically as the other operations. — aschepler, Jul 03 '13 at 02:34
@crowder its just geometry, I can focus more on the theory. C=A+B is more intuitive at first glance then C=add(A,B); — user1659134, Jul 03 '13 at 02:56
@Beta Forward declaration was working, I was being dumb and thought a different issue was being caused by the cyclic dependency. — user1659134, Jul 03 '13 at 02:57
@Aurelius That could also work but with typedef I would have access to dot and cross product from vertex and that wouldn't make sense. — user1659134, Jul 03 '13 at 02:58
@TaylorBrandstetter I didn't know you could declare binary operators... not sure how the compiler understands that — user1659134, Jul 03 '13 at 03:02
@aschepler yeah Vertex+vertex=Vector is strange. I did mention its not very useful. But I put it in there just because. Vector-Vertex is probably not that useful mathematically but again its their for symmetry. — user1659134, Jul 03 '13 at 03:05

Manu343726 · Answer 1 · 2013-07-03T01:24:50.720

To make code of this type of things (Arithmetic data types) easy to write, normally I use a set of templates called "Operator overloading helpers", like Boost operators header. Checkout my implementation.

The advantage of this approach is that the implementation of the operators is coherent (operator+=implementation is coherent with operator+implementation, etc).

In your case, if you only implement Vertex& operator+=(const Vector& other) , Vertex& operator-=(const Vector& other) , Vector& operator+=(const Vector& other) , and Vector& operator-=(const Vector& other); you cover your 3th to 5th cases. How?

Check this code:

//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;
    }
};

Thats all.

Symmetry note: Symmetry property implies that operation a # b its equal to b # a, for a given operator #. Arithmetic helpers uses this feature to provide symmetric operators. For example, matrix algebra: m1 + m2 == m2 + m1, so operator+(const matrix_type_2& m1 , const matrix_type_1& m2) is implemented as m2 + m1 (A call to operator+(const matrix_type_1& m1 , const matrix_type_2& m2)). As you can see, symmetry not works for case 8.

My helpers implementation uses the type of the first parameter as return type of the operator. This is the reason why your other cases are not covered. But that cases implies a conversion from Vector to Vertex or/and viceversa. If you modify the implementation to do that, your all cases could be covered.

Sorry about this, but my forward declaration was working. Turns out I had a different issue which was causing a compiler error that made me think I couldn't do this at all. But it succeeded fine the way it is. — user1659134, Jul 03 '13 at 02:12

score 0 · Answer 2 · answered Jul 03 '13 at 02:13

0

Forward declaration actually solved my problems. The compiling issue I got was because my function signatures didn't match correctly in a not obvious way.

answered Jul 03 '13 at 02:13

user1659134

93
2
7

Inherent Circular Dependency C++ Vertex and Vectors

2 Answers2