(一二七)动态内存和类——第十二章

  1. 云栖社区>
  2. 博客>
  3. 正文

(一二七)动态内存和类——第十二章

零零水 2016-01-25 14:47:00 浏览615
展开阅读全文

面对基本类型的时候,我们可以使用动态内存(newdelete)。

 

而面对类的时候,也可以使用动态内存,只不过使用方法有区别。

 

例如声明一个私有成员,想要这个私有成员的值为一个字符串(但这个字符串是什么是未知的)。

首先,不考虑用char word[40];这样的。原因有两点:①实际字符串可能超过40个字符;②对于没有超过的,很可能导致内存浪费(例如创建了1w个对象,有9000个只要一个字符长度,1000个需要40个字符长度);

 

因此,可以使用指针,让指针来指向字符串。

但单纯用指针指向字符串也存在问题:

①直接指向字符串的话,若字符串被修改,那么该对象的成员的值也会随之改变;

 

 

因此,具体做法是一般用new来分配一个动态内存,然后让成员的指针指向这个动态内存,并将字符串的内容复制到这个动态内存之中;等类对象消失时,用析构函数delete这个动态内存,防止内存泄露。

 

 

如代码:

//new.cpp
#pragma once
#include<iostream>
class Player
{
	char *name;	//名字
	int id;	//id编号
	static int players;	//玩家数量,注意,它被static所限定,所以是静态变量(并且是全局的)。可以通过Player::players来访问,且这里不能初始化(因为类声明不分配内存,即使是静态内存)
	//静态类变量有一个特点,无论有多少个对象,都只有一个副本。也就是说,所有的对象,都共享这个静态变量
public:
	Player(const char*);	//构造函数
	Player();	//默认构造函数
	~Player();	//析构函数
	friend std::ostream& operator<<(std::ostream& os, Player&);	//运算符重载<<
};
//new.cpp
#include<iostream>
#include"new.h"

Player::Player(const char* a)	//构造函数
{
	name = new char[strlen(a) + 1];	//strlen是不计算末尾空字符的。注意,这里有new,那么构造函数都要对应的delete
	strcpy_s(name, strlen(a) + 1, a);	//将a复制到name之中(name指向的是new出来的字符串)
	//这里假如直接用name=a的话,那么其实是让name指向了a的地址,而不是将a的值赋给了name
	players++;	//新建的话,人数加一
	id = players;	//id为人数。之所以在players++后赋值,是因为其+1指的是当前新建的对象
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;
}
Player::Player()	//默认构造函数
{
	name = new char[10];
	strcpy_s(name,10, "未起名");
	players++;
	id = players;	//id为人数
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;
}
Player::~Player()	//析构函数
{
	std::cout << "姓名:" << name << " 的玩家已被删除。其ID号为:" << id << "剩余玩家数:" << --players << std::endl;
	delete []name;	//delete对应new。name指向的是new出来的内存,注意,构造函数是new[],所以这里是delete[]
}
std::ostream& operator<<(std::ostream& os, Player& m)	//运算符重载<<
{
	os << "姓名:" << m.name << ",ID:" << m.id;
	return os;
}

//1.cpp main函数,用于测试
#include<iostream>
using namespace std;
#include "new.h"		//to avoid confusion with complex.h

int Player::players = 0;	//声明全局静态变量,才能引用。

int main()
{
	Player a;
	{
		Player b("charname");
		cout << b << endl;
		{
			Player c("成龙");
			cout << c << endl;
		}
	}

	cout << "Done!\n";
	system("pause");
	return 0;
}

显示:


姓名:未起名,ID:1的玩家已被创建。
姓名:charname,ID:2的玩家已被创建。
姓名:charname,ID:2
姓名:成龙,ID:3的玩家已被创建。
姓名:成龙,ID:3
姓名:成龙 的玩家已被删除。其ID号为:3剩余玩家数:2
姓名:charname 的玩家已被删除。其ID号为:2剩余玩家数:1
Done!
请按任意键继续. . .

 

注意:

newdelete应对应。因为是new char[],所以也应该是delete[],而不是delete

 

②在类中,被static(但不包含const)所限定的成员,只能在类外进行初始化。又因为需要全局可以使用(因为是类,不能不允许只在某个代码块使用),所以需要在代码块外进行初始化。所以int Player::players = 0;的位置才在main函数外。

 

bc在代码块内声明,因此离开代码块时,bc将调用析构函数删除。

 

 

 

特殊成员函数:

析构函数和按值传递函数所产生的问题:

假设,将1.cpp的代码修改,新增2个函数,分别参数为Player类的引用和Player类的按值传递。其他不变。

新的代码部分如下:

//1.cpp main函数,用于测试
#include<iostream>
using namespace std;
#include "new.h"		//to avoid confusion with complex.h

int Player::players = 0;	//声明全局静态变量,才能引用。
void show1(Player& a);
void show2(Player a);

int main()
{	//1#大括号
	Player a;
	{	//2#大括号
		Player b("charname");
		show2(b);
		{	//3#大括号
			Player c("成龙");
			show1(c);
		}
	}

	cout << "Done!\n";
	system("pause");
	return 0;
}

void show1(Player& a)
{
	cout << a << endl;
}

void show2(Player a)
{
	cout << a << endl;
}

在这段新的代码中,会出现错误。


错误表现在:

1show2(b);这行代码,运行后,提示charname这个对象(也就是Player b)被删除。正常的话,是不会删除的。

2)由于删除了,因此Player c创建并初始化的时候,id2,而不是期望的3

show1(c)这个是正常运行的——即单纯的显示了对象c

3)在2#大括号结束后(即离开2#大括号所包括的代码块时),程序提示出错。原因在于,Player b对象,理应在离开代码块时被删除,但是在show2(b)函数调用时就被删除了(见(1)),那么离开代码块时理应调用析构函数删除对象b,则delete[]了其 堆中对象b的私有成员name原本指向的内存地址 。相当于这个地址被二次delete[]

 

 

可见,当析构函数delete删除对象new出来的数据时,若使用按值传递,则会出现错误。而按引用传递,则一切正常。

 

之所以这样,是因为show2(按值传递)错误的调用了析构函数(因为调用了析构函数才会输出xxx已被删除这段话)。

 

按照书上的来看,假如编译器不提示错误,而显示出所有的内容,那么问题会反应的更明显。


析构函数意外的被调用:

可以观察到黑线,在离开这个代码块时,有5个析构函数被调用(因为先手创建了5个对象,headline1、headline2sportssailorknot),

但是前2个还正常,后三个则出现了错误。

 

第三个之所以出错,原因在于callme2(headline2);这个函数,错误的调用了析构函数,导致提示headline2的字符串被删除。我们也可以看到,根据自动变量的栈的LIFO原则,第一个退出的应该是knot,而knot=headline1(因此其指向同一个字符串),于是第一个退出对象的析构函数调用正常,第二个是sailor=sports,因此也正常。而第三个到了sports,但因为第三个和第二个指向的是同一个字符串(“Spinach.......”),已经被delete[]过了,因此第三个字符串显示便不正常(这时姑且不论计数),而第4个是headline2(在callme2()函数中已经被调用过析构函数了),第5个道理同第三个。因此,第3,4,5个退出的对象都不正常。

 

创建对象但未按预计那样调用构造函数:

除了析构函数,另外还有1个对象在创建时,被调用,却未按我们计划进行声明,是:

Stringbad sailor = sports;

这个对象。对象sailor是通过另外一个对象赋值创建的,按照我们计划中,构造函数有无参数的默认构造函数,和带一个字符串地址的构造函数。无论是哪个,在创建一个新对象时,都应该声明新对象被创建,并且计数加一。但实际上,并没有(看图中的绿色圆圈)。

 

 

原因分析:

之所以会这样,是因为 特殊成员函数 引起的。而这些函数是 自动定义 的,就书上这个例子Stringbad类和我修改过的1.cpp源代码文件而言,这些函数的行为和类设计的不符(我并没有想让类这样做)。

 

这些 自动定义 的 特殊成员函数 包括5种:

①默认构造函数——如果没有定义构造函数的话(例如Player类的默认构造函数是Player(){}且无赋值);

 

②默认析构函数——如果没有定义的话(例如退出一个类对象在退出代码块的话,会清除其所有私有成员——前提是没有new出来的,new出来的需要自己编写析构函数清除);

 

③复制构造函数——如果没有定义的话(这个之间并没有遇见过);

 

④赋值运算符——如果没有定义的话;

 

⑤地址运算符——如果没有定义的话。

 

更准确的说,是编译器将在做以上最后三个这个行为时,生成其定义。

例如,我们没有定义赋值运算符,然后我们要将Player类的对象a赋值给对象b,编译器会自动生成赋值运算符的定义。

 

结果表明:Stringbad类中的问题,是由隐式复制构造函数和隐式赋值运算符引起的(编译器自行生成的定义)。

 

另外:C++11还提供了另外2个特殊成员函数:①移动构造函数;②移动赋值运算符。这两个在18章(所以好远)

 

 

①关于第一个——默认构造函数:

之前已经学到过,默认构造函数可以由用户自行定义,也可以不定义默认构造函数但定义构造函数。在这两种情况下,编译器不会定义默认构造函数。

否则,如果用户不定义构造函数/默认构造函数,编译器将提供一个默认构造函数(无任何赋值)。

 

 

复制构造函数:

复制构造函数用于将一个对象 复制 到新创建的对象中。也就是说,它用于初始化过程中(包括按值传递参数),而不是常规的赋值过程中。

类的复制构造函数原型如下:

Class_name (const Class_name &);

它接受一个指向类对象的常量引用作为参数。例如,Stringbad类的复制构造函数的原型是:Stringbad (const Stringbad&);

 

1)何时调用复制构造函数

新建一个对象,并将其初始化为同类现有对象时,复制构造函数就会被调用。

简单的来说:在声明一个对象的同时,进行初始化,且这个初始化的形式是用另一个已有对象。

例如已有Player类对象m

Player m;

Player a(m); //给参数的形式

Player b = m; //赋值形式

Player c = Player(m); //m作为参数创建一个对象并赋值,注意,必须使用对象,否则会调用构造函数,而不是复制构造函数。

Player*d = new Player(m); //new一个对象并赋值,这里d是指针

复制构造函数为:

Player (const Playerm) { std::cout << "a"; } //复制构造函数

实测证明,在创建对象abc三个对象和d这个指针时,复制构造函数被调用。(但由于这里的复制构造函数的定义只是表示调用,因此无法输出这4个对象,会出错)

 

对象bc,可能使用复制构造函数直接创建bc,也可能使用复制构造函数生成一个临时的对象,然后将临时对象的内容赋值给bc,这取决于具体的实现(也就是看代码怎么写)。

指针d,使用对象m初始化一个匿名的对象,然后将这个匿名的对象的地址,赋给d指针。

 

每当程序生成对象副本时,编译器都将使用复制构造函数。具体包括:

1》当函数按值传递对象(例如void show2(Player a));

2》当函数返回对象时(例如return a);

3》编译器生成临时对象时(例如a+b+c时,有可能生成临时对象。但这种情况是否生成,需要看编译器);

都将调用复制构造函数(特别是《1》和《2》)

例如,函数:

void show2(Player a)

{

cout << a << endl;

}

 

将使用复制构造函数,生成一个Player类的形参。而结束这个函数时,生成的形参消亡,于是触发了析构函数,delete了实参new出来用于储存字符串的地址。

 

 

2)默认的复制构造函数的功能

默认的复制构造函数的功能,是逐个复制非静态成员(成员复制也称为浅复制)(注意,没有复制例如static限定的,以及enum枚举类型),复制的是成员的值。

例如Player类有int aint b两个成员。那么Player A=Player B; 就相当于A.a=B.a; A.b=B.b;这样(当然,实际上是不能这么写的,这里表示意思如此)。

 

如果成员本身就是类对象(就是说一个类A的成员,是另一个类B的对象,嵌套效果),则使用该类(类B)的复制构造函数来复制成员对象(类B的对象)。

 

这也就是说,如果类对象A的成员a是一个指针,那么通过复制构造函数来将A的值赋给类对象B时,B的成员a也是一个指针,且和A的成员a指向同一个地址。

 

这样的话,当A.a指向的地址的值改变时,B.a指向的地址的值也随之改变(因为他们是同一个地址)。那么A.a如果是new出来的对象,被删除后,B.a也同时受到了影响。

 

 

 

因此,

应显式的声明并自定义一个复制构造函数:

特别是在成员中有使用new来请求动态内存时,应显示的自定义一个复制构造函数。

 

自定义复制构造函数例子如下:

函数原型:Player(const Player& m); //复制构造函数

 

函数定义:

Player::Player(const Player& m)	//被传递的
{
	players++;	//计数器(如果有)应该相应增加
	name = new char[strlen(m.name) + 1];	//new一个地址
	strcpy_s(name, strlen(m.name)+1, m.name);	//将参数(传递的对象)复制进去。
	id = players;	//给上id
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;	//声明
}

部分源代码:

int main()
{
	{
		Player m;
		Player a(m);	//给参数的形式
		Player b = m;	//赋值形式
		Player c = Player(m);	//m作为参数创建一个对象并赋值,注意,必须使用对象,否则会调用构造函数,而不是复制构造函数。
		Player*d = new Player(m);	//new一个对象并赋值
	}
	cout << "\nDone!\n";
	system("pause");
	return 0;
}


显示:

姓名:未起名,ID:1的玩家已被创建。
姓名:未起名,ID:2的玩家已被创建。
姓名:未起名,ID:3的玩家已被创建。
姓名:未起名,ID:4的玩家已被创建。
姓名:未起名,ID:5的玩家已被创建。
姓名:未起名 的玩家已被删除。其ID号为:4剩余玩家数:4
姓名:未起名 的玩家已被删除。其ID号为:3剩余玩家数:3
姓名:未起名 的玩家已被删除。其ID号为:2剩余玩家数:2
姓名:未起名 的玩家已被删除。其ID号为:1剩余玩家数:1

Done!
请按任意键继续. . .


分析:

①首先看到,只调用了4个析构函数,却使用了1次默认构造函数(第一个),4个复制构造函数(第2~5个)。

之所以析构函数只调用4次,是因为最后的对象d是一个类对象指针,而不是类对象,但这种类对象指针会调用复制构造函数。

指针在离开时,不会调用析构函数(析构函数面对的是类对象)。

如果要删除指针指向的对象,应使用delete命令,如:delete d;即可调用指针d指向的对象的析构函数——需要记住,deletenew对应(我差点忘了)。

 

②在复制构造函数中,有几个特点:

1)没有返回值(不需要return,函数头也没有类型);

2)被传递的对象(例如代码里的对象m)是参数(onst Playerm),调用的时候需要用类成员运算符(例如m.name);

3)传递给的对象(例如代码里的对象abc等),被隐式传递给函数,调用的时候,直接使用私有成员名即可。就像是成员函数的运算符重载函数那样,运算符左边的(这里是被初始化的)对象被隐式传递给函数。

4)需要给对象的哪些成员赋值,则在赋值构造函数里进行逐个赋值。

 

③另外注意,默认的复制构造函数不影响静态成员(如players,如果有这种计数器变量,在有必要的情况下,需要加上计数器变量的变化)。

 

 

 

 

现在回过头来看上面的代码,问题在于:

①按值传递时,调用默认的复制构造函数,但默认的复制构造函数是逐成员赋值,从而导致(1)未给计数器加上数字;(2)让指针指向同一个地址;

 

②在将一个对象传递给一个新对象时,调用默认复制构造函数,同样犯了①中的两个错误。

 

③于是,在调用析构函数时,则释放了已释放的内存(而且还要输出已释放内存的内容),故导致错误。

 

 

 

另一个问题:赋值运算符:

除了调用复制构造函数会导致逐成员复制之外,使用赋值运算符也会导致逐成员复制(记得,指针复制后指向的是同一个地址)。

 

ANSI C允许结构赋值,C++允许类对象赋值,实现的原理是自动为类重载赋值运算符(所以才能类对象a=类对象b)。

 

这种运算符重载的函数原型就像普通的赋值运算符重载那样:

Class_name& operator=(const Class_name &);

其中,Class_name是类名,例如上面的Player类。

解释是:接受一个被const限定的类对象的引用,然后返回一个类对象的引用。

 

注意:赋值运算符不影响静态成员。

 

 

 

赋值运算符存在的问题同隐式复制构造函数——遇见指针会导致指针指向同一个地址(遇见new出来的动态内存,可能导致二次或多次delete)。

 

 

解决办法:自定义一个赋值运算符(=)的重载函数,注意以下几点:

①由于是赋值运算符,因此对象之前已经存在了,因此无需更新计数(如果有计数器的话);

 

②因为对象已经存在了,假如有指针指向new出来的动态内存,那么赋值运算符需要delete进行释放,才能重新new(特别是new出来的字符串长度不一的情况下,长的字符串赋值到短的new出来的,可能导致超出限界);

 

③如果赋值运算符中有delete释放内存,那么需要保证每个构造函数(包括默认和复制构造函数),都需要使用new来申请动态内存(不然会导致释放静态内存区或者其他非动态内存区,比如栈)。

 

 

例如,将上面的赋值运算符的重载函数修改如下:

函数原型:

Playeroperator=(const Player& m);

函数定义:

Player& Player::operator=(const Player& m)
{
	if (this == &m) { return *this; }	//首先,this是指针,m是对象,所以应用this==&m(判定地址而不是判定值)来防止将自己赋值给自己。
			//其次,之所以return *this,是因为m被const所限定,所以假如地址相同的话(是自己赋值给自己),返回自己(相当于什么事都没做)
	delete[] name;	//因为是指针指向字符串,new char[],所以也是delete[]
	name = new char[strlen(m.name) + 1];	//new一个
	strcpy_s(name, strlen(m.name) + 1, m.name);	//复制字符串的值到新的地址
	return *this;	//返回调用的对象
}

解释:

m作为参数传递,因为是引用,为了防止被修改,所以使用const进行限定;

 

②因为mconst限定,因此不能返回m(会导致指针指向同一个地址),只能返回*this(也就是调用这个函数,被隐式传递的对象);

 

③如果要new,需要先delete(因为指针之前是指向一个new出来的地址的),不然会导致内存泄露。

 

④因为是赋值,不是创建新对象,因此不应更改计数器的数字(在这里,那是构造函数和析构函数干的事)。

 

⑤具体方法有一些类似构造函数。

 

附上修改后的全部代码:

//new.cpp
#pragma once
#include<iostream>
class Player
{
	char *name;	//名字
	int id;	//id编号
	static int players;	//玩家数量,注意,它被static所限定,所以是静态变量(并且是全局的)。可以通过Player::players来访问,且这里不能初始化(因为类声明不分配内存,即使是静态内存)
	//静态类变量有一个特点,无论有多少个对象,都只有一个副本。也就是说,所有的对象,都共享这个静态变量
public:
	Player();	//默认构造函数
	Player(const char*);	//构造函数
	~Player();	//析构函数
	Player(const Player& m);	//复制构造函数
	friend std::ostream& operator<<(std::ostream& os, Player&);	//运算符重载<<
	Player& operator=(const Player& m);
};

//new.cpp
#include<iostream>
#include"new.h"

Player::Player()	//默认构造函数
{
	name = new char[10];
	strcpy_s(name,10, "未起名");
	players++;
	id = players;	//id为人数
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;
}
Player::~Player()	//析构函数
{
	std::cout << "姓名:" << name << " 的玩家已被删除。其ID号为:" << id << "剩余玩家数:" << --players << std::endl;
	delete []name;	//delete对应new。name指向的是new出来的内存,注意,构造函数是new[],所以这里是delete[]
}
std::ostream& operator<<(std::ostream& os, Player& m)	//运算符重载<<
{
	os << "姓名:" << m.name << ",ID:" << m.id;
	return os;
}
Player::Player(const Player& m)	//被传递的
{
	players++;	//计数器(如果有)应该相应增加
	name = new char[strlen(m.name) + 1];	//new一个地址
	strcpy_s(name, strlen(m.name)+1, m.name);	//将参数(传递的对象)复制进去,注意,之所以是strlen(m.name)+1,是因为strlen不计算空字符,而这里要将空字符也复制进去
	id = players;	//给上id
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;	//声明
}
Player& Player::operator=(const Player& m)
{
	if (this == &m) { return *this; }	//首先,this是指针,m是对象,所以应用this==&m(判定地址而不是判定值)来防止将自己赋值给自己。
			//其次,之所以return *this,是因为m被const所限定,所以假如地址相同的话(是自己赋值给自己),返回自己(相当于什么事都没做)
	delete[] name;	//因为是指针指向字符串,new char[],所以也是delete[]
	name = new char[strlen(m.name) + 1];	//new一个
	strcpy_s(name, strlen(m.name) + 1, m.name);	//复制字符串的值到新的地址
	return *this;	//返回调用的对象
}

Player::Player(const char* a)	//构造函数
{
	name = new char[strlen(a) + 1];	//strlen是不计算末尾空字符的。注意,这里有new,那么构造函数都要对应的delete
	strcpy_s(name, strlen(a) + 1, a);	//将a复制到name之中(name指向的是new出来的字符串)
										//这里假如直接用name=a的话,那么其实是让name指向了a的地址,而不是将a的值赋给了name
	players++;	//新建的话,人数加一
	id = players;	//id为人数。之所以在players++后赋值,是因为其+1指的是当前新建的对象
	std::cout << "姓名:" << name << ",ID:" << id << "的玩家已被创建。" << std::endl;
}

void show1(Player& a)	//按值引用传递
{
	std::cout << "按引用传递:" << a << std::endl;
}

void show2(Player a)	//按值传递
{
	std::cout << "按 值 传递:" << a << std::endl;
}

//1.cpp main函数,用于测试
#include<iostream>
using namespace std;
#include "new.h"		//to avoid confusion with complex.h

int Player::players = 0;	//声明全局静态变量,才能引用。
void show1(Player& a);
void show2(Player a);

int main()
{	
	{	//1#大括号
		Player a;
		{	//2#大括号
			Player b("charname");
			show2(b);	//按值传递
			{	//3#大括号
				Player c("成龙");
				show1(c);	//按引用传递
				Player d;	//新建一个对象
				d = b;	//将b赋值给他
				show2(d);
			}
			cout << "3#大括号在这行之前结束。" << endl;

		}
		cout << "2#大括号在这行之前结束。" << endl;
	}
	cout << "1#大括号在这行之前结束。" << endl;

	cout << "Done!\n";
	system("pause");
	return 0;
}

显示:


姓名:未起名,ID:1的玩家已被创建。
姓名:charname,ID:2的玩家已被创建。
姓名:charname,ID:3的玩家已被创建。
按 值 传递:姓名:charname,ID:3
姓名:charname 的玩家已被删除。其ID号为:3剩余玩家数:2
姓名:成龙,ID:3的玩家已被创建。
按引用传递:姓名:成龙,ID:3
姓名:未起名,ID:4的玩家已被创建。
姓名:charname,ID:5的玩家已被创建。
按 值 传递:姓名:charname,ID:5
姓名:charname 的玩家已被删除。其ID号为:5剩余玩家数:4
姓名:charname 的玩家已被删除。其ID号为:4剩余玩家数:3
姓名:成龙 的玩家已被删除。其ID号为:3剩余玩家数:2
3#大括号在这行之前结束。
姓名:charname 的玩家已被删除。其ID号为:2剩余玩家数:1
2#大括号在这行之前结束。
姓名:未起名 的玩家已被删除。其ID号为:1剩余玩家数:0
1#大括号在这行之前结束。
Done!
请按任意键继续. . .

解释:

姓名:未起名,ID:1的玩家已被创建。
//这一行是Player a;,创建新对象,使用默认构造函数

姓名:charname,ID:2的玩家已被创建。
//这一行是Player b("charname");,使用构造函数

姓名:charname,ID:3的玩家已被创建。
//这行和以下两行是show2(b);	//按值传递,按值传递,因此先调用复制构造函数

按 值 传递:姓名:charname,ID:3
//这里是show2(b)函数的std::cout << "按 值 传递:" << a << std::endl;

姓名:charname 的玩家已被删除。其ID号为:3剩余玩家数:2
//这里是因为show2(b)函数结束,临时对象被删除,调用了析构函数

姓名:成龙,ID:3的玩家已被创建。
//这里是Player c("成龙");,调用了构造函数

按引用传递:姓名:成龙,ID:3
//函数show1(c);,按引用传递,不创造新对象

姓名:未起名,ID:4的玩家已被创建。
//Player d;,默认构造函数

姓名:charname,ID:5的玩家已被创建。
//d = b赋值运算符重载被跳过(因为函数没有输出内容),然后这行和下面两行都是函数show2(d)调用

按 值 传递:姓名:charname,ID:5
//略,见上

姓名:charname 的玩家已被删除。其ID号为:5剩余玩家数:4
//函数结束,析构函数调用

姓名:charname 的玩家已被删除。其ID号为:4剩余玩家数:3
//注意,之所以是charname,是因为使用了赋值运算符将b赋值给他(由于使用的不是默认的,因此d和b的成员char*name,指向的是不同的地址。这行调用了对象d的析构函数

姓名:成龙 的玩家已被删除。其ID号为:3剩余玩家数:2
//调用了对象c的析构函数

3#大括号在这行之前结束。
//括号结束,表示位置

姓名:charname 的玩家已被删除。其ID号为:2剩余玩家数:1
//调用了对象b的析构函数,注意,没有和对象d的指针指向同一个地址(因为赋值运算符被自定义了)

2#大括号在这行之前结束。
//括号结束,表示位置

姓名:未起名 的玩家已被删除。其ID号为:1剩余玩家数:0
//对象a的析构函数被调用。此时,所有对象的析构函数均已被调用,因此剩余为0

1#大括号在这行之前结束。
//表示位置

Done!
请按任意键继续. . .

解释完。

 

 

 

C++11的空指针:

当一个指针,字面值为0时(char *a=0;),有两个含义:

①可以表示数字值是0(例如int *a=0);

②也可以表示空指针(这样人和编译器都难以区分)。

因此有些程序员使用(void*)0(或者是(int*)(char*)等,总之用强制类型转换后,0就是表示指针了)来标识空指针(空指针的内部表示可能不为0只不过一般表示NULL==0)。

还有程序员使用NULL(这是一个表示空指针的C语言宏)。

C++11引入了新的关键字nullptr,用于表示空指针。(有点像NULL,只不过NULLC语言宏)。

 

但是我还是不太清楚空指针有什么意义,我查了查别人的说法,感觉争论还蛮激烈的。

 

 



网友评论

登录后评论
0/500
评论
零零水
+ 关注