C++ 修炼 三

一、this指针
类的成员变量单独存储在每一个类对象中，成员函数存储在代码段中，所有的类对象共享一份成员函数。

成员函数是如何区别调用它的是哪个类对象的？
答：借助了this指针，类的每个成员函数都有一个隐藏的参数this指针，它指向类对象

类的构造函数中也同样有this指针，指向的就是正在构造的这个对象

在类中（成员、构造、析构函数）对成员变量、成员函数的访问都是借助了this指针
User(const char* name,const char* pass)
{
    this->name=new char[strlen(name)+1];
    strcpy(this->name,name);
}
this指针是隐藏的，但也可以显示使用：
    1、参数与成员名重合时，使用this可以区别出成员变量与参数名
    2、在成员函数中如果想返回当前对象的指针、引用等，可以使用this指针实现
    3、将this指针作为函数的参数，从一个对象传递给另一个其它类对象，可以实现对象间的交互
二、常函数
在函数的参数列表与函数体之间有const修饰的函数，这个const其实就是在修饰this指针
不能在常函数内修改成员变量的值,普通的成员函数可以调用常函数，而常函数只能调用常函数
//int* p;
//const int* p1=p;

如果在常函数中真的需要修改某个成员变量的数据，那么需要这个成员被mutable修饰
普通成员函数不能被const修饰 没有this指针

三、析构函数
1、特殊的成员函数
    ~类名（void）
    {
    }
    没有参数、没有返回值、不能重载
2、谁来调用
    析构函数会在销毁对象时自动调用，在对象整个生命周期内最多被调用一次
    User* user=new User;
    exit(0);
    delete user;
    还没来得及释放，进程就结束了
3、析构函数负责什么
    析构函数负责释放在构造函数期间所获取的所有资源，它的执行过程：
        1、先执行析构函数本身代码
        2、调用成员类的析构函数
        3、调用父类的析构函数
4、缺省的析构函数
    如果一个类没实现析构函数，编译器会自动生成一个具有析构函数功能的二进制指令，它负责释放编译器能够看的到的资源（成员变量、类成员、父类成员）（看不到指针指向的资源），这就是缺省析构
    如果一个类没有动态资源，也不需要做善后工作，缺省析构完全够用了，不需要再定义新析构函数
    注意：缺省析构无法释放动态资源（堆内存） 不一定是堆内存

类对象的创建过程与释放过程:
创建过程：分配内存（对象）->父类构造->成员构造->自己构造
    父类构造：按照继承表从左到右依次构造
    成员构造：按照声明顺序从上到下依次构造
释放：自己析构->析构成员->析构父类->释放内存（对象）
    析构成员：按照声明顺序从下到上依次析构
    析构父类：按照继承表从右到左依次析构

先构造后析构

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

    User(User& that)
    {
    
    }
    拷贝构造的参数应该加const保护，但编译器并没有强行限制
    编译器会自动生成一个拷贝构造函数，它负责把旧对象中的所有数据拷贝给新创建的对象

    深拷贝和浅拷贝的区别：
    如果类成员有指针，浅拷贝只拷贝指针变量的值，而深拷贝是拷贝指针变量所指向的目标
    
    什么情况下需要实现拷贝构造：
    当类成员中有指针成员，此时默认的拷贝构造（浅拷贝）就无法完成任务，需要自己动手实现拷贝构造（深拷贝）
    User(User& that)
    {
        name = new char[strlen(that.name)+1];//申请内存
        strcpy(name,that.name);
        strcpy(pass,that.pass);
        cout << "我是拷贝构造" << endl;
    }
    什么情况下会调用拷贝构造：
    1、使用一个旧对象给新对象赋值时
    User user1=user;
    2、使用对象当作函数的参数，当调用函数时就会一起调用拷贝构造
    void func(User& user)     User user   就会再创建一个对象，使用引用就不会了
    {
          user.show();
    }

五、赋值构造（赋值运算符)
当一类旧对象给另一个类旧对象赋值时，就会调用赋值构造    
void operator=(类& )  可加可不加const  没有返回值，使用 User&   return *this;   为了连续赋值
{
}

什么时会调用：对象=对象；
编译器会生成一个缺省的赋值构造，它负责把一个对象的内存拷贝给另一个对象  覆盖

什么情况需要实现赋值构造：
当需要深拷贝时需要自己动手实现赋值构造，也就是拷贝构造与赋值构造需要同时实现

编译器会自动生成四个成员函数：构造、析构、赋值构造、拷贝构造

if(this!=&that)//取地址  不相同，才释放。。
{
    释放旧空间
    申请新空间
    拷贝内容
}

return *this;

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

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

八、单例模式
什么是单例模式，只能创建出一个类对象（只有一个实际的实例）的叫单例模式
单例模式的应用场景：
    Windows系统的任务管理器
    Linux、Unix系统的日志系统
    网站的访问计数器
    服务端程序的连接池、线程池、数据池
获取单一对象的方法：
    1、定义全局（C语言），但不受控制，防君子不能防小人
    2、专门写一个类，把类的构造函数设置私有，借助静态成员函数提供一个接口以此来获取唯一的实例
C++如何实现单例：
    1、禁止类的外部创建类对象：构造函数设置私有      
    2、类自己维护一个唯一的对象：使用一静态指针指向
    3、提供一个获取实例的方法：静态成员函数获取静态指针

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

#include <iostream>

using namespace std;

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();
	Singleton sig1 = Singleton::get_object();
	sig1.show();
}

懒汉模式：
    用静态成员指针来指向单例类的唯一实例对象，只有真正调用获取实例对象的静态接口时，实例对象才被创建
    优点：什么时候用什么时候创建，节约内存
    缺点：在第一次调用访问获取实例对象的静态接口才真正创建，如果在多线程操作情况下有可能被创建出多个实例对象（虽然可能性很低），存在线程不安全问题

#include <iostream>
#include <pthread.h>

using namespace std;

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

Singleton* Singleton:: objectp;

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