【C++初阶】类和对象（中）

已于 2024-05-18 13:20:46 修改
阅读量627 收藏 11
点赞数 28
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-02-21 19:08:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Liu_20236666/article/details/136188021
版权

目录

一.类的6个默认成员函数

1.知识引入 

​编辑 2.构造函数 

(1)概念 

(2)语法特性

(3)特征 

①问题引入1

②问题引入2  （缺少默认构造函数）

3.析构函数

(1)概念

(2)特性

4.拷贝构造函数 

(1)概念

(2)特征

①拷贝构造函数是构造函数的一个重载形式。

②拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。 

③若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象的内置类型成员按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。自定义类型成员调用它的拷贝构造。

5.赋值运算符重载  

 (1)运算符重载

① 语法及注意事项

(2)赋值运算符重载

二.总结 

一.类的6个默认成员函数

1.知识引入 

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数

  • 示例 

 2.构造函数 

(1)概念 

构造函数是一个特殊的成员函数，名字与类名相同,创建类 类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。 

  • 注意

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

(2)语法特性

  1. 函数名与类名相同。
  2. 无返回值。（不是void,是就不需要写）
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。
  •  示例 
class Date
{
public:
	Date()//构造函数
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	/*Date(int year=1,int month=1,int day=1)带参构造函数（函数重载）
	{
		_year = year;
		_month = month;
		_day = day;
	}*/
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
    //调用无参构造函数
	Date d1;
	d1.Print();

    //调用带参构造函数
	/*Date d2(2024,2,8);
	d2.Print();*/
	return 0;
}
  • 注意
 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
 warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)

//Date d3();

 通常情况只写一个构造函数，避免调用时存在歧义。

 (3)特征 

①问题引入1

关于编译器生成的默认成员函数，会有以下疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？ 

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	
	Date d1;
	d1.Print();

	return 0;
}

  • 解答

 C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型。默认生成的构造函数，对于内置类型不做处理，自定义类型会去调用他的默认构造函数。 

class A
{
public:
	A()
	{
		cout <<"A()" << endl;
		_a = 0;
	}
private:
	int _a;
};
class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;//也可以在这里给缺省值
	int _month;
	int _day;

	A _aa;
};

int main()
{
	
	Date d1;
	d1.Print();

	return 0;
}
  •  结果显示

 ②问题引入2  （缺少默认构造函数）
class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//也可以在声明时给缺省值
	int _year=1;
	int _month=1;
	int _day;

};

int main()
{
	
	Date d1;
	d1.Print();

	return 0;
}

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

问题存在：我们写了一个带参数的构造函数，编译器就不再给我们生成构造函数了。

  • 修改 
class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	//也可以在声明时给缺省值
	int _year=1;
	int _month=1;
	int _day;

};

int main()
{
	Date d1;
	d1.Print();
	return 0;
}

3.析构函数

 (1)概念

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

(2)特性

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载。

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

class Date
{
public:
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	~Date()
	{
		cout << this << endl;
		cout << "~Date()" << endl;
	}
private:
	//也可以在声明时给缺省值
	int _year=1;
	int _month=1;
	int _day;

};
void func()
{
	Date d2;
}
int main()
{
	func();

	Date d1;
	d1.Print();

	return 0;
}

 

4.拷贝构造函数 

(1)概念

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

(2)特征

①拷贝构造函数是构造函数的一个重载形式。
//拷贝构造函数
class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//Date(const Date& d) // 错误写法：编译报错，会引发无穷递归
	 Date(const Date& d) // 正确写法
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2024,1,28);

	Date d2(d1);
	return 0;
}
②拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。 
  •  C++规定自定义类型的拷贝都会调用拷贝构造

而传引用传参则不再需要调用拷贝构造。 

  • 为什么会引发无穷递归 

③若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象的内置类型成员按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。自定义类型成员调用它的拷贝构造。
class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	 void Print()
	 {
		 cout << _year << "-" << _month << "-" << _day << endl;
	 }
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024,1,28);
	Date d2(d1);

	d1.Print();
	d2.Print();

	return 0;
}
  • 深拷贝 
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack st1;
	Stack s2(st1);
	return 0;
}

程序最终崩溃，这是为什么呢？

  • 问题分析 

  • 代码修改（手写拷贝构造）
typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_size = 0;
		_capacity = capacity;
	}
	//Stack st2(st1)
	Stack(const Stack& s)
	{
		DataType* tmp = (DataType*)malloc(sizeof(s._capacity * (sizeof(DataType))));
		if (tmp == nullptr)
		{
			perror("malloc fail");
			exit(-1);
		}
		memcpy(tmp, s._array, sizeof(DataType) * s._size);

		_array = tmp;
		_size = s._size;
		_capacity = s._capacity;
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack st1;
	Stack s2(st1);
	return 0;
}

5.赋值运算符重载  

 (1)运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。 

① 语法及注意事项

函数原型：返回值类型 operator操作符(参数列表) 

  • 注意事项
  1. 不能通过连接其他符号来创建新的操作符：比如operator@
  2. 重载操作符必须有一个类类型参数
  3. 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义
  4. 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
  5. .*    ::    sizeof    ?:    .注意注意以上5个运算符不能重载。
  • 比较两个日期相等及小于（传统写法） 
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
//判断日期相等
bool DataEqual(const Date& x, const Date& y)
{
	return x._year == y._year
				&& x._month == y._month
				&& x._day == y._day;
}
//判断日期小于
bool DateLess(const Date& x, const Date& y)
{
	if (x._year < y._year)
	{
		return true;
	}
	else if (x._year == y._year)
	{
		if (x._month < y._month)
		{
			return true;
		}
		else if (x._month == y._month)
		{
			return x._day < y._day;
		}
	}
	return false;
}
int main()
{
	Date d1(2024, 1, 28);
	Date d2(2024, 2, 27);

    cout << DataEqual(d1, d2) << endl;
	cout << DateLess(d1, d2) << endl;
	return 0;
}

缺陷：由于函数名可能会存在取名字不规范的情况，将导致不知道这个函数的作用是什么。

因此采用运算符重载，来更容易让看代码的人知道这个代码的作用，增强代码可读性。 

  • 运算符重载写法 
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//private:
	int _year;
	int _month;
	int _day;
};
//判断日期相等
bool operator==(const Date& x, const Date& y)
{
	return x._year == y._year
				&& x._month == y._month
				&& x._day == y._day;
}
//判断日期小于
bool operator<(const Date& x, const Date& y)
{
	if (x._year < y._year)
	{
		return true;
	}
	else if (x._year == y._year)
	{
		if (x._month < y._month)
		{
			return true;
		}
		else if (x._month == y._month)
		{
			return x._day < y._day;
		}
	}
	return false;
}
int main()
{
	Date d1(2024, 1, 28);
	Date d2(2024, 2, 27);

	cout << (d1==d2) << endl;//cout<<(operator==(d1,d2)<<endl;
	cout << (d1<d2) << endl;

	return 0;
}
  • 注意 

这里代码能执行是因为我们将类内的成员设置成了公有权限，否则在类外面是不能访问类里面的成员的。

  • 处理方式（将类外函数放入类内）
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//判断日期相等
	bool operator==( const Date& y)
	{
		return _year == y._year
			&& _month == y._month
			&& _day == y._day;
	}
	//判断日期小于
	bool operator<( const Date& y)
	{
		if (_year < y._year)
		{
			return true;
		}
		else if (_year == y._year)
		{
			if (_month < y._month)
			{
				return true;
			}
			else if (_month == y._month)
			{
				return _day < y._day;
			}
		}
		return false;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 1, 28);
	Date d2(2024, 2, 27);

	cout <<d1.operator==(d2) << endl;
	cout << d1.operator<(d2) << endl;

	cout << (d1==d2) << endl;
	cout << (d1<d2) << endl;

	return 0;
}

(2)赋值运算符重载

赋值运算符重载格式 ：

  1.  参数类型：const T&，传递引用可以提高传参效率
  2. 返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值
  3. 检测是否自己给自己赋值
  4. 返回*this ：要复合连续赋值的含义
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//d1=d2
	void operator=(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 1, 28);
	Date d2(2024, 2, 27)

	Date d3(d1);//拷贝构造，同类型一个存在的对象进行初始化要创建的对象
	
	d1 = d2;//已经存在的对象,一个拷贝赋值给另一个
	d1.Print();
	d2.Print();


	return 0;
}
  • 返回值问题 
d1=d2=d3;

我们知道赋值操作是将右操作数赋值给左操作数，然后将左操作数作为返回值，因此该赋值函数需要有明确的返回值类型。因此要对上方代码进行部分修改：

    Date& operator=(const Date& d)//这里的“&”是引用
	{
		if (this != &d)//这里的“&”是取地址
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
  • 赋值运算符只能重载成类的成员函数不能重载成全局函数  
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	int _year;
	int _month;
	int _day;
};
// 赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数
Date& operator=(Date& left, const Date& right)
{
	if (&left != &right)
	{
		left._year = right._year;
		left._month = right._month;
		left._day = right._day;
	}
	return left;
}
// 编译失败：
// error C2801: “operator =”必须是非静态成员

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现 一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值 运算符重载只能是类的成员函数。 

二.总结 

  

川辞.
关注
专栏目录
C++初阶：类和对象
weixin_36194037的博客
09-21 350
C++初阶：类和对象
C++初阶-类和对象中
~
12-14 423
C++类和对象一、前言二、类的6个默认成员函数汇总三、构造函数四、析构函数五、拷贝构造函数六、赋值运算符重载1、运算符重载2、赋值运算符重载七、日期类的实现八、const成员九、取地址及const取地址操作符重载 一、前言 本章是继C++类和对象启点之章的后续，进一步深入学习掌握C++类和对象 二、类的6个默认成员函数汇总 对于任何一个类来说，在我们不主动写默认成员函数时，会自动生成默认成员函数，总共有6个默认成员函数 汇总示图： 三、构造函数 引入： 在C语言数据结构时，创建结构变量我
C++ 初阶 类和对象(中)
fq157856469的博客
11-03 690
先来说一下什么是内置类型，内置类型就是指语言自带的类型，如int，double，float......自定义类型就很好理解了，就是用户自己定义的类型，如class出来的类。但必须要注意的一点则是，在C++中，编译器会对自定义类型调用它的默认构造函数，而不对内置类型进行处理。//栈顶元素的位置//容量int* _s;//栈class testpublic:private:Stack s1;Stack s2;
C++初阶-类和对象上
~
12-06 1467
类和对象-起点之章一、前言二、面向过程/对象区别三、类的引入四、类的定义五、类的访问限定符及封装1、访问限定符2、封装六、类的作用域七、类的实例化八、类对象模型1、类对象的大小计算2、结构体内存对齐规则九、this指针1、this指针引入2、this指针的特性3、相关面试题 一、前言 主要讲解点： 本章将开启C++类和对象的学习和讲解，这里是起点之章，为之后的深入掌握类和对象打基础 二、面向过程/对象区别 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C+
C++初阶-类和对象下
~
12-19 382
C++类和对象-最终之章（下）零、前言一、再谈构造函数1、构造函数体赋值2、初始化列表3、explicit关键字二、static成员三、C++11 新式成员初始化四、友元1、友元函数2、友元类五、内部类六、再次理解封装七、再次理解面向对象 零、前言 本章为C++类和对象的最后一章，将类和对象的知识进一步学习和掌握 一、再谈构造函数 1、构造函数体赋值 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值 示例： class Date { public: Date(int.
C++初阶 类和对象(上)
fq157856469的博客
10-31 720
在C语言中，我们编写代码更多地是面向过程进行编写的，通过分析出求解问题的步骤，然后函数调用逐步解决问题。比方说洗衣服，在C语言的实现就是打开洗衣机->放衣服进去->倒入洗衣液->关上洗衣机->启动洗衣机->洗衣机翻滚->洗衣机甩干......如此一步一步地实现。而在C++中更多的是面向对向对象进行编写的。洗衣服这个操作，操作的对象便有4个，洗衣机，洗衣液，衣服和人，洗衣服在C++的实现则是使用这4个对象互相交互实现的，而人是不需要去关注洗衣机是如何去洗衣服的，只需要把事情交给洗衣机干就行了。
C++初阶 类和对象(下)
fq157856469的博客
11-16 555
拷贝构造函数是构造函数的重构，也就是说它也没有需要返回的东西，同样是为了构造成员而生。拷贝构造函数只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。其实很多小伙伴应该在使用C语言的时候就有过这样的苦恼，我这结构体+结构体没法玩啊，我得用.或->获取结构体成员才能够对里面的成员进行操作啊，太费劲了，就是写了个函数，还得来个d3=addition(d1,d2);就不能d1+d2吗。
C++初阶：类和对象（中）
L18623384951的博客
09-11 938
本文主要讲述了类的6个默认成员函数：构造函数/析构函数/拷贝函数/赋值函数/（const）取地址操作符重载函数，并讲述了操作符重载operator相关的函数。
C++初阶之 类和对象！
2301_81772249的博客
09-15 382
class为定义类的关键字,class后面为类的关键字,{}里为类的主体,注意类定义结束后面不能省略分号类中的变量为成员变量,类中的函数为成员函数为了区分成员变量,一般都在成员变量前面加一个_c++中,struct也可以定义类,c++中兼容c的struct用法,明显的变化是struct 可以定义函数,一般情况下我们还是用class定义类public://成员函数perror("malloc申请失败!");return;top = 0;//...扩容int Top()
C++初阶之类和对象
yueqing8的博客
07-30 281
C++面向对象的三大特点：封装、继承和多态。C++认为万事万物结尾对象，对象上有其属性和行为。
c++初阶 类和对象 中级篇
01-22
本篇文章讲解了C++中类和对象的中级知识，涵盖了类的6个默认成员函数、构造函数、析构函数、拷贝构造函数、赋值运算符重载、日期类的实现等内容。 一、类的6个默认成员函数 在C++中，如果一个类中什么成员都没有，...
C++初阶+类和对象（上）.pdf
01-17
C++初阶+类和对象（上） 本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程...
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 764
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
C 学习（4）
search7的博客
11-05 755
C语言学习，每个模块来自工作中的？？？
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 138
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 415
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 586
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
C++11|std::move和std::forward的区别
mooridy的博客
11-05 365
std::move和是C++11中引入的两个模板函数，它们在C++的类型推导和完美转发中扮演着重要的角色。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值