c5

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

using namespace std;

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

// 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 operator == ( const Wektor3 &w1, const Wektor3 &w2 );
    friend operator != ( const Wektor3 &w1, const Wektor3 &w2 );

    friend istream& operator >> (istream &s, Wektor3 &w);
    friend ostream& operator << (ostream &s, Wektor3 &w);

private:
    double  _x, _y, _z;
};

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

// 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 ! ()
//Do uzupelnienia
{
    return sqrt((_x*_x)+(_y*_y)+(_z*_z));
}
//---------------------------------------------------------

double Wektor3::Azym( void )
{
//Do uzupelnienia
    double a = 0;
    a = _x/(sqrt((_x*_x)+(_y*_y)));
    if(_y >= 0)
    {
        return (acos(a)*(180/M_PI));
    }else
    {
        return -(acos(a)*(180/M_PI));
    }
}
//---------------------------------------------------------

double Wektor3::Elev( void )
//Do uzupelnienia
{
    return (asin((_z)/(((sqrt((_x*_x)+(_y*_y)+(_z*_z)))))))*(180/M_PI);
}
//---------------------------------------------------------

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 tmpw;

        tmpw._x += w1._x + w2._x;
        tmpw._y += w1._y + w2._y;
        tmpw._z += w1._z + w2._z;

    return tmpw;
}
//---------------------------------------------------------

Wektor3 operator * ( double k, const Wektor3 &w )
//Do uzupelnienia
{
    Wektor3 tmpw;

    tmpw._x = k * w._x;
    tmpw._y = k * w._y;
    tmpw._z = k * w._z;

    return tmpw;
}

Wektor3 operator * ( const Wektor3 &w, double k )
//Do uzupelnienia
{
    Wektor3 tmpw;

    tmpw._x = k * w._x;
    tmpw._y = k * w._y;
    tmpw._z = k * w._z;

    return tmpw;
}
//---------------------------------------------------------

operator == ( const Wektor3 &w1, const Wektor3 &w2 )
//Do uzupelnienia
{
    if(w1._x == w2._x && w1._y == w2._y && w1._z == w2._z)
    {
        return true;
    }
    return false;
}
//---------------------------------------------------------

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

// --------------------------------------------------------

istream& operator >> (istream &s, Wektor3 &w)
{
    s >> w._x >> w._y >> w._z;
    return s;
}
// --------------------------------------------------------
ostream& operator << (ostream &s, Wektor3 &w)
{
    s << "(" << w._x << ", " << w._y << ", " << w._z << ")";
    return s;
}
//=========================================================

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