Overloading operators in derived class

Must I need to redefine all the overloading operators with derived type if I require to use them in derived class?

The following code compiles fine:

class Point {

public:

    Point(int X = 0, int Y = 0):x(X), y(Y) {}

    virtual ~Point() {}

    Point operator +(Point &rhs) {
        return Point(x + rhs.x, y + rhs.y);
    }

protected:
    int x, y;
};

class Vector : public Point {

public:

    Vector(int X, int Y) : Point(X, Y) {}

    ~Vector() {}

    Vector operator +(Vector &rhs) {
        return Vector(x + rhs.x, y + rhs.y);
    }
};

int main()
{
    Vector v1(1, 2);
    Vector v2(3, 2);

    Vector v3 = v2 + v1;
}

But from what I've read,

C++ Primer 4th Ed. Section 15.5.3.

If a derived class wants to make all the overloaded versions available through its type, then it must either redefine all of them or none of them.

Does the part of the quote "none of them" make any sense here?