WD—C++课前作业—30题

怎么会手和脚都在桌子上

目录

31,声明一个类 String,其数据成员为 char head[100],构造函数 String(char*Head)实现 head 的初始化,成员函数 void reverse()实现 head 内字符串的逆序存放,成员函数 void print()实现 head 内字符串的输出。

32.定义盒子 Box类,要求具有以下成员:可设置盒子形状;可计算盒子体积;可计算盒子的表面积。

33.声明一个 Tree(树)类,有成员 ages(树龄),成员函数grow(int years)用以对 ages 加上 years,showAge()用以显示 tree 对象的 ages 值。在主函数中定义 Tree 类对象,并调用成员函数(自行指定实参数据)

34.有一个学生类 Student,包括学生姓名、成绩,设计一个友元函数,输出成绩对应的等级:(1)大于等于 90:优;(2)80~90:良;(3)70~79:中;(4)60~69:及格;(5)小于 60:不及格。

35.定义一个复数类,用友元函数实现对双目运算符“+”的运算符重载,使其适用于复数运算。

36.有一个 Time 类,包含数据成员 minute(分)和 sec(秒),模拟秒表,每次走一秒,满 60 秒进一分钟,此时秒又从0开始算。要求输出分和秒的值。(提示:重载单目运算符++)

37.设计一个三角形类 Triangle,包含三角形三条边长的私有数据成员,另有一个重载运算符“+”,以实现求两个三角形对象的面积之和。

38.使用函数重载的方法定义两个重名函数,分别求出整型数的两数之和和浮点数的两数之和,并在主函数中调用。

39.定义一个抽象类 Shape 用以计算面积,从中派生出计算长方形、梯形、圆形面积的派生类。程序中通过基类指针来调用派生类中的虚函数,计算不同形状的面积。

40.定义计数器类 Counter。要求具有以下成员:计数器值;可进行增值和减值记数;可提供记数值。

41.声明一个哺乳动物 Mammal 类,再由此派生出狗 Dog类,二者都定义 speak(成员函数,基类中定义为虚函数。声明一个 Dog类的对象,调用 speak()函数,观察运行结果。

42.编写一个程序计算“三角形、正方形、圆形”三种图形的面积,要求  :a)抽象出一个基类 Base;  b)在其中说明一个虚函数用来求面积;   c)利用派生类定义“三角形、正方形、圆形”;  编写主函数并测试。

C++字符串(std::string)、STL(标准模板库)相关;(这一部分的作业,请参考 C++ Primer5 的练习)

43.编写一段程序,从标准输入中一次读入一整行,存入 std::string 中,然后修改该程序,使其一次读入一个词。(练习3.2)

44.请说明std::string类的输入运算符和 getline函数分别是如何处理空白字符的。(练习3.3)

45.编写一段程序从标准输入中读入多个字符串并将它们连接在一起,输出连接成的大字符串。然后修改上述程序,用空格把输入的多个字符串分隔开来。(练习 3.5)

46.编写一段程序,读入一个包含标点符号的字符串,将标点符号去除后输出字符串剩余的部分。(练习 3. 10)

47.编写一段程序,创建一个含有 10 个整数的 vector 对象,然后使用迭代器将所有元素的值都变成原来的两倍。输出 vector 对象的内容,检验程序是否正确。(练习 3.23)

48.编写一段程序,比较两个 std::string 对象。再编写一段程序,比较两个C风格字符串的内容。(练习3.39)

49.对于下面的程序任务,vector、deque 和 list 哪种容器最为合适?解释你的选择的理由。如果没有哪一种容器优于其他容器,也请解释理由。(练习9.1)(1)读取固定数量的单词,将他们按字典序插入到容器中。(2)读取未知数量的单词,总是将新单词插入到末尾。删除操作在头部进行。(3)从一个文件读取未知数量的整数。将这些数排序,然后将他们打印到标准输出。

50.对6种创建和初始化 vector 对象的方法,每一种都给出一个实例。解释每个 vector 包含什么值。(练习9.11)

51.如何从一个 list初始化一个 vector?从一个 vector又该如何创建?编写代码验证你的答案。(练习9.13)

52.编程程序,将一个 1ist 中的 char*指针(指向C风格字符串)元素赋值给-个vector中的string。(练习9.14) 

53,编写程序,从标准输入读取 string 序列,存入一个 deque 中。编写一个循环,用迭代器打印 deque 中的元素。(练习 9.18)

54.编写程序,从一个 1ist拷贝元素到两个 deque 中,其中值为偶数的所有元素都拷贝到一个 deque 中,而奇数元素都拷贝到另一个 deque 中。(9.20)

​编辑55,假定你希望每次读取一个字符存入一个 std::string 中,而且知道最少需要读取 100个字符,应该如何提高程序的性能?(9.42)

​编辑56.编写一个函数,接受一个表示名字的 std::string 参数和两个分别表示前缀(如“Mr.”或“Ms.”)和后缀(如“Jr.”“III”)的字符串。使用迭代器及insert 和 append 函数将前缀和后缀加到给定的名字中,生成新的 string 并返回。(9.45)

57.定义一个 map,关键字是家庭的姓,值是一个 vector,保存家中孩子(们)的名。编写代码,实现添加新的家庭以及向已有家庭中添加新的孩子。(11.7)

0.1  bug,只有第一个添加人的函数能进入循环

​编辑​编辑0.2 正常的

58,编写一个程序,在一个 vector 而不是一个 set 中保存不重复的单词。使用set的优点是什么?(练习 11.8)

59.可以用什么类型来对一个 map 进行下标操作?下标运算符返回的类型时什么?请给出一个具体例子,即定义一个 map,然后写出一个可以用来对 map 进行下标操作的类型以及下标运算符将会返回的类型。(11.26)

60.用冒泡法对 10 个整数排序。(用 STL 的 vector 容器实现)​​​​​​​

31,声明一个类 String,其数据成员为 char head[100],构造函数 String(char*Head)实现 head 的初始化,成员函数 void reverse()实现 head 内字符串的逆序存放,成员函数 void print()实现 head 内字符串的输出。
#include <iostream>
#include <cstring>
using namespace std;
/*
声明一个类 String,其数据成员为 char head[100]
构造函数 String(char*Head)实现 head 的初始化
成员函数 void reverse()实现 head 内字符串的逆序存放
成员函数 void print()实现 head 内字符串的输出。
*/
class String {
public:
	String(char* Head) {
		strcpy_s(head, sizeof(head), Head);
	}
	void reverse() {
		int len = strlen(head);
		for (int i = 0; i < len / 2; i++) {
			char temp = head[i];
			head[i] = head[len - i - 1];
			head[len - i - 1] = temp;
		}
	}
	void print() {
		cout << head << endl;
	}
	char head[100];
};
void test01() {
	String s(const_cast<char*>("hallo,world"));
	s.print();
	s.reverse();
	s.print();
}
int main() {
	test01();
	system("pause");
	return 0;
}

BUG:在你的代码中,test01 函数中创建 String 对象时,实参类型是 const char* 类型,但是构造函数参数类型是 char*,导致类型不匹配的错误。为了解决这个问题,你可以将构造函数的参数类型改为 const char*,或者在调用构造函数时将实参的类型转换为 char* 

32.定义盒子 Box类,要求具有以下成员:可设置盒子形状;可计算盒子体积;可计算盒子的表面积。
#include <iostream>
#include <string>
using namespace std;
class BOX {
public:
	BOX(int l,int w,int h) {
		m_l = l; m_w = w; m_h = h;
	}
	int gets() {
		return  m_l *m_w *m_h;
	}
	int getv() {
		return 2 * (m_l * m_w + m_l * m_h + m_w * m_h);
	}
	void shape() {
		cout << "BOX的长,宽,高分别为:" << m_l << " " << m_w << " " << m_h << endl;
	}
	int m_l;
	int m_w;
	int m_h;
};
void test01() {
	BOX b1(3, 4, 5);
	b1.shape();
	cout << "体积是:" << b1.getv() << endl;
	cout << "面积是:" << b1.gets() << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

33.声明一个 Tree(树)类,有成员 ages(树龄),成员函数grow(int years)用以对 ages 加上 years,showAge()用以显示 tree 对象的 ages 值。在主函数中定义 Tree 类对象,并调用成员函数(自行指定实参数据)
#include <iostream>
#include <string>
using namespace std;
/*
* 声明一个 Tree(树)类,有成员 ages(树龄)
成员函数grow(int years)用以对 ages 加上 years
showAge()用以显示 tree 对象的 ages 值
在主函数中定义 Tree 类对象,并调用成员函数(自行指定实参数据)
*/
class Tree {
public:
	Tree() {
		ages = 0;
	}
	Tree(int age) {
		this->ages = age;
	}
	void grow(int years) {
		this->ages += years;
	}
	void showAge() {
		cout << "树的年龄为:" << ages << endl;
	}
	int ages;
};
void test01() {
	Tree t1(78);
	t1.showAge();
	t1.grow(200);
	t1.showAge();
}
int main() {
	test01();
	system("pause");
	return 0;
}

34.有一个学生类 Student,包括学生姓名、成绩,设计一个友元函数,输出成绩对应的等级:
(1)大于等于 90:优;(2)80~90:良;(3)70~79:中;(4)60~69:及格;(5)小于 60:不及格。
#include <iostream>
#include <ctime>
using namespace std;
/*
有一个学生类 Student,包括学生姓名、成绩,设计一个友元函数,输出成绩对应的等级:
(1)大于等于 90:优;(2)80~90:良;(3)70~79:中;(4)60~69:及格;(5)小于 60:不及格。
*/
class Student {
	friend void classgrade(Student& s);
public:
	Student(string name, int sc) {
		n_name = name;
		n_score = sc;
	}
	void show() {
		cout << "姓名:" << n_name << "\t成绩:" << n_score << "\t等级:";
	}
private:
	string n_name;
	int n_score;
};
void classgrade(Student& s) {
	int sco = s.n_score / 10;
	switch (sco) {
	case 10:cout << "优" << endl; break;
	case 9:cout << "优" << endl; break;
	case 8:cout << "良" << endl; break;
	case 7:cout << "中" << endl; break;
	case 6:cout << "及格" << endl; break;
	default:cout << "不及格" << endl; break;
	}
}
void test01() {
	srand((unsigned int)time(NULL));
	Student s1("栋栋",rand()%51+50);
	s1.show();
	classgrade(s1);
}
int main() {
	test01();
	system("pause");
	return 0;
}

35.定义一个复数类,用友元函数实现对双目运算符“+”的运算符重载,使其适用于复数运算。
#include <iostream>
#include <ctime>
using namespace std;
/*
.定义一个复数类,用友元函数实现对双目运算符“+”的运算符重载,使其适用于复数运算。
*/
class Complex {
	friend Complex& operator+(Complex& c1, Complex& c2);
public:
	Complex(int a1, int b1) {
		_a = a1;
		_b = b1;
	}
	void show() {
		cout << _a << "+" << _b << "i" << endl;
	}
private:
	int _a;
	int _b;
};
Complex& operator+(Complex& c1, Complex& c2) {
	Complex c(c1._a + c2._a, c1._b + c2._b);
	return c;
}
void test01() {
	Complex c1(3, 5);
	Complex c2(7, 4);
	Complex c3 = c1 + c2;
	c2.show();
	c1.show();
	c3.show();
}
int main() {
	test01();
	system("pause");
	return 0;
}

36.有一个 Time 类,包含数据成员 minute(分)和 sec(秒),模拟秒表,每次走一秒,满 60 秒进一分钟,此时秒又从0开始算。要求输出分和秒的值。(提示:重载单目运算符++)
#include <iostream>
#include <ctime>
using namespace std;
/*
有一个 Time 类,包含数据成员 minute(分)和 sec(秒)
模拟秒表,每次走一秒,满 60 秒进一分钟,此时秒又从0开始算。
要求输出分和秒的值。(提示:重载单目运算符++)
*/
class Time {
public:
	Time(int min,int sce) {
		_min = min;
		_sec = sce;
	}
	void showt() {
		cout << _min << " minute\t" << _sec <<" second" << endl;
	}
	Time& operator++() {//前置
		_sec++;
		if (_sec == 60) {
			_min++;
			_sec = 0;
		}
		return *this;
	}
	Time operator++(int) {//后置
		Time t(this->_min, this->_sec);
		_sec++;
		if (_sec == 60) {
			_min++;
			_sec = 0;
		}
		return t;
	}
private:
	int _min;
	int _sec;
};

void test01() {
	Time t1(3, 59);
	t1.showt();
	(t1++).showt();
	t1.showt();
	(++t1).showt();
	t1.showt();
}
int main() {
	test01();
	system("pause");
	return 0;
}

37.设计一个三角形类 Triangle,包含三角形三条边长的私有数据成员,另有一个重载运算符“+”,以实现求两个三角形对象的面积之和。
#include <iostream>
using namespace std;
/*
设计一个三角形类 Triangle,包含三角形三条边长的私有数据成员
另有一个重载运算符“+”,以实现求两个三角形对象的面积之和。
*/
class Triangle {
public:
	Triangle() {
		_a = _b = _c = 0;
	}
	bool ist(int a, int b, int c) {
		return a < (b + c) && b < (a + c) && c < (a + b);
	}
	Triangle(int a, int b, int c) {
		if (ist(a,b,c)) {
			_a = a;_b = b; _c = c;
		}
		else {
			cout << "no no no" << endl;
		}
	}
	void showt() {
		cout << this->_a << " " << this->_b << " " << this->_c << endl;
	}
	double ss() {
		double d = (_a + _b + _c) / 2;
		double s = sqrt(d*(d - _a)*(d - _b)*(d - _c));
		return s;
	}
	double operator+(Triangle &b) {
		return this->ss() + b.ss();
	}
private:
	int _a;
	int _c;
	int _b;
};

void test01() {
	Triangle t1(60,57,60);
	Triangle t2(3, 4, 5);
	t1.showt();
	t2.showt();
	cout << "t1:s:" << t1.ss() << endl;
	cout << "t2:s:" << t2.ss() << endl;
	cout << "t1+t2:s:" << t1+t2 << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

38.使用函数重载的方法定义两个重名函数,分别求出整型数的两数之和和浮点数的两数之和,并在主函数中调用。
#include<iostream>
#include<string>
using namespace std;
/*
使用函数重载的方法定义两个重名函数,分别求出整型数的两数之和和浮点数的两数之和,并在主函数中调用。
*/
void plus01(int a,int b=10) {
	cout << a + b << endl;
}
void plus01(double a, int b=10) {
	cout << a + b << endl;
}
int main() {
	int a = 8; 
	plus01(a);
	double i = 90.998;
	plus01(i);
	return 0;
}

39.定义一个抽象类 Shape 用以计算面积,从中派生出计算长方形、梯形、圆形面积的派生类。程序中通过基类指针来调用派生类中的虚函数,计算不同形状的面积。
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
39.定义一个抽象类 Shape 用以计算面积,从中派生出计算长方形、梯形、圆形面积的派生类。
程序中通过基类指针来调用派生类中的虚函数,计算不同形状的面积。
*/
class shape {
public:
	virtual void getshape() {};
};
class rectangle :public shape {
public:
	rectangle(int l,int h) {
		this->_l = l; this->_h = h;
	}
	void getshape() {
		cout << "rectangle shape :" << endl;
		int shape = this->_l * this->_h;
		cout <<shape<< endl;
	}
public:
	int _l;
	int _h;
};
class trapezoid :public shape {
public:
	trapezoid(int ul,int dl,int uh) {
		this->_upl = ul; this->_downl = dl; this->_uph = uh;
	}
	void getshape() {
		cout << "trapezoid shape :" << endl;
		double shape = (this->_upl / 2.0 + this->_downl / 2.0) * this->_uph;
		cout << shape << endl;
	}
public:
	int _upl;
	int _downl;
	int _uph;
};
class circle :public shape {
public:
	circle(int r) {
		this->_r = r;
	}
	void getshape() {
		cout << "circle shape :" << endl;
		double shape = this->_r * this->_r * PAI;
		cout << shape << endl;
	}
public:
	int _r;
};
void test01() {
	rectangle t(5, 6);
	t.getshape();
	trapezoid tr(3, 5, 6);
	tr.getshape();
	circle c(5);
	c.getshape();
}
int main() {
	test01();
	return 0;
}

​​​​​​​

40.定义计数器类 Counter。要求具有以下成员:计数器值;可进行增值和减值记数;可提供记数值。
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
40.定义计数器类 Counter。要求具有以下
成员:计数器值;
可进行增值和减值记数;可提供记数值。
*/
class Counter {
public:
	Counter(int a) {
		this->_count = a;
	}
	Counter& operator++() {//前置
		this->_count++;
		return *this;
	}
	Counter operator++(int) {//hou_zhi
		Counter p = *this;
		this->_count++;
		return p;
	}
	void getcount(int a) {
		cout << "begin count = " << this->_count << endl;
		system("pause");
		for (int i =0; i <= a; i++) {
			_count++;
			cout << this->_count << " ";
			system("cls");
		}
		cout << endl << "after count = " <<this->_count<< endl;
	}
public:
	int _count;
};
void test01() {
	Counter c(0);
	c.getcount(67);
	cout << (++c)._count << endl;
	cout << (c++)._count << endl;
	cout << (c)._count << endl;
}
int main() {
	test01();
	return 0;
}

41.声明一个哺乳动物 Mammal 类,再由此派生出狗 Dog类,二者都定义 speak(成员函数,基类中定义为虚函数。声明一个 Dog类的对象,调用 speak()函数,观察运行结果。
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
41.声明一个哺乳动物 Mammal 类,再由此派生出狗 Dog类,二者都定义 speak(成员函数,
基类中定义为虚函数。声明一个 Dog类的对象,调用 speak()函数,观察运行结果。
*/
class Mammal {
public:
	virtual void speak() {};
};
class dog :public Mammal {
public:
	void speak() {
		cout << " wang wang wang " << endl;
	}
};
void test01() {
	dog facai;
	facai.speak();
}
int main() {
	test01();
	return 0;
}
42.编写一个程序计算“三角形、正方形、圆形”三种图形的面积,要求  :a)抽象出一个基类 Base;  b)在其中说明一个虚函数用来求面积;   c)利用派生类定义“三角形、正方形、圆形”;  编写主函数并测试。
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
42.编写一个程序计算“三角形、正方形、圆形”三种图形的面积,要求  :
a)抽象出一个基类 Base;  
b)在其中说明一个虚函数用来求面积;  
c)利用派生类定义“三角形、正方形、圆形”;  编写主函数并测试。
*/
class shape {
public:
	virtual void getshape() {};
};
class square :public shape {
public:
	square(int l) {
		this->_l = l; 
	}
	void getshape() {
		cout << "square shape :" << endl;
		int shape = this->_l * this->_l;
		cout << shape << endl;
	}
public:
	int _l;
};
class triangle :public shape {
public:
	triangle(int ul, int dl, int uh) {
		this->_a = ul; this->_b = dl; this->_c = uh;
	}
	void getshape() {
		cout << "triangle shape :" << endl;
		double s = (_a + _b + _c) / 2.0;
		double shape = sqrt(s*(s-_a)*(s-_b)*(s-_c));
		cout << shape << endl;
	}
public:
	int _a;
	int _b;
	int _c;
};
class circle :public shape {
public:
	circle(int r) {
		this->_r = r;
	}
	void getshape() {
		cout << "circle shape :" << endl;
		double shape = this->_r * this->_r * PAI;
		cout << shape << endl;
	}
public:
	int _r;
};
void test01() {
	square t(5);
	t.getshape();
	triangle tr(4, 5, 3);
	tr.getshape();
	circle c(5);
	c.getshape();
}
int main() {
	test01();
	return 0;
}

C++字符串(std::string)、STL(标准模板库)相关;(这一部分的作业,请参考 C++ Primer5 的练习)

43.编写一段程序,从标准输入中一次读入一整行,存入 std::string 中,然后修改该程序,使其一次读入一个词。(练习3.2)
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
43.编写一段程序,从标准输入中一次读入一整行,存入 std::string 中,
然后修改该程序,使其一次读入一个词。(练习3.2)
*/

void test01() {
	cout << " one word once :___" << endl;
	string c;
	cin >> c;
	cout << c << endl;//string读到空格停止读入
}
void test02() {
	cout << " one line once:___" << endl;
	string line;
	while (getline(cin, line)) {//getline(is,s)从is中读取一行赋给S[包括空格],返回is
		cout << line << endl;
	}
}
int main() {
	test01();
	test02();
	return 0;
}
44.请说明std::string类的输入运算符和 getline函数分别是如何处理空白字符的。(练习3.3)

输入运算符 :逐字读取,行编辑,只保留第一串不含空白字符的连续字符;
getline :逐字读取,行编辑,全保留/换行符不存贮到字符串中

#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
44.请说明std::string类的输入运算符和 
getline函数分别是如何处理空白字符的。(练习3.3)
*/

void test01() {
	cout << " one word once :___" << endl;
	string c;
	cin >> c;
	cout << c << endl;
}
void test02() {
	cout << " one line once:___" << endl;
	string line;
	while (getline(cin, line)) {
		cout << line << endl;
	}
}
int main() {
	test01();
	test02();
	return 0;
}

45.编写一段程序从标准输入中读入多个字符串并将它们连接在一起,输出连接成的大字符串。然后修改上述程序,用空格把输入的多个字符串分隔开来。(练习 3.5)
#include<iostream>
#include<string>
using namespace std;
#define PAI 3.14159
/*
45.编写一段程序从标准输入中读入多个字符串并将它们连接在一起,输出连接成的大字符串。
然后修改上述程序,用空格把输入的多个字符串分隔开来。(练习 3.5)
*/

void test01() {
	string word;
	while (cin>>word) {
		cout << word;
	}
}
void test02() {
	string word;
	while (cin >> word) {
		cout << word<<" ";
	}
}
int main() {
	//test01();
	test02();
	return 0;
}

46.编写一段程序,读入一个包含标点符号的字符串,将标点符号去除后输出字符串剩余的部分。(练习 3. 10)
#include<iostream>
#include<string>
#include<cctype>
using namespace std;
/*
46.编写一段程序,读入一个包含标点符号的字符串,将标点符号去除后输出字符串剩余的部分。(练习 3. 10)
*/

void test02() {
	string line;
	while (getline(cin, line)) {
		for (auto c:line) {
			if (!ispunct(c)) {
				cout << c;
			}
		}
	}
}
int main() {
	test02();
	return 0;
}
47.编写一段程序,创建一个含有 10 个整数的 vector 对象,然后使用迭代器将所有元素的值都变成原来的两倍。输出 vector 对象的内容,检验程序是否正确。(练习 3.23)
#include<iostream>
#include<string>
#include<vector>
using namespace std;
/*
47.编写一段程序,创建一个含有 10 个整数的 vector 对象,
然后使用迭代器将所有元素的值都变成原来的两倍。
输出 vector 对象的内容,检验程序是否正确。(练习 3.23)
*/
void print01(vector<int> &v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		//*it *= 2;
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	vector<int> v;
	for (int i = 0; i < 10; i++)
		v.push_back(i);
	print01(v);
	for (int i = 0; i < 10; i++)
		v[i]*=2;
	print01(v);
}
int main() {
	test02();
	return 0;
}
48.编写一段程序,比较两个 std::string 对象。再编写一段程序,比较两个C风格字符串的内容。(练习3.39)
#include<iostream>
#include<string>
#include<vector>
using namespace std;
/*
48.编写一段程序,比较两个 std::string 对象。再编写一段程序,比较两个C风格字符串的内容。(练习3.39)
*/
void bigorsmall(string s1,string s2) {
	if (s1.compare(s2) == 0) {
		cout << s1<<" == "<<s2 << endl;
	}
	else if (s1.compare(s2) < 0) {
		cout << s1 << " > " << s2 << endl;
	}
	else if (s1.compare(s2) > 0) {
		cout << s1 << " < " << s2 << endl;
	}
}
void test02() {
	string s1 = "dsewfaewg";
	string s2 = "dsewfaewg";
	bigorsmall(s1, s2);
	const char* v1 = "nihao";
	const char* v2 = "aihao";
	bigorsmall(v1, v2);
}
int main() {
	test02();
	return 0;
}

49.对于下面的程序任务,vector、deque 和 list 哪种容器最为合适?解释你的选择的理由。如果没有哪一种容器优于其他容器,也请解释理由。(练习9.1)
(1)读取固定数量的单词,将他们按字典序插入到容器中。
(2)读取未知数量的单词,总是将新单词插入到末尾。删除操作在头部进行。
(3)从一个文件读取未知数量的整数。将这些数排序,然后将他们打印到标准输出。
/*
(1)LIST可以对任意位置进行快速插入或删除元素,操作方便,修改指针即可,不需要移动大量元素,LIST合适,
也可以每次尾部插入之后用排序算法重新排序,VECTOR合适
(2)固定头部删除,尾部插入,DEQUE更合适
(3)排序需要遍历元素,VECTOR访问元素的速度快于DEQUE,LIST,VECTOR合适
*/
50.对6种创建和初始化 vector 对象的方法,每一种都给出一个实例。解释每个 vector 包含什么值。(练习9.11)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
50.对6种创建和初始化 vector 对象的方法,每一种都给出一个实例。解释每个 vector 包含什么值。(练习9.11)
*/
void myprint(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	vector<int> v1;     //vector<T> v; 
	for (int i = 0; i < 5; i++) {
		v1.push_back(i);
	}
	vector<int> v2(v1.begin(), v1.end());   //vector(v.begin(),v.end());
	vector<int> v3(15,1);   //vector(n,elem); 
	vector<int> v4(v3);   //vector(const vector &vec); 
	vector<int> v5;   //operator= 
	v5 = v1;
	vector<int> v6;   //assign(n,elem)
	v6.assign(20, 0);   
	vector<int> v7;  //assign(beg,end)
	v7.assign(v3.begin(), v3.end());
	myprint(v1);
	myprint(v2);
	myprint(v3);
	myprint(v4);
	myprint(v5);
	myprint(v6);
	myprint(v7);
}
int main() {
	test02();
	return 0;
}

51.如何从一个 list<int>初始化一个 vector<double>?从一个 vector<int>又该如何创建?编写代码验证你的答案。(练习9.13)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
51.如何从一个 list<int>初始化一个 vector<double>?
从一个 vector<int>又该如何创建?编写代码验证你的答案。(练习9.13)
*/
void myprint(vector<double>& v) {
	for (vector<double>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	list<int>l(5, 6);
	vector<double>v0(l.begin(), l.end());
	vector<int> v1(10,1);
	vector<double>v2(v1.begin(),v1.end());
	myprint(v0);
	myprint(v2);
}
int main() {
	test02();
	return 0;
}

52.编程程序,将一个 1ist 中的 char*指针(指向C风格字符串)元素赋值给-个vector中的string。(练习9.14) 
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
52.编程程序,将一个 1ist 中的 char*指针(指向C风格字符串)元素
赋值给-个vector中的string。(练习9.14) 
*/
void myprint(vector<string>& v) {
	for (vector<string>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	list<const char*>l = { "cc","ii","ee"};
	vector<string>v0(l.begin(), l.end());
	myprint(v0);
}
int main() {
	test02();
	return 0;
}
​​​​​​​
53,编写程序,从标准输入读取 string 序列,存入一个 deque 中。编写一个循环,用迭代器打印 deque 中的元素。(练习 9.18)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
53,编写程序,从标准输入读取 string 序列,存入一个 deque 中。
编写一个循环,用迭代器打印 deque 中的元素。(练习 9.18)
*/
void myprint(deque<string>& v) {
	for (deque<string>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	deque<string>v0;
	string word;
	while (cin >> word) {
		v0.push_back(word);
	}
	myprint(v0);
}
int main() {
	test02();
	return 0;
}
54.编写程序,从一个 1ist<int>拷贝元素到两个 deque 中,其中值为偶数的所有元素都拷贝到一个 deque 中,而奇数元素都拷贝到另一个 deque 中。(9.20)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
54.编写程序,从一个 1ist<int>拷贝元素到两个 deque 中,其中值为偶数的所有元素
都拷贝到一个 deque 中,而奇数元素都拷贝到另一个 deque 中。(9.20)
*/
void myprint(deque<int>& v) {
	for (deque<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	deque<int> odd_number;
	deque<int> even_number;
	list<int> l;
	for (int i = 0; i < 101; i++) {
		l.push_back(i);
	}
	for (auto it = l.begin(); it != l.end(); it++) {
		if (*it % 2 == 0) {
			even_number.push_back(*it);
		}
		else {
			odd_number.push_back(*it);
		}
	}
	cout << " odd_number" << endl;
	myprint(odd_number);
	cout << " even_number" << endl;
	myprint(even_number);
}
int main() {
	test02();
	return 0;
}
55,假定你希望每次读取一个字符存入一个 std::string 中,而且知道最少需要读取 100个字符,应该如何提高程序的性能?(9.42)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
55,假定你希望每次读取一个字符存入一个 std::string 中,而且知道最少需要
读取 100个字符,应该如何提高程序的性能?(9.42)
1.使用 reserve:在读取字符前,调用 reserve 函数来预留足够的内存空间,以减少动态内存分配的次数
2.使用移动语义:当将读取的字符添加到 std::string 中时,使用移动语义而不是复制语义,可以避免不必要的内存复制。
*/

void test02() {
	string str;
	str.reserve(100);//提前开辟空间
	cout << str.capacity() << endl;
	char c;
	/*while ((c = getchar()) != EOF) {
		str.push_back(c);
	}*/
	while (cin.get(c)) {
		str.push_back(move(c));//使用移位字符
	}
	cout << str << endl;
}
int main() {
	test02();
	return 0;
}
56.编写一个函数,接受一个表示名字的 std::string 参数和两个分别表示前缀(如“Mr.”或“Ms.”)和后缀(如“Jr.”“III”)的字符串。使用迭代器及insert 和 append 函数将前缀和后缀加到给定的名字中,生成新的 string 并返回。(9.45)
#include<iostream>
#include<string>
#include<vector>
#include<deque>
#include<list>
using namespace std;
/*
56.编写一个函数,接受一个表示名字的 std::string 参数和两个分别表示前缀(如“Mr.”或“Ms.”)和后缀(如“Jr.”“III”)的字符串。
使用迭代器及insert 和 append 函数将前缀和后缀加到给定的名字中,生成新的 string 并返回。(9.45)
*/

void test02() {
	string str="魏国";
	string prefix = "Mr.";
	string prefix2 = "Ms.";
	string suffix = "Jr.III";
	cout << str << endl;
	str.append(suffix,0,3);
	cout << str << endl;
	str.append(suffix, 3, 3);
	cout << str << endl;
	str.insert(0, prefix);
	cout << str << endl;
	str.insert(0, prefix2);
	cout << str << endl;
}
int main() {
	test02();
	return 0;
}
57.定义一个 map,关键字是家庭的姓,值是一个 vector,保存家中孩子(们)的名。编写代码,实现添加新的家庭以及向已有家庭中添加新的孩子。(11.7)
0.1  bug,只有第一个添加人的函数能进入循环
#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
/*
57.定义一个 map,关键字是家庭的姓,值是一个 vector,保存家中孩子(们)的名。
编写代码,实现添加新的家庭以及向已有家庭中添加新的孩子。(11.7)
*/
void addchild(map<string, vector<string>>&fam) {
	string ff, child;
	cout << " addchild : enter family,child" << endl;
	while(cin>>ff&&cin>>child){
		fam[ff].push_back(child);
	}
}
void addfamily(map<string, vector<string>> &fam) {
	cout << " addfamily:enter family" << endl;
	string ff;
	while (cin >> ff) {
		fam[ff];
	}
}
void show(map<string,vector<string>> &fam) {
	cout << "show family and children" << endl;
	for (auto a : fam) {
		cout << a.first << ":\t" << endl;
		for (auto b : a.second) {
			cout << b << " ";
		}
		cout << endl;
	}
}
void test02() {
	map<string, vector<string>> fam;
	addchild(fam);
	addfamily(fam);//bug,只有第一个添加人的函数能进入循环
	show(fam);
}
int main() {
	test02();
	return 0;
}
0.2 正常的
#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
/*
57.定义一个 map,关键字是家庭的姓,值是一个 vector,保存家中孩子(们)的名。
编写代码,实现添加新的家庭以及向已有家庭中添加新的孩子。(11.7)
*/
void addchild(map<string, vector<string>>&fam, const string &ff, const string &child) {
		fam[ff].push_back(child);
}
void addfamily(map<string, vector<string>> &fam,const string &ff) {
	fam[ff];
}
void show(map<string,vector<string>> &fam) {
	cout << "show family and children" << endl;
	for (auto a : fam) {
		cout << a.first << ":\t" ;
		for (auto b : a.second) {
			cout << b << " ";
		}
		cout << endl;
	}
	cout << endl;
}
void test02() {
	map<string, vector<string>> fam;
	addchild(fam,"huang","dsd");
	addchild(fam, "huang", "34523");
	addchild(fam, "chen", "dddq");
	addfamily(fam,"xu");
	addfamily(fam, "zhuge");
	show(fam);
}
int main() {
	test02();
	return 0;
}

58,编写一个程序,在一个 vector 而不是一个 set 中保存不重复的单词。使用set的优点是什么?(练习 11.8)
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
/*
58,编写一个程序,在一个 vector 而不是一个 set 中保存不重复的单词。使用set的优点是什么?(练习 11.8)
SET	会自动进行排序,且不允许重复元素出现
*/
void addVector(vector<string> &v,string a) {
	vector<string>::iterator isrepetition=find(v.begin(), v.end(), a);
	if (isrepetition == v.end()) {
		v.push_back(a);
	}
}
void show(vector<string>& v) {
	for (vector<string>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	vector<string> v;
	addVector(v, "hkhk");
	addVector(v, "23");
	addVector(v, "hkhk");
	show(v);
}
int main() {
	test02();
	return 0;
}
​​​​​​​
59.可以用什么类型来对一个 map 进行下标操作?下标运算符返回的类型时什么?请给出一个具体例子,即定义一个 map,然后写出一个可以用来对 map 进行下标操作的类型以及下标运算符将会返回的类型。(11.26)
#include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
/*
当对MAP进行下标操作时,会得到一个MAPPED_TYPE对象,解引用一个迭代器时,会得到一个VALUE_TYPE对象
STRING 和 VECTOR使用小标和解引用返回的数据类型相同
*/
void show(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	map<int, string> m;
	m.insert(make_pair(2, "dsfe"));
	cout <<" m[2]:\t" << m[2] << endl;
	map<int, string>::iterator it = m.begin();
	cout <<"*it:\t" << (*it).first << " " << (*it).second << endl;
}
int main() {
	test02();
	return 0;
}
60.用冒泡法对 10 个整数排序。(用 STL 的 vector 容器实现)
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
/*
60.用冒泡法对 10 个整数排序。(用 STL 的 vector 容器实现)
*/
void bubble(vector<int> &v) {
	for (int t= 0; t < v.size()-1; t++) {
		for (int i = 0; i < v.size() - 1 - t; i++) {
			if (v[i] > v[i + 1]) {
				v[i] += v[i + 1];
				v[i + 1] = v[i] - v[i + 1];
				v[i]= v[i] - v[i + 1];
			}
		}
	}
}
void show(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test02() {
	srand(unsigned int(time(NULL)));
	vector<int> v;
	for (int i = 0; i < 10; i++) {
		int t = rand() % 100;
		v.push_back(t);
	}
	show(v);
	bubble(v);
	show(v);
}
int main() {
	test02();
	return 0;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/626798.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

第15节 编写shellcode加载器

我最近在做一个关于shellcode入门和开发的专题课&#x1f469;&#x1f3fb;‍&#x1f4bb;&#xff0c;主要面向对网络安全技术感兴趣的小伙伴。这是视频版内容对应的文字版材料&#xff0c;内容里面的每一个环境我都亲自测试实操过的记录&#xff0c;有需要的小伙伴可以参考…

数据结构进阶——搜索二叉树

数据结构进阶——二叉搜索树 1. 二叉搜索树的概念和定义2. 二叉搜索树的操作2.1 二叉搜索树的插入2.2 二叉搜索树的查找2.3 二叉搜索树的删除 3. 二叉搜索树的实际应用3.1 两种模型加二叉搜索树完整代码3.2 KV模型练习 4. 二叉搜索树性能分析 1. 二叉搜索树的概念和定义 1. 二叉…

航电AFDX板卡,标准PMC规格、高性能ARINC664网络接口板卡

是一款标准PMC规格、高性能ARINC664网络接口板卡。该产品支持ARINC664网络仿真、测试及数据分析等应用需求&#xff1b;支持2个ARINC664端口&#xff0c;采用RJ45插件形式&#xff0c;每个端口高达64K缓存&#xff0c;2个端口可作为2个独立端口&#xff0c;也可作为冗余端口使用…

10G UDP协议栈 IP层设计-(5)IP RX模块

一、模块功能 1、解析目的IP是否是本节点的源IP&#xff0c;如果是则进行如下的处理&#xff0c;如果不是则无需上上级传递 2、提取MAC层发送过来的IP报文&#xff0c;并提取其中的数据字段&#xff08;上层协议字段&#xff09;&#xff0c;传递给上级 3、提取IP报文头中的…

Android Studio无法使用Google翻译问题记录

背景 其实关于Google翻译不能用的问题已经出现很久了&#xff0c;之前Google关掉了很多国内的一些Google服务&#xff0c;但是Google翻译还是能用的&#xff0c;直到不知什么时候起&#xff0c;Google翻译也不能用呢。 每次换电脑安装完AS后第一件事就是下载插件 Settings-Pl…

[ardunio ide导入blinker库]

1 blinker库下载地址 https://github.com/blinker-iot/blinker-library2 导入方法一 zip导入 项目 -> 导入库 ->添加.zip库 3 导入方法二

排序(一)----冒泡排序,插入排序

前言 今天讲一些简单的排序,冒泡排序和插入排序,但是这两个排序时间复杂度较大,只是起到一定的学习作用,只需要了解并会使用就行,本文章是以升序为例子来介绍的 一冒泡排序 思路 冒泡排序是一种简单的排序算法&#xff0c;它重复地遍历要排序的序列&#xff0c;每次比较相邻…

【web网页开发制作】Html+Css+Js游戏主题特效及轮播效果网页作业天涯明月刀(7页面附源码)

HTMLCSSJS游戏主题轮播效果 &#x1f354;涉及知识&#x1f964;写在前面✨特效展示特效1、轮播幻灯效果特效2和3、鼠标悬浮及点击效果 &#x1f367;一、网页主题&#x1f333;二、网页效果Page1、首页Page2、游戏简介Page3、新闻中心Page4、互动专区Page5、视听盛宴Page6、用…

基于MSWA相继加权平均的交通流量分配算法matlab仿真

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 5.完整程序 1.程序功能描述 基于MSWA相继加权平均的交通流量分配算法matlab仿真.如图所示交通网络中&#xff0c;包含6个节点、11各路段、9个OD对。经枚举可得每个OD对间存在3条无折返有效路…

助力数字农林业发展服务香榧智慧种植,基于YOLOv5全系列【n/s/m/l/x】参数模型开发构建香榧种植场景下香榧果实检测识别系统

作为一个生在北方但在南方居住多年的人&#xff0c;居然头一次听过香榧&#xff08;fei&#xff09;这种作物&#xff0c;而且这个字还不会念&#xff0c;查了以后才知道读音&#xff08;fei&#xff09;&#xff0c;三声&#xff0c;这着实引起了我的好奇心&#xff0c;我相信…

“ModuleNotFoundError: No module named ‘selenium‘”报错如何解决

接上节&#xff1a;测试平台开发之测试框架改造并发执行及结果隔离(1) 上节博客的末尾提到&#xff1a;在命令窗口执行python main.py 可是执行的时候遇到了如下报错&#xff1a; ERRORS _____________________________________________________________ ERROR collecting te…

讲解SSM的xml文件

概述&#xff1a;这些配置文件很烦&#xff0c;建议直接复制粘贴 springMVC.xml文件 <?xml version"1.0" encoding"UTF-8"?> <beans xmlns"http://www.springframework.org/schema/beans"xmlns:xsi"http://www.w3.org/2001/XM…

Spring AI项目配置1.0.0-SNAPSHOT快照版指导

Spring AI项目配置1.0.0-SNAPSHOT快照版开发指导 说明pom文件修改 说明 请在更换Spring AI的全程中&#xff0c;科学上网&#xff0c;因为国内镜像和maven官方仓库还没有Spring AI的依赖&#xff0c;需要的依赖目前存放在https://repo.spring.io如果你使用的maven是自己配置&a…

Flutter 依据JSON数据自动生成实体类

json自动化生成工具 点击这里可以跳转 页面是这样的 然后在左边输入你的json数据&#xff0c;它会自动生成对应的实体类 生成的实体类是如下&#xff1a; import package:json_annotation/json_annotation.dart; part merch_region.g.dart;JsonSerializable()class MerchReg…

贷款中介CRM管理系统解决方案

一、贷款中介行业背景介绍 随着贷款中介行业的快速发展&#xff0c;贷款中介业务逐渐成为企业和个人融资的重要渠道。然而&#xff0c;贷款中介行业存在信息不对称、风险控制不力等难题。给金融稳定带来潜在风险。 二、方案目的和意义 鑫鹿贷款中介系统解决方案旨在规范贷款中…

JavaScript基础(七)

isNaN //用来判断一个变量是不是一个非数字 不是来判断是不是number类型&#xff0c;而是判断当前值能不能转为number类型&#xff0c;OK&#xff1f;懂了。 还有同学不明白&#xff0c;来看实例: <script> //isNaN(非数字)→true &#xff08;数字&#xff09;→fal…

文献速递:多模态深度学习在医疗中的应用--多模式婴儿脑分割技术:模糊引导深度学习

Title 题目 Multimodal Infant Brain Segmentation by Fuzzy-informed Deep Learning 多模式婴儿脑分割技术&#xff1a;模糊引导深度学习 01 文献速递介绍 日益普及的非侵入式婴儿脑磁共振图像&#xff08;MRI&#xff09;为准确理解脑主要发展轨迹的动态性提供了机会&…

10,hadoop优化与LZO压缩

hadoop多目录与LZO压缩 1.HDFS存储多目录 存储多目录&#xff1a; namenode&#xff0c; datanode namenode: 可以在当前节点中创建几个 namenode的多目录&#xff0c; 就是 虽说可以是多个目录&#xff0c;但是这个namenode多目录中&#xff0c;内容都是一样&#xff0c; 就…

使用System.Drawing绘制基本几何图形

1.使用System.Drawing绘制一个正方形 using System; using System.Drawing; using System.Windows.Forms;public partial class MyForm : Form {public MyForm(){// 你可以在这里设置Form的双缓冲&#xff0c;以避免绘制时出现的闪烁 this.DoubleBuffered true;}protected o…

基于django医用耗材网上申领系统的实现

基于django医用耗材网上申领系统的实现 开发语言:Python 数据库&#xff1a;MySQL所用到的知识&#xff1a;Django框架工具&#xff1a;pycharm、Navicat、Maven 系统功能实现 管理员登录 系统在安全性的验证方面究竟做了什么功能呢&#xff1f;在做之前我们也进行了思量&…