# Previous review

In [C++ Advanced] Following the TDD principle and implementing the plane vector class (Vec2D) , we have initially implemented the Vec2D content, and now we have made certain improvements:

Realize half of Vec2D binary arithmetic operator overload
1, +-(two Vec2D object operations and one Vec2D object and a double number operation)
2, * (dot multiplication and number multiplication)
At the same time, use the function that involves copying the object to pass The way of reference is modified.
Note that if there is an object copy, you need to pass by reference, if it's just a simple value copy, you don't need to pass by reference.

# Knowledge points

Let's take a look at how we generally call binary operators:
note that the last one is a "wrong" wording, because this is not a member function wording, and z is not an object of the Vec2D class.
But common sense tells us that this way of writing and d should be the same.

```Vec2D a{ 1 , 2 }, b{ 3 , 6 }; double z { 1.3 };

Vec2D c = a + b;   //a.operator+(b);   Vec2D Vec2D::operator+(Vec2D);

Vec2D d = a + z;   //a.operator+(z);   Vec2D Vec2D::operator+(double);

Vec2D e = z + b;   //z.operator+(b);   Vec2D double::operator+(Vec2D); Wrong!
Copy code```

Here are the prototypes of these overloaded functions. Note that the last one is a friend function. If you don t remember the friend function, please review: blog.csdn.net/qq_42604176

```struct  Vec2D {

Vec2D operator +(Vec2D);                 //Member function

Vec2D operator +( double );                //Member function

friend Vec2D operator +( double , Vec2D); //Non-member (friend) function

};

Vec2D operator +( double , Vec2D) { //Do something

}
Copy code```

# Modified part

1. First improve the h file

```# pragma once
# include  <iostream>
# include  <string>
# include  <cmath>
# include  <exception>
class  Vec2D
{
private :
double x_;
double y_;
public :
Vec2D ();
Vec2D ( double , double );
~ Vec2D ();
//Convert a vector to a string representation
std::string toString () ;
Vec2D add ( const Vec2D& secondVec2D) ;
//
Vec2D operator +( const Vec2D& secondVec2D);
Vec2D operator +( const  double num);

double & at ( const  int index) ;
//vector subtraction
Vec2D subtract ( const Vec2D& secondVec2D) ;

//Subtract from the value
Vec2D subtract ( const  double num) ;

Vec2D operator of subtraction function -( const Vec2D& secondVec2D);
Vec2D operator -( const  double num);

//vector dot product
double  dot ( const Vec2D& secondVec2D) ;
//vector number multiplication
Vec2D multiply ( const  double multiplier) ;

double  operator *( const Vec2D& secondVec2D);
Vec2D operator *( const  double multiplier);

friend Vec2D operator *( const  double multiplier,Vec2D vec2d);

//vector negative value
Vec2D negative () ;
//vector self-increase 1
Vec2D& increase () ;
//vector self-decrement 1
Vec2D& decrease () ;
//find the norm (length) of the vector
double  magnitude () ;
//Find the angle between Vec2D and x+axis
double  direction () ;
//Compare the length of the two vectors. If firstVec2D is less than secondVec2D, return -1, if greater than, return 1, if equal, return 0
int  compareTo (Vec2D secondVec2D) ;
};
Copy code```

2. Add the specific details of the function in the cpp file

```# include  "Vec2D.h"
Vec2D:: Vec2D () {
x_ = 0.0 ;
y_ = 0.0 ;
}

Vec2D:: Vec2D ( double x, double y) {
x_ = x;
y_ = y;
}

Vec2D::~ Vec2D () {

}

//Convert the vector to a string representation
std::string Vec2D::toString ()
{
return std:: string ( "(" + std:: to_string (x_) + ", " + std:: to_string (y_) + ")" );
}

Vec2D Vec2D::add ( const Vec2D& secondVec2D)
{
return  Vec2D (x_ + secondVec2D.x_, y_ + secondVec2D.y_);
}
//
{
//TODO: add the implementation code here.
return  Vec2D ( this ->x_ + num, this ->y_ + num);
}

Vec2D Vec2D:: operator +( const Vec2D& secondVec2D)
{
}
Vec2D Vec2D:: operator +( const  double num)
{
}

//Vector subtraction
Vec2D Vec2D::subtract ( const Vec2D& secondVec2D)
{
return  Vec2D (x_-secondVec2D.x_, y_-secondVec2D.y_);
}
//Vector subtraction
Vec2D Vec2D::subtract ( const  double num)
{
return  Vec2D ( this ->x_-num, this ->y_-num);
}

Vec2D Vec2D:: operator -( const Vec2D& secondVec2D)
{
return  this -> subtract (secondVec2D);
}
Vec2D Vec2D:: operator -( const  double num)
{
return  this -> subtract (num);
}

//Vector dot product
double  Vec2D::dot ( const Vec2D& secondVec2D)
{
return (x_ * secondVec2D.x_ + y_ * secondVec2D.y_);
}

//Vector number multiplication
Vec2D Vec2D::multiply ( const  double multiplier)
{
return  Vec2D (x_ * multiplier ,y_ * multiplier);
}

Vec2D Vec2D:: operator *( const  double num)
{
return  this -> multiply (num);
}
double Vec2D:: operator *( const Vec2D& secondVec2D)
{
return  this -> dot (secondVec2D);
}
//Multiplication friend function, not a member function of
Vec2D Vec2D operator *( const  double multiplier,Vec2D vec2d)
{
return vec2d. multiply (multiplier);
}

//Negative vector value
Vec2D Vec2D::negative ()
{
return  Vec2D (-x_, -y_);
}

//Vector increment 1
Vec2D& Vec2D::increase ()
{
x_++;
y_++;
return (* this );
}

//vector decrement 1
Vec2D& Vec2D::decrease ()
{
x_--;
y_--;
return (* this );
}

//Find the norm (length) of the vector
double  Vec2D::magnitude ()
{
return  sqrt (x_ * x_ + y_ * y_);
}

//Find the angle between Vec2D and x+ axis
double  Vec2D::direction ()
{
return  atan (y_/x_);
}

//Compare the length of two vectors. If firstVec2D is less than secondVec2D, return -1, if greater than, return 1, and if equal, return 0
int  Vec2D::compareTo (Vec2D secondVec2D)
{
double m1 = this -> magnitude () ;
double m2 = secondVec2D. magnitude ();
if ( abs (m1-m2) < 1e-10 )
return  0 ;
else
return (m1> m2? 1 : -1 );
}

double & Vec2D::at ( const  int index)
{
if ( 0 == index)
return x_;
else  if ( 1 == index)
return y_;
//use exception handling method, throw An exception
occurs , and the carrying information is printed else
throw std:: out_of_range ( "at() only accept 1 or 2 as parameter" );
//TODO: insert return statement here
}
Copy code```

3. Run the test function

```# include  <iostream>
# include  "Vec2D.h"
using std::cout;
using std::endl;

int  main ()
{
//Create vector object
Vec2D v1{ 3 , 5 }, v2{ 4 , 6 };

//The vector is converted to a string
cout << "v1 = " << v1. toString () << endl;
cout << "v2 = " << v2. toString () << endl;

//Vector addition: vector + vector, vector + number
Vec2D v3 = v1 + v2;
Vec2D v4 = v3 + 10.0 ;

cout << "v3 = " << v3. toString () << endl;
cout << "v4 = " << v4. toString () << endl;

//Vector subtraction, vector dot product, vector number multiplication
//Vec2D v5 = v2.subtract(v1);
//double v6 = v2.dot(v1);//The dot product of two vectors is a number
//Vec2D v7 = v3.multiply(2.1);
Vec2D v5 = v2-v1;
double v6 = v2 * v1;					 //The dot product of two vectors is a number
Vec2D v7 = v3 * 2.1 ;

cout << "v2-v1 = " << v5. toString () << endl;
cout << "v2 * v1 = " << v6 << endl;
cout << "v3 * 2.1 = " << v7. toString () << endl;
cout << "2.1 * v3 = " << ( 2.1 * v3). toString () << endl;		 //Friend function is used here
//vector
negation Vec2D v8 = v2. negative ();
cout << "-v2 = " << v8. toString () << endl;
//vector increment/decrement
cout << " ++v8 = " << v8. increase (). toString () << endl ;
cout << "--v2 =" << v2. decrease (). toString () << endl;