结构属性运算符重载

Question

I'm writing a game in C++ for my Arduino and I've recently found the joys of operator overloading in structs. So far so good! I'm now stuck on the syntax to overload operators on properties. I want to implement something like this so that if my x or y values increase over the screen width I wrap the value back to 0. Many thanks!

// My guess :(
x& operator++(x &newx, int){
    if (x == SCREEN_WIDTH - 1)
        return 0;
    else
        return x + 1;
}

My struct definition is:

struct point_t
{
    uint8_t x;
    uint8_t y;
    x& operator++(x &newx, int){
        if (x == SCREEN_WIDTH - 1)
            return 0;
        else
            return x + 1;
    }
    point_t& operator=(const point_t &p)
    {
        x = p.x;
        y = p.y;
        return *this;
    }
    bool operator==(const point_t &p) const
    {
        return (x == p.x && y == p.y);
    }
    bool operator!=(const point_t &p) const
    {
        return !(x == p.x && y == p.y);
    }
};

Answer 1

You can't do this exactly as written. The return type of operator should be type .

What you can do is to create a new type, say coordinate , overload operator++ for it, and have your x (and y ) have coordinate type, not uint8_t .

Possible solution (based on code by @MrMase):

template<uint8_t MAX>
class coordinate_t
{
    private:
        int8_t _p;
    public:
        coordinate_t(int8_t p = 0): _p(p) {}

        // Postfix ++
        coordinate_t operator++(int)  
        {
            coordinate_t p(_p);
            ++_p;
            if (_p > MAX - 1)
                _p = 0;
            return p;
        }

        // Postfix --
        coordinate_t operator--(int)  
        {
            coordinate_t p(_p);
            --_p;
            if (_p < 0)
                _p = MAX - 1;
            return p;
        }

        int get() const {return _p;}
};

typedef coordinate_t<SCREEN_WIDTH> xcoordinate_t;
typedef coordinate_t<SCREEN_HEIGHT> ycoordinate_t;

I've made it a template to allow for a simple typedef to define different coordinates; you might also have made MAX a private field and subclass it for different coordinates. In fact, it seems that the template solution is more safe, as it will not allow you to mix different coordinates; however, you might want to reconsider this based on your actual usage.

See full example: http://coliru.stacked-crooked.com/a/5a34261310d05a54

Answer 2

When overloading unary operators (operators with only a single operand, like the increase/decrease operators ++ and -- ) as member functions, they don't have an argument since they are performed on this . The exceptions being the dummy int arguments for the postfix increase/decrease operators.

The returned value differs depending on which operator you overload, but generally for unary operator you return a reference to object, ie *this .

Example

struct point_t
{
    int x;

    // Prefix increase operator
    point_t& operator++()
    {
        ++x;
        return *this;
    }

    // Postfix increase operator
    point_t operator++(int)
    {
        point_t old(*this);  // Create new object using copy-constructor
        operator++();  // Call prefix operator++ on `this`
        return old;  // Return old value, before increment
    }

    ...
};

It's all documented in this operator overloading reference , as well as plenty of tutorials all over the Internet.

---

On an unrelated note, that operator!= can be implemented by using the == operator that you have already implemented:

bool operator!=(const point_t& p) const
{
    return !(*this == p);
}

It's always a good idea to use existing operators when creating related operator overloads.

Answer 3

It seems it's not possible to overload a property of an enum so I'm going to do the next best thing: create a new type called xcordinate and overload the ++operator

Thanks very much to everyone who helped. I'm grateful! :)