Problem z przeciążaniem operatorów

#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <ostream>

using namespace std;
using std::cout;
using std::cin;

//=========================================================

// Deklaracja klasy Wektor3


class Wektor3
{
   
public:
    Wektor3( void );
    Wektor3( double x, double y, double z );
    Wektor3( const Wektor3 & w );
   
    double X( void ) { return _x; }
    double Y( void ) { return _y; }
    double Z( void ) { return _z; }
   
    Wektor3 & Assign( double x, double y, double z );
    Wektor3 & operator =( const Wektor3 & w );
   
    double operator !( void );
    double Azym( void );
    double Elev( void );
   
    Wektor3 & operator +=( const Wektor3 & w );
    Wektor3 & operator *=( double k );
   
    friend Wektor3 operator +( const Wektor3 & w1, const Wektor3 & w2 );
    friend Wektor3 operator *( double k, const Wektor3 & w );
    friend Wektor3 operator *( const Wektor3 & w, double k );
   
    friend bool operator ==( const Wektor3 & w1, const Wektor3 & w2 );
    friend bool operator !=( const Wektor3 & w1, const Wektor3 & w2 );
   
   
private:
    double _x, _y, _z;
};
ostream operator <<( ostream & s, Wektor3 & w );
istream operator >>( istream & s, Wektor3 & w );

//=========================================================

// Definicje konstruktorow, metod i funkcji zaprzyjaznionych

Wektor3::Wektor3( void )
{
    _x = _y = _z = 0.0;
}
//---------------------------------------------------------

Wektor3::Wektor3( double x, double y, double z )
{
    _x = x; _y = y; _z = z;
}
//---------------------------------------------------------

Wektor3::Wektor3( const Wektor3 & w )
//Do uzupelnienia
{
    _x = w._x;
    _y = w._y;
    _z = w._z;
}
//---------------------------------------------------------

Wektor3 & Wektor3::Assign( double x, double y, double z )
{
    _x = x; _y = y; _z = z;
   
    return * this;
}
//---------------------------------------------------------

Wektor3 & Wektor3::operator =( const Wektor3 & w )
//Do uzupelnienia
{
    _x = w._x;
    _y = w._y;
    _z = w._z;
    return * this;
}
//---------------------------------------------------------

double Wektor3::operator !( void )
//Do uzupelnienia
{
    long double dlugosc;
    dlugosc = sqrt(( _x * _x ) +( _y * _y ) +( _z * _z ) );
    return dlugosc;
}
//---------------------------------------------------------

double Wektor3::Azym( void )
//Do uzupelnienia
{
    double azymut;
    azymut = acos( _x / sqrt(( _x * _x ) +( _y * _y ) ) );
    if( - 180 < azymut && azymut <= 180 )
         return azymut;
   
}
//---------------------------------------------------------

double Wektor3::Elev( void )
//Do uzupelnienia
{
    double elewacja;
    elewacja = asin( _z /( sqrt(( _x * _x ) +( _y * _y ) +( _z * _z ) ) ) );
    if( - 90 <= elewacja && elewacja <= 90 )
         return elewacja;
   
}
//---------------------------------------------------------

Wektor3 & Wektor3::operator +=( const Wektor3 & w )
//Do uzupelnienia
{
    _x += w._x;
    _y += w._y;
    _z += w._z;
    return * this;
}
//---------------------------------------------------------

Wektor3 & Wektor3::operator *=( double k )
//Do uzupelnienia
{
    _x *= k;
    _y *= k;
    _z *= k;
    return * this;
}
//---------------------------------------------------------

Wektor3 operator +( const Wektor3 & w1, const Wektor3 & w2 )
//Do uzupelnienia
{
    Wektor3 suma( w1._x + w2._x, w1._y + w2._y, w1._z + w2._z );
    return suma;
}
//---------------------------------------------------------

Wektor3 operator *( double k, const Wektor3 & w )
//Do uzupelnienia
{
    Wektor3 iloczynliczba(( w._x ) * k,( w._y ) * k,( w._z ) * k );
    return iloczynliczba;
}
//---------------------------------------------------------

Wektor3 operator *( const Wektor3 & w, double k )
//Do uzupelnienia
{
    Wektor3 iloczynliczba( k *( w._x ), k *( w._y ), k *( w._z ) );
    return iloczynliczba;
}
//---------------------------------------------------------

bool operator ==( const Wektor3 & w1, const Wektor3 & w2 )
//Do uzupelnienia
{
    bool wektory_sa_rowne = 0;
    if( w1._x == w2._x && w1._y == w2._y && w1._z == w2._z )
         wektory_sa_rowne = 1;
   
    return wektory_sa_rowne;
}
//---------------------------------------------------------

bool operator !=( const Wektor3 & w1, const Wektor3 & w2 )
//Do uzupelnienia
{
    bool wektory_nie_sa_rowne = 0;
    if( w1._x != w2._x || w1._y != w2._y || w1._z != w2._z )
         wektory_nie_sa_rowne = 1;
   
    return wektory_nie_sa_rowne;
}
//=========================================================

int main( int argc, char * argv[] )
{
    Wektor3 w1( 1, 2, 3 );
    Wektor3 w3, w4, w5;
    double ax, ay, az, k;
   
    cout << "Wektor w3 (x, y, z): ";
   
    // cin >> ax >> ay >> az;
    // w3.Assign( ax, ay, az );
    cin >> w3;
   
    cout << "Wektor w4 (x, y, z): ";
   
    // cin >> ax >> ay >> az;
    // w4.Assign( ax, ay, az );
    cin >> w4;
    cout << "Wspolczynnik k: ";
    cin >> k;
   
    Wektor3 w31( w3 );
   
    cout << fixed << setprecision( 3 ) << endl;
   
    // cout << "Wektor w1 = ( " << w1.X( ) << ", " << w1.Y( ) << ", " << w1.Z( ) << " )" << endl;
    // cout << "Wektor w3 = ( " << w3.X( ) << ", " << w3.Y( ) << ", " << w3.Z( ) << " )" << endl;
    // cout << "Kopia  w3 = ( " << w31.X( ) << ", " << w31.Y( ) << ", " << w31.Z( ) << " )" << endl;
    // cout << "Wektor w4 = ( " << w4.X( ) << ", " << w4.Y( ) << ", " << w4.Z( ) << " )" << endl << endl;
    cout << "Wektor w1 = " << w1 << endl;
    cout << "Wektor w3 = " << w3 << endl;
    cout << "Kopia  w3 = " << w31 << endl;
    cout << "Wektor w4 = " << w4 << endl << endl;
   
    // w5.Assign( w3 );
    // w5.Plus( w4 );
    w5 = w3;
    w5 += w4;
   
    // cout << "Wektor w3+w4 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl;
    cout << "Wektor w3+w4 = " << w5 << endl;
   
    // w5.Assign( Plus( w1, w3 ) );
    w5 = w1 + w3;
   
    // cout << "Wektor w1+w3 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl << endl;
    cout << "Wektor w1+w3 = " << w5 << endl << endl;
   
    // w5.Assign( w3 );
    // w5.Mult( k );
    w5 = w3;
    w5 *= k;
   
    // cout << "Wektor k*w3 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl ;
    cout << "Wektor k*w3 = " << w5 << endl;
   
    // w5.Assign( Mult( k, w4 ) );
    w5 = k * w4;
    // cout << "Wektor k*w4 = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl;
    cout << "Wektor k*w4 = " << w5 << endl;
    w5 = w3 * k;
    // cout << "Wektor w3*k = ( " << w5.X( ) << ", " << w5.Y( ) << ", " << w5.Z( ) << " )" << endl << endl;
    cout << "Wektor w3*k = " << w5 << endl << endl;
   
    // cout << "Modul w3 = " << w3.Mod( ) << endl;
    cout << "Modul w3 = " << !w3 << endl;
   
    cout << "Azymut w3 = " << w3.Azym() << endl;
    cout << "Elewacja w3 = " << w3.Elev() << endl << endl;
   
    // cout << "w3==w4 " << ( Eq( w3, w4 ) ? "tak" : "nie" ) << endl << endl;
    // cout << "w3!=w4 " << ( Neq( w3, w4 ) ? "tak" : "nie" ) << endl << endl;
    cout << "w3==w4 " <<(( w3 == w4 ) ? "tak"
        : "nie" ) << endl << endl;
    cout << "w3!=w4 " <<(( w3 != w4 ) ? "tak"
        : "nie" ) << endl << endl;
   
    return 0;
}