每日打卡-10

一.问题描述

线性代数里面我们学习过n维向量，请用类vector_N来封装n维整型向量，成员如下；

私有数据成员:

• 向量维数n， int型
• 指针 p，int型

公有函数成员:

• 无参默认构造函数，在该函数中，将n置0，将p置null;
• 重载输入输出运算符，输入运算符，先指定向量维数，若输入为非正整数，则提示错误信息，“Error Length!”然后退出程序，若维数输入正确则分配长度为n的动态内存，并用指针p指向该内存，输出运算符依次输出向量各元素即可；
• 重载向量的加法+、减法-、数乘*（乘数在前，乘数为int型）这三运算符；
• 重载[]运算，例如，向量a=(1,2,3,4)，a[0]的值为1，若下标越界，则输出“Error Index”，然后退出程序；
• 返回向量维数的函数；
• 将两个向量的内积运算定义为vector_N的友元函数；

  在主函数中定义两个vector_N类对象v1，v2，均不带参数，之后对两个对象进行输入赋值，输入数乘运算的乘数，输入待取元素的下标，对两个向量进行加、减、数乘和内积运算，并将结果输出，输出v1中对应下标对应的元素。加法、减法和内积运算先判断两向量维数是否一致，若一致则输出运算结果，否则输出错误提示信息“Mismatch Length!”

  提示：

1.此类需要用到动态内存的分配，所以在析构函数中应释放空间，并将指针置null，将维数n置0

2.需要显式定义复制构造函数vector_N(vector_N &)

3.需要重载复制运算符 vector_N operator= (vector_N &)

4.退出程序用函数 _exit(0)

5.返回值类型需要为引用的形式，另一方面，在使用时就要考虑不能返回临时变量的引用

二.设计思路

按照题目所属写出对应代码即可

三.流程图

四.伪代码 

1

五.代码实现 

#include<iostream>
using namespace std;
class vector {
private:
	int n;
	int* p;
public:

	//构造函数和析构函数
	vector():n(0),p(NULL){}
	vector(int n) : n(n) { p = new int[n]; }
	vector(vector& v) : n(v.n) { p = new int[n]; for (int i = 0; i < n; i++) p[i] = v.p[i]; }
	~vector() {delete p;  p = NULL;  n = 0; }


	//重载等于运算符
	vector& operator=(const vector& v) { 
		if (p != v.p) { delete[] p; n = v.n; p = new int[n]; for (int i = 0; i < n; i++) p[i] = v.p[i]; } 
		return *this; 
	}
	

	//重载输入输出
	friend istream& operator>>(istream& in, vector& v) {
		in >> v.n;
		if (v.n < 0) { 
			cout << "Error Length1"<<endl; 
			exit(0); 
		}
		v.p = new int[v.n];
		for (int i = 0; i < v.n; i++) in >> v.p[i];
		return in;
	}
	friend ostream& operator<<(ostream& out, vector& v) {
		out << "(";
		for (int i = 0; i < v.n; i++) {
			out << v.p[i];
			if (i < v.n - 1) out << ", ";
		}
		out << ")";
		return out;
	}


	//重载加减数乘内积
	friend vector operator+(const vector& v1, const vector& v2) {
		if (v1.n != v2.n) { cout << "Mismatch Length!" << endl; _exit(0); }
		vector res(v1.n);
		for (int i = 0; i < v1.n; i++) res.p[i] = v1.p[i] + v2.p[i];
		return res;
	}
	friend vector operator-(const vector& v1, const vector& v2) {
		if (v1.n != v2.n) { cout << "Mismatch Length!" << endl; _exit(0); }
		vector res(v1.n);
		for (int i = 0; i < v1.n; i++) res.p[i] = v1.p[i] - v2.p[i];
		return res;
	}
	friend vector operator*(const int s, const vector& v1) {
		vector res(v1.n);
		for (int i = 0; i < v1.n; i++) res.p[i] = v1.p[i] * s;
		return res;
	}
	friend int operator*(const vector v1, const vector v2) {
		if (v1.n != v2.n) { cout << "Mismatch Length!" << endl; _exit(0); }
		int res=0;
		for (int i = 0; i < v1.n; i++) res += v1.p[i] * v2.p[i];
		return res;
	}

	//重载[]运算符
	int& operator[](const int i) {
		if (i < 0 || i >= n) { cout << "Error Index" << endl; _exit(0); }
		return p[i];
	}

	void getn() {
		cout << n;
	}
	void show(int s) {
		cout << p[s];
	}
};
int main() {
	vector v1, v2, v3;
	int s, idx;
	cin >> v1 >> v2;
	cin >> s >> idx;
	v3 = v1 + v2;
	cout << v3 << endl;
	v3 = v1 - v2;
	cout << v3 << endl;
	cout << v1 * v2 << endl;
	v3 =5* v1 ;
	cout << v3 << endl;
	cout << v1[idx];
}