C++ day19 使用类（三）示例矢量类

╰+哭是因爲堅強的太久メ 2023-07-15 13:25 8阅读 0赞

### 文章目录 ###

*  写一个矢量类，巩固类设计，重载运算符和namespace
 *   *  示例1 基本功能 编译器决不能接收任何形式的二义性
     *   *  出现的问题：
         *  做的不错的地方：
     *  示例2 随机游走 Random Walk

# 写一个矢量类，巩固类设计，重载运算符和namespace #

矢量，就是物理上那个术语，有大小有方向，可以用水平分量和垂直分量表示，也可以用模长和角度表示，矢量有效的操作有：加减法以及数乘。所以，很明显，矢量不可能用一个量表示，而是需要用一个类来表示，下面我们尝试设计这个类，并借此巩固名称空间，友元函数，内联函数，访问权限，构造函数，函数重载，运算符重载等知识，还能涉及到一些代码重用的知识。

## 示例1 基本功能 编译器决不能接收任何形式的二义性 ##

//vector.h
    #ifndef VECTOR_H_
    #define VECTOR_H_
    #include <iostream>
    
    namespace VECTOR
    { 
    	class Vector
    	{ 
    	public:
    		enum Mode { RECT, POL};
    	private:
    		double x;
    		double y;
    		double mag;
    		double ang;
    		Mode mode;//rect or polar,所以Mode枚举量要定义在前面
    		void set_x();
    		void set_y();
    		void set_mag();
    		void set_ang();
    	public:
    		Vector();
    		Vector(double n1, double n2, Mode form = RECT);
    		~Vector();
    		void reset(double n1, double n2, Mode form = RECT);//用于给一个Vector对象重新设置值，很好的必需的方法
    		//内联函数
    		double xval() const { return x;}
    		double yval() const { return y;}
    		double magval() const { return mag;}
    		double angval() const { return ang;}
    		void polar_mode();//设置为polar模式
    		void rect_mode();
    		//operator overloading
    		Vector operator+(const Vector & v) const;
    		Vector operator-(const Vector & v) const;
    		Vector operator-() const;//方向取反
    		Vector operator*(double n) const;
    		//friends
    		friend Vector operator*(double n, const Vector & v){ return v * n;}//利用成员运算符函数进行代码重用，设计内联友元函数
    		friend std::ostream & operator<<(std::ostream & os, const Vector & v);
    	};
    }
    
    #endif

//vector.cpp
    #include <iostream>
    #include <cmath>
    #include "vector.h"
    const double RAD_TO_DEG = 180 / 3.141592657;
    
    namespace VECTOR{ 
    	Vector::Vector()
    	{ 
    		x = y = mag = ang = 0.0;
    		mode = RECT;
    	}
    
    	Vector::Vector(double n1, double n2, Mode form)//不要把默认参数写在函数定义中
    	{ 
    		mode = form;
    		if (mode == RECT)
    		{ 
    			x = n1;
    			y = n2;
    			set_mag();//私有函数可以不用对象和成员运算符调用
    			set_ang();
    		}
    		else if(mode == POL)
    		{ 
    			mag = n1;
    			ang = n2;
    			set_x();
    			set_y();
    		}
    		else
    		{ 
    			std::cout << "Wrong mode! Incorrect 3rd argument to Vector() -- ";
    			std::cout << "Vector set to 0.\n";//不能贸然设置为某一个格式，否则输入不匹配
    			Vector();
    		}
    
    
    	}
    
    	Vector::~Vector()
    	{ 
    
    	}
    
    	void Vector::set_x()
    	{ 
    		if (mode == POL)
    			x = mag * std::cos(ang);//在polar模式下设置x
    	}
    
    	void Vector::set_y()
    	{ 
    		if (mode == POL)
    			y = mag * std::sin(ang);//在polar模式下设置y
    	}
    
    
    	void Vector::set_mag()
    	{ 
    		if (mode == RECT)
    			mag = std::sqrt(x * x + y * y);//在rect模式下设置mag
    	}
    
    
    	void Vector::set_ang()
    	{ 
    		if (mode == RECT)
    		{ 
    			if (x==0 && y==0)
    				ang = 0;
    			else
    				ang = std::atan2(y, x);//在rect模式下设置ang
    		}
    	}
    
    
    	void Vector::reset(double n1, double n2, Mode form)
    	{ 
    		//函数体和构造函数一样
    		mode = form;
    		if (mode == RECT)
    		{ 
    			x = n1;
    			y = n2;
    			set_mag();//私有函数可以不用对象和成员运算符调用
    			set_ang();
    		}
    		else if(mode == POL)
    		{ 
    			mag = n1;
    			ang = n2;
    			set_x();
    			set_y();
    		}
    		else
    		{ 
    			std::cout << "Wrong mode! Incorrect 3rd argument to Vector() -- ";
    			std::cout << "Vector set to 0.\n";//不能贸然设置为某一个格式，否则输入不匹配
    			Vector();
    		}
    
    	}
    
    
    	void Vector::polar_mode()//设置为polar模式
    	{ 
    		mode = POL;
    	}
    
    	void Vector::rect_mode()
    	{ 
    		mode = RECT;
    	}
    
    	//operator overloading
    	Vector Vector::operator+(const Vector & v) const
    	{ 
    		//操作数顺序无法反转
    		return Vector(x + v.x, y + v.y);//直接按矩形模式计算，用构造函数生成一个对象返回，注意这里省略了this
    
    		/* //复杂版本，不用构造函数，就要自己写这么大一堆 Vector temp; temp.x = x + v.x; temp.y = y + v.y; temp.mode = RECT; set_mag(temp.x, temp.y); set_ang(temp.x, temp.y); return temp; */
    
    	}
    
    	Vector Vector::operator-(const Vector & v) const
    	{ 
    		//操作数顺序无法反转
    		return 	Vector(x - v.x, y - v.y);
    
    	}
    
    	Vector Vector::operator-() const//方向取反，负号运算符
    	{ 
    		/* //代码虽然多点，但直接对调用对象操作,高效 //但是这里函数是const，即无法修改调用对象，只能新建临时对象 x = -x; y = -y; return *this; */
    		return Vector(-x, -y);//简洁版，但是这需要生成一个临时对象，然后复制出去，有点低效
    	}
    
    	Vector Vector::operator*(double n) const
    	{ 
    		//操作数顺序无法反转
    		return Vector(x * n, y * n);//简洁版
    		/* x *= n; y *= n; return *this; */
    	}
    
    	//friends
    	std::ostream & operator<<(std::ostream & os, const Vector & v)
    	{ 
    	    if (v.mode == Vector::Mode::RECT)
                os << "(x, y) = " << "(" << v.x << ", "  << v.y << ")";
    		else if (v.mode == Vector::Mode::POL)
                os  << "(mag, ang) = " << "(" << v.mag << ", " << v.ang * RAD_TO_DEG << ")";
    		else
                std::cout << "Wrong mode! Incorrect 3rd argument to Vector() -- ";
    
    		return os;
    	}
    
    }

//main.cpp
    #include <iostream>
    #include "vector.h"
    
    int main()
    { 
        using std::cout;
        using std::endl;
    	VECTOR::Vector v1 = VECTOR::Vector();//默认构造函数
    	VECTOR::Vector v2 = VECTOR::Vector(2.0, 3.5);//RECT模式
    	VECTOR::Vector v3 = VECTOR::Vector(3.5, 3.0, VECTOR::Vector::POL);//POL模式
    	VECTOR::Vector v4(1.0, 1.0);
    
    	cout << v1 << endl;
        cout << v2 << endl;
        cout << v3 << endl;
        cout << v4 << endl;
        return 0;
    }

输出

(x, y) = (0, 0)
    (x, y) = (2, 3.5)
    (mag, ang) = (3.5, 171.887)
    (x, y) = (1, 1)

### 出现的问题： ###

*  1 类声明放在名称空间的，但是写类方法定义忘记放在名称空间了
 *  2 忘记在cmath包的数学函数前面加std::
 *  3 我对于怎么写析构函数很茫然，其实这里实例中自己写不写析构函数都行，因为没有用new,析构函数无事可做，和编译器会给的析构函数一样
 *  4 我竟然在友元函数的原型和定义的函数头的最后加了const，可能是努力急着把成员函数不要忘记能设置为const就设置const，导致竟然在友元函数处犯错了。
 *  5 主程序中构造Vector类的对象时，试图用数字1和0作为第三个参数，即mode,可是编译器报错不可以把int转换为VECTOR::Vector::Mode类型
 *  6 友元函数的访问权限不熟悉：在友元函数中直接用了RECT,POL，mode。报错。  
    ![在这里插入图片描述][20200317141007334.png]![在这里插入图片描述][20200317141156260.png]  
    我以为友元函数可以访问私有数据就没问题，但是却忽略了虽然可以访问，但是要加上类限定符，因为友元函数不在类作用域！！  
    正确代码：mode必须用成员运算符访问，而POL和RECT必须用类名限定再用枚举名限定。

std::ostream & operator<<(std::ostream & os, const Vector & v)
    { 
        if (v.mode == Vector::Mode::RECT)
               os << "(x, y) = " << "(" << v.x << ", "  << v.y << ")";
    	else if (v.mode == Vector::Mode::POL)
               os  << "(mag, ang) = " << "(" << v.mag << ", " << v.ang * RAD_TO_DEG << ")\n";
    	else
               std::cout << "Wrong mode! Incorrect 3rd argument to Vector() -- ";
    
    	return os;
    }

*  7 运算符成员函数中我没用构造函数，写了很长的很不优雅的代码；直接调用构造函数又简单又省事，这就叫代码重用

Vector Vector::operator+(const Vector & v) const
    	{ 
    		//操作数顺序无法反转
    		return Vector(x + v.x, y + v.y);//直接按矩形模式计算，用构造函数生成一个对象返回，注意这里省略了this
    		
    		/* //复杂版本，不用构造函数，就要自己写这么大一堆 Vector temp; temp.x = x + v.x; temp.y = y + v.y; temp.mode = RECT; set_mag(temp.x, temp.y); set_ang(temp.x, temp.y); return temp; */
    
    	}

*  8 没有充分重用代码：书上例程把乘法运算符友元函数设计为内联代码，之所以可以只有一句代码是因为它调用了公有成员函数的乘法运算符函数，那个函数限制了操作数顺序但功能没问题呀，所以用友元函数突破操作数顺序限制时可以直接利用那个函数的代码。  
    但是需要注意：千万不要把友元函数的参数顺序写为

friend Vector operator*(const Vector & v, double n){ return v * n;}

因为这样的话，和成员函数Vector operator\*(double n) const;的参数顺序一样，编译器会报错，模糊的重载，编译器决不能接收任何形式的二义性：  
![在这里插入图片描述][20200317150337832.png]  
所以要把参数顺序写为：

//利用成员运算符函数进行代码重用，设计内联友元函数
    friend Vector operator*(double n, const Vector & v){ return v * n;}

这样就不是模糊重载了，就不会报错，小小的一个细节，参数的顺序，就可能导致模糊重载哦，必须细心。  
从这一点也可以看出，类的成员方法的实际参数总是比圆括号里的多一个，那就是this指针指向的调用对象，对于编译器来说调用对象是实实在在的第一个参数。

我之前自己写的友元函数定义：

Vector operator*(const Vector & v, double n)
    	{ 
    		return Vector(v.x * n, v.y * n);
    	}

成员函数定义：

Vector Vector::operator*(double n) const
    	{ 
    		//操作数顺序无法反转
    		return Vector(x * n, y * n);//简洁版
    		/* //复杂版，且需要函数为非const成员函数 x *= n; y *= n; return *this; */
    	}

可以看到两个函数定义几乎一样的，重用多好

### 做的不错的地方： ###

*  在set\_x等四个私有函数中加了if，判断mode正确才设置值
 *  非默认构造函数中考虑了用户输入0，1以外的数字导致没有匹配模式，输出错误。不过书上的处理比我的好
 *  默认构造函数使用了多重赋值运算符
 *  在显示度数时把弧度制转换为了角度制。
 *  弄明白了调用成员函数且需要修改和返回调用对象时，用构造函数新建临时对象和直接操作调用对象的区别：前者低效一点，因为要把临时对象复制出去，但是可以把函数设置为const成员函数；后者相反，更高效一点，但不能设置为const成员函数

## 示例2 随机游走 Random Walk ##

![在这里插入图片描述][20200317170753164.png]  
程序方面不多说了，都在注释里

//main.cpp
    #include <iostream>
    #include <ctime>
    #include <cstdlib>
    #include "vector.h"
    typedef unsigned int uint;
    void eatline();
    
    int main()
    { 
    	double target;//随机漫步的目标距离
        double stepLen;//步长
        uint steps;//步数
        uint direction;
        VECTOR::Vector result = VECTOR::Vector();//每一步走完的位置
        //注意构造函数调用不要累赘地加类名限定，因为构造函数名和类名一样，不要写成VECTOR::Vector::Vector();
        VECTOR::Vector step = VECTOR::Vector(0.0, 0.0, VECTOR::Vector::Mode::POL);//每一步
    
        srand(time(0));//设置随机数种子
    
        //读取目标距离
    	std::cout << "Enter target distance (q to quit): ";
    	while (!(std::cin >> target))
        { 
            char ch;
            //一定要加这句！！！找了好久问题，因为输入字符使得上面读取到target失败，cin会有错误标记
            //再读会读到-1即文件结尾标志
            std::cin.clear();
            while ((ch = std::cin.get()) != 'q' && ch != 'Q')
            { 
                eatline();
                std::cout << "Enter q to quit:\n";
            }
    
        }
        eatline();
    
        //读取步长
        std::cout << "Enter step length: ";
        while (!(std::cin >> stepLen))
        { 
            std::cin.clear();
            eatline();
            std::cout << "Enter step length: ";
        }
        eatline();
    
        steps = 0;
        while (result.magval() < target)//不要写为while (result.mag < target),因为mag是私有成员，只能通过公有接口访问
        { 
            direction = rand() % 360;//0-359
            step.VECTOR::Vector::reset(stepLen, direction, VECTOR::Vector::Mode::POL);
            result = result + step;//不要用+=，没有对Vector类定义
            ++steps;
        }
        std::cout << "After " << steps << " steps, the subject has the following location:\n";
        std::cout << result << '\n' << "or\n";
        result.VECTOR::Vector::polar_mode();
        std::cout << result << '\n';
        std::cout << "Average outward distance per step = " << double(target / steps) << '\n';
        result.VECTOR::Vector::reset(0.0, 0.0);
    
        std::cout << "\nEnter target distance (q to quit): ";
    
    	return 0;
    }

为了循环输入目标距离使得程序可以多次工作，只能设计为：如果target读取失败就退出程序。即无法双全，无法让target和stepLen的读取都用while确保正确，必须舍掉target。

在保证stepLen 输入正确的while中，一定要先处理错误输入，然后处理正确输入，顺序不能反。

而target既然不准备循环保证一定输入正确的target，那就先处理正确输入，即我们主要要做的事情，然后处理错误输入，即退出程序。

//main.cpp
    #include <iostream>
    #include <ctime>
    #include <cstdlib>
    #include "vector.h"
    typedef unsigned int uint;
    void eatline();
    
    int main()
    { 
    	double target;//随机漫步的目标距离
        double stepLen;//步长
        uint steps;//步数
        uint direction;
        VECTOR::Vector result = VECTOR::Vector();//每一步走完的位置
        //注意构造函数调用不要累赘地加类名限定，因为构造函数名和类名一样，不要写成VECTOR::Vector::Vector();
        VECTOR::Vector step = VECTOR::Vector(0.0, 0.0, VECTOR::Vector::Mode::POL);//每一步
    
        srand(time(0));//设置随机数种子
    
        //读取目标距离
    	std::cout << "Enter target distance (q to quit): ";
    	while (std::cin >> target)
        { 
            eatline();
            //读取步长
            std::cout << "Enter step length: ";
            while (!(std::cin >> stepLen))
            { 
                std::cin.clear();
                eatline();
                std::cout << "Enter step length: ";
            }
            eatline();
    
            steps = 0;
            while (result.magval() < target)//不要写为while (result.mag < target),因为mag是私有成员，只能通过公有接口访问
            { 
                direction = rand() % 360;//0-359
                step.VECTOR::Vector::reset(stepLen, direction, VECTOR::Vector::Mode::POL);
                result = result + step;//不要用+=，没有对Vector类定义
                ++steps;
            }
            std::cout << "After " << steps << " steps, the subject has the following location:\n";
            std::cout << result << '\n' << "or\n";
            result.VECTOR::Vector::polar_mode();
            std::cout << result << '\n';
            std::cout << "Average outward distance per step = " << double(target / steps) << '\n';
            result.VECTOR::Vector::reset(0.0, 0.0);
    
            std::cout << "\nEnter target distance (q to quit): ";
        }
    
        char ch;
        //一定要加这句！！！找了好久问题，因为输入字符使得上面读取到target失败，cin会有错误标记
        //再读会读到-1即文件结尾标志
        std::cin.clear();
        while ((ch = std::cin.get()) != 'q' && ch != 'Q')
        { 
            eatline();
            std::cout << "Enter q to quit:\n";
        }
    	return 0;
    }

我在上面的主程序的尾巴上加了点东西，保证按q退出。虽不是什么了不得的事，但我还是觉得按提示来比较好。注意一定要在读取错误后首先清除错误标记再重新读取，不然只会读取到文件结尾标志-1，这是调试发现的。

注意主程序中名称空间的类名限定的使用！！！也可以直接写一句using VECTOR::Vector,这样主程序的所有VECTOR::Vector::全部可以去掉了(但是Mode前面还是要写Vector::的)，我只是为了熟悉，加强印象故意这么写的。  
用using指令的主程序版本：

//main.cpp
    #include <iostream>
    #include <ctime>
    #include <cstdlib>
    #include "vector.h"
    typedef unsigned int uint;
    void eatline();
    
    int main()
    { 
        using VECTOR::Vector;
    	double target;//随机漫步的目标距离
        double stepLen;//步长
        uint steps;//步数
        uint direction;
        Vector result = Vector();//每一步走完的位置
        //注意构造函数调用不要累赘地加类名限定，因为构造函数名和类名一样，不要写成VECTOR::Vector::Vector();
        Vector step = Vector(0.0, 0.0, Vector::Mode::POL);//每一步
    
        srand(time(0));//设置随机数种子，time(0)返回当前系统时间，是秒数，把这个秒数作为产生随机数的新种子
        //实际上，time函数的参数是time_t类型，使用0就可以不自己声明一个time_t类型的变量了，因为0这个数字很奇怪，编译器觉得他是什么类型都行，所以不报错，但是你输入1就不行了，编译器报错不能把int转换为time_t类型，0还是很牛逼的
    
        //读取目标距离
    	std::cout << "Enter target distance (q to quit): ";
    	while (std::cin >> target)
        { 
            eatline();
            //读取步长
            std::cout << "Enter step length: ";
            while (!(std::cin >> stepLen))
            { 
                std::cin.clear();
                eatline();
                std::cout << "Enter step length: ";
            }
            eatline();
    
            steps = 0;
            while (result.magval() < target)//不要写为while (result.mag < target),因为mag是私有成员，只能通过公有接口访问
            { 
                direction = rand() % 360;//0-359
                step.reset(stepLen, direction, Vector::Mode::POL);
                result = result + step;//不要用+=，没有对Vector类定义
                ++steps;
            }
            std::cout << "After " << steps << " steps, the subject has the following location:\n";
            std::cout << result << '\n' << "or\n";
            result.polar_mode();
            std::cout << result << '\n';
            std::cout << "Average outward distance per step = " << double(target / steps) << '\n';
            result.reset(0.0, 0.0);
    
            std::cout << "\nEnter target distance (q to quit): ";
        }
    
        char ch;
        //一定要加这句！！！找了好久问题，因为输入字符使得上面读取到target失败，cin会有错误标记
        //再读会读到-1即文件结尾标志
        std::cin.clear();
        while ((ch = std::cin.get()) != 'q' && ch != 'Q')
        { 
            eatline();
            std::cout << "Enter q to quit:\n";
        }
    	return 0;
    }

vector.cpp中加了一个函数，用于读取输入缓冲区剩余字符。没加在名称空间中，且其原型也写在main.cpp中的

void eatline()
    { 
    	while (std::cin.get() != '\n')
    			;
    }

Enter target distance (q to quit): 50
    Enter step length: 1
    After 1534 steps, the subject has the following location:
    (x, y) = (36.8634, 34.9542)
    or
    (mag, ang) = (50.8007, 43.4772)
    Average outward distance per step = 0.0325945
    
    Enter target distance (q to quit): 50
    Enter step length: 1
    After 1684 steps, the subject has the following location:
    (x, y) = (45.0455, 23.8093)
    or
    (mag, ang) = (50.9508, 27.8592)
    Average outward distance per step = 0.0296912
    
    Enter target distance (q to quit): 50
    Enter step length: 1
    After 2982 steps, the subject has the following location:
    (x, y) = (50.6607, -0.916762)
    or
    (mag, ang) = (50.669, -1.03672)
    Average outward distance per step = 0.0167673
    
    Enter target distance (q to quit): p
    Enter q to quit:
    q

[20200317141007334.png]: https://img-blog.csdnimg.cn/20200317141007334.png
[20200317141156260.png]: /images/20230528/c23f38e46d7f4b348d556dce8059e89c.png
[20200317150337832.png]: /images/20230528/2913b84f0142492cab3e6700e1e3add3.png
[20200317170753164.png]: /images/20230528/2cbe5053155f496b8a53e5d67df54817.png