Stworzenie nowego obiektu przez przeciążony operator

Witam, mam taki kod:

class Vector2D
{
    public:
        int x;
        int y;

    Vector2D(int x, int y);
    Vector2D(Vector2D &d);
    Vector2D operator!();
};

Vector2D::Vector2D(int x, int y)
 :x(x), y(y) {}

Vector2D::Vector2D(Vector2D &d)
 :x(d.x), y(d.y) {}

Vector2D Vector2D::operator!()
{
    return Vector2D(-this->x, -this->y); // tu jest blad 
}

Ten błąd to:

error: no matching function for call to 'Vector2D::Vector2D(Vector2D)

Chciałem żeby mi to ostatecznie działało w ten sposób:

Vector2D y(1,5);
Vector2D x(!y);

Dzięki z góry za pomoc.

To nie jest błąd w funkcji operator!()!
Kompliator podał wyraźnie dlaczego jest błąd. Brak funkcji Vector2D(Vector2D), ale takiego konstruktora nie da się utworzyć. Można to obejść:

Vector2D y(1,5);
Vector2D neg(0, 0);
neg = !y;
Vector2D x(neg); 

ale niech ręka boska broni przed takim rozwiązaniem!
Po prostu napisz normalny konstruktor kopiujący:

class Vector2D
{
   //...
    Vector2D(const Vector2D &d);
    //...
};
Vector2D::Vector2D(const Vector2D &d)
 :x(d.x), y(d.y) {}
 

Błąd Ci mówi że nie masz odpowiedniego prototypu.

class Vector2D {
public:
	int x;
	int y;
	Vector2D();
	Vector2D(int x, int y);
	Vector2D(const Vector2D& d);
	Vector2D operator!();
	virtual ~Vector2D();
};
Vector2D::Vector2D(): x(0), y(0) {
}

Vector2D::Vector2D(int x, int y) : x(x), y(y){}

Vector2D::Vector2D(const Vector2D& d): x(d.x), y(d.y){
}

Vector2D Vector2D::operator !(){
	return Vector2D(-this->x,-	this->y);
}

Vector2D::~Vector2D() {
}

Działa ślicznie!

Po prostu konstruktor kopiujący skopany ;) Polecam Ksiażkę Meyersa Effective C++, pomoże Ci w zrozumieniu ;)

Wszystko fajnie, pieknie, ale skad sie wzial ten absurdalny pomysl na uzycie operatora negacji logicznej do zanegowania wektora?

Ech, wszysci piszczą na ten operator logiczny (i w sumie dobrze) więc tak powinno być:

class Vector2D {
public:
    int x;
    int y;
    Vector2D();
    Vector2D(int x, int y);
    Vector2D(const Vector2D& d);
    Vector2D operator-();
    virtual ~Vector2D();
};
Vector2D::Vector2D(): x(0), y(0) {
}
 
Vector2D::Vector2D(int x, int y) : x(x), y(y){}
 
Vector2D::Vector2D(const Vector2D& d): x(d.x), y(d.y){
}
 
Vector2D Vector2D::operator -(){
    return Vector2D(-this->x,-this->y);
}
 
Vector2D::~Vector2D() {
}

I taka uwaga: można overloadować !, ale sobie tym strzelić w stope można ;) z resztą jak nie uważasz to strzelić sobie można na multum sposobów... Jak coś ostro skopiesz to demony mogą ci nawet z nosa wyfrunąć ;) http://www.catb.org/jargon/html/N/nasal-demons.html