C++this指针、拷贝、赋值构造和单例模式

this指针

1、类的成员变量单独存储在每个类对象中，成员函数存储在代码段中，所有类对象共享一份成员函数。
2、成员函数是如何区别调用它的是哪个类对象的？

借助了this指针，类的每个成员函数都有一个隐藏的参数this指针，它指向类对象。

3、类的构造函数中也同样有this指针，指向的就是正在构造的这个对象。
4、在类中（成员、构造、析构函数）对成员变量、成员函数访问都是借助了this指针。
5、this指针是隐藏的，但是也可以显式使用：

1、参数与成员名一样时，使用this指针可以区别出成员变量与参数名
2、在成员函数中如果想返回当前对象地指针、引用等，可以使用this指针实现。
3、将this指针作为函数的参数，从一个对象传递给另一个其他类对象，可以实现对象间的交互。

class User
{
	char name[20];
	char pass[7];
public:
	User(const char* name,const char* pass)
	{
		strcpy(this->name,name);
		strcpy(this->pass,pass);
		show();
	}
	User& func(void)
	{
		return *this;
	}
	void show(void)
	{
		cout << name << " " << pass << endl;
	}
};
int main()
{
	User user1("zhizhen","zzxx");
	User& user2 = user1.func();
}

常函数

1、在函数参数列表与函数体之间有const修饰的函数，这个const其实就是在修饰this指针。
2、不能在常函数内修改成员变量的值，普通成员函数就可以调用常函数，而常函数只能调用常函数。
3、如果在常函数中真的需要修改某个成员变量的数据，那么需要这个成员被mutable修饰。

class User
{
	mutable char name[20];	// mutable修饰成员name
	char pass[7];
public:
	User(const char* name,const char* pass)
	{
		strcpy(this->name,name);
		strcpy(this->pass,pass);
		show();
	}
	User& func(void)
	{
		return *this;
	}
	void show(void) const
	{
		strcpy(name,"--------");	// 在常函数内修改name的值
		cout << name << " " << pass << endl;
	}
};
int main()
{
	User user1("zhizhen","zzxx");
	User& user2 = user1.func();
}

析构函数

特殊的成员函数

没有参数、没有返回值、不能重载
~类名(void)
{

}

谁来调用

析构函数会在销毁对象时自动调用，在对象的整个声明周期内最多被调用一次。

析构函数负责什么

析构函数负责释放在构造函数期间获取的所有资源，它的执行过程

1、先执行析构函数本身代码
2、调用成员类的析构函数
3、调用父类的析构函数

缺省的析构函数

1、如果一个类没实现析构函数，编译器会自动生成一个具有析构功能的二进制指令，它负责释放编译器能够看得到的资源（成员变量、类成员、父类成员），这就是缺省析构。
2、如果类中没有动态资源，也不需要做善后工作，缺省析构就完全够用了，不需要再定义新析构函数。

注意：缺省析构无法释放动态资源（堆内存）。

拷贝构造

1、拷贝构造又称为复制构造，是一种特殊的构造函数，它是使用一个现有的旧对象来构造一个新的对象，只有一个引用参数（对象本身）。

类名(类& )
{

}

2、拷贝构造的参数应该加const保护，但编译器并没有强制限制。
3、编译器会自动生成一个拷贝构造函数，它负责把旧对象中所有数据拷贝给新创建的对象。
4、深拷贝和浅拷贝的区别：

如果类成员中又指针，浅拷贝就只拷贝指针变量的值。而深拷贝是拷贝指针变量所指向的目标。

5、什么情况下需要实现拷贝构造：

当类成员中有指针成员，此时默认的拷贝构造（浅拷贝）就无法完成任务了，需要自己动手实现拷贝构造（深拷贝）。

6、什么情况下会调用拷贝构造：

1、使用旧对象给新对象赋值时
User user1 = user;
2、使用对象当作函数参数，当调用函数时，就会一起调用拷贝构造

赋值构造（赋值运算符）

1、当一个旧的类对象给另一个旧的类对象赋值时，就会调用赋值构造

void operator = (类& )
{

}

2、什么时候会调用：对象 = 对象;

编译器会生成一个缺省的赋值构造，它负责把一个对象的内容拷贝给另一个对象。

3、什么情况下需要实现赋值构造：

当需要深拷贝时需要自己手动实现赋值构造，也就是说拷贝构造与赋值构造需要同时实现。
编译器会自动生成四个成员函数：构造、析构、赋值构造和拷贝构造。

User& operator = (const User& that)
{
	if(this != &that)
	{
		delete[] name;
		name = new char[strlen(that.name)+1];
		strcpy(name,that.name);
	}
	return *this;
	/* 方法2
	User temp(that);
	swap(name,temp.name);
	*/
}

关于拷贝构造、赋值构造的建议

1、拷贝构造、赋值构造函数不光会拷贝本类的数据，也会调用成员类对象和父类的拷贝构造和赋值构造，而不是单纯的按字节复制，因此尽量少用指针成员。
2、在函数参数中尽量使用类指针或引用来当参数（不要直接使用类对象），减少调用拷贝构造和赋值构造的机会，也可以降低数据传递的开销。
3、如果由于特殊原因无法实现完整的拷贝构造、赋值构造，建议将它们私有化，防止误用。
4、一旦为一个类实现了拷贝构造，那么也一定要实现赋值构造。

静态成员

1、类成员一旦被static修饰就会变成静态成员，单独一份存储在bss或data内存段中，所有的类对象共享（静态成员属于类而不属于某个对象）。
2、静态成员类内声明，类外定义、初始化，与成员函数一样需要加"类名::"限定符表示它属于哪个类，但不需要再额外加static。
3、成员函数前也可以被static修饰，这种函数叫静态成员函数，这种成员函数没有this指针，因此在静态函数中不能再直接访问类的成员变量、成员函数，但可以直接访问静态成员（成员函数和成员变量）。
4、静态成员变量、函数依然受访问控制限定符的影响。
5、因为在代码编译完成后，静态成员已经定义完成，有了自己的存储位置和存储空间，因此可以不通过类对象而直接调用，而通过"类名::静态成员名"可以直接调用。
6、普通成员函数可以直接访问静态成员变量、静态成员函数。
7、静态成员变量可以被当作全局变量来使用（访问限定符必须是public），静态成员函数可以当作类的接口，实现对类的管理。

单例模式

单例模式是只能创建出一个类对象（只有一个实际的实例）的叫单例模式。

单例模式的应用场景：

1、Windows系统的任务管理器
2、Linux/UNIX系统的日志管理器
3、网站的访问计数器
4、服务端程序的连接池、线程池、数据池

获取单一对象的方法：

1、定义一个全局（C语言），但不受控制。
2、专门写入一个类，把类的构造函数设置私有，借助静态成员函数提供一个外部接口以此来获取唯一的实例。

C++如何实现单例模式：

1、禁止类在外部创建类对象：构造函数设置私有
2、类自己维护一个唯一的实例：使用一个静态指针指向
3、提供一个获取实例的方法：静态成员函数获取静态指针

饿汉模式

将单例类的唯一实例对象定义为成员变量，当程序开始运行时，实例对象就已经创建完成。
优点：加载进行时静态创建单例对象，线程安全。
缺点：无论使用与否，总要创建，浪费内存

class Singleton
{
private:
	Singleton(void)
	{
	
	}
	static Singleton object;
public:
	static Singleton& get_object(void)
	{
		return object;
	}
	void show(void)
	{
		cout << "我是对象" << &object << endl;
	}
};

Singleton Singleton::object;

int main()
{
	Singleton sig = Singleton::get_object();
	sig.show();
}

懒汉模式

用静态成员指针来指向单例类的唯一实例对象，只有真正调用获取实例对象的静态接口时，实例对象才被创建。
优点：什么时候用什么时候创建，节约内存
缺点：在以此调用访问获取实例对象接口时才真正创建，在多线程操作情况下有可能被创建出多个实例对象，虽然可能性很低，存在线程不安全问题。(增加线程锁)

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

class Singleton
{
private:
	Singleton(void){}
	static Singleton* objectp;
public:
	static Singleton& get_object(void)
	{
		if(NULL == objectp)
		{
			pthread_mutex_lock(&mutex);
			objectp = new Singleton;
			pthread_mutex_unlock(&mutex);
		}
		return *objectp;
	}
	void show(void)
	{
		cout << "我是对象：" << objectp << endl;
	}
};

Singleton* Singleton::objectp;

int main()
{
	Singleton str = Singleton::get_object();
	str.show();
}