一、this指针
类的成员变量单独存储在每个类对象中，成员函数存储在代码段中，所有的类对象共享一份成员函数。
成员函数是如何区别调用它的是哪个类对象的？
答：借助了this指针，类的每个成员函数都有一个隐藏的参数this指针，它指向类对象。类的构造函数中也同样有this指针，指向的就是正在构造的这个对象。
在类中（成员、构造、析构函数）对成员变量、成员函数的访问都是借助了this指针。
this指针是隐藏的，但也可以显示使用：
1、参数与成员一样时，使用this可以区别出成员与参数名。
2、在成员函数中如果想返回当前对象的指针、引用等，可以使用this指针实现。
3、将this指针作为函数的参数，从一个对象传递给另一个其它类对象，可以实现对象间的交互。#include <iostream>
#include <cstring>
using namespace std;
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)//隐藏this指针
{
cout<< name << " "<< pass <<endl;
}
User* this = const this;
};
int main()
{
User u1("aaa","123");
User u2("bbb","321");
User& u3 = u1.func();
u1.show();
u2.show();
u3.show();
}二、常函数
在函数的参数列表与函数体之间有const修饰的函数，这个const其实就是在修饰this指针。
不能在常函数内修改成员变量的值，普通成员函数可以调用常函数，而常函数只能调用常函数。
如果在常函数中真的需要修改某个成员变量的数据，那么需要这个成员被 mutable修饰。mutable char name[20];
void show(void) const//隐藏this指针
{
strcpy(name,"------");
cout<< name << " "<< pass <<endl;
}普通函数不能声明为常函数（因为没有this指针）。
三、析构函数
1、特殊的成员函数
~类名(void)
{
}
没有参数、没有返回值、不能重载
2、谁来调用
析构函数会在销毁对象时自动调用，在对象的整个生命周期内最多被调用一次。
3、析构函数负责什么
负责释放在构造函数期间获取的所有资源，它的执行过程：
1.先执行析构函数本身代码
2.调用成员类的析构函数
3.调用父类的析构函数#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class A
{
public:
A(void)
{
cout << "A 's 构造" <<endl;
}
~A(void)
{
cout<<"A 's 析构"<<endl;
}
};
class B
{
public:
B(void)
{
cout << "B 's 构造" <<endl;
}
~B(void)
{
cout<<"B 's 析构"<<endl;
}
};
class User : public A
{
char* name;
char* pass;
B b;
//char name[20];
//char pass[10];
public:
User(const char* name,const char* pass)
{
this->name = new char[strlen(name)+1];
strcpy(this->name,name);
this->pass = new char[strlen(pass)+1];
strcpy(this->pass,pass);
cout<< "构造"<<endl;
cout<<"-----"<<endl;
}
/* User(void)
{
cout<<"构造"<<endl;
}
*/
~User(void)
{
delete name;
delete pass;
cout<<"析构"<<endl;
}
};
int main()
{
User* u1 = new User("asd","ads");
//exit(0);
delete u1;
//User u2;
} 4.缺省的析构函数
如果一个类没有实现析构函数，编译器会自动生成一个具有析构函数功能的二进制指令，它负责释放编译器能够看得到的资源（成员变量、类成员、弗雷成员），这就是缺省析构。
如果类中没有动态资源，也不需要做善后工作，缺省析构就完全共用了，不需要再实现新析构函数。
注意：缺省析构无法释放动态资源（堆内存）【堆内存是动态资源，动态资源不一定是堆内存】
类对象的创建过程与释放过程。
创建：分配内存（对象）-> 父类构造-> 成员构造-> 自己构造
父类构造：按照继承表从左到右依次构造。
成员构造：按照声明顺序从上至下依次构造。
释放：自己析构-> 成员析构-> 父类析构-> 释放内存（对象）
成员析构：按照声明顺序从下到上依次构造。
父类析构：按照继承表从右到左依次构造。四、拷贝构造
拷贝构造又称为复制构造，是一种特殊的构造函数，它是使用一个现有的旧对象构造一个新的对象时调用的函数，只有一个引用型的参数（对象本身）。
类名(类& )
{
}
拷贝构造的参数应该加 const 保护，但编译器并没有强行限制。
编译器会自己生成一个拷贝构造函数，它负责把旧对象中的所有数据拷贝给新创建的对象。
深拷贝与浅拷贝的区别：
如果类成员有指针，浅拷贝只拷贝指针变量的值，而深拷贝指针变量所指向的目标。
什么情况下需要实现拷贝构造：
当类成员中没有指针成员，此时默认的拷贝构造（浅拷贝）就无法完成任务，需要自己动手实现拷贝构造（深拷贝）。
什么情况下会调用拷贝构造：
1、使用旧对象给新对象赋值时
User user1 = user;
2、使用对象当作函数的参数，当调用函数时，就会一起调用拷贝构造。#include <iostream>
#include <cstring>
using namespace std;
class User
{
char* name;
char pass[7];
int id;
public:
User(const char* name,const char* pass)
{
this->name = new char[strlen(name)+1];
strcpy(this->name,name);
strcpy(this->pass,pass);
}
void show(void)
{
cout<<name <<" " <<pass <<endl;
}
~User(void)
{
cout<<"析构"<<&name <<endl;
delete[] name;
}
User(User& that)
{
name = new char[strlen(that.name)];
strcpy(name,that.name);
strcpy(pass,that.pass);
cout << "我是拷贝构造" << endl;
}
};
void func(User& user)
{
user.show();
}
int main()
{
User u1("a","aa");
u1.show();
// 调用拷贝构造
User u2 = u1;
u2.show();
func(u1);
}五、赋值构造（赋值运算符）
当一类对象给另一个类对象赋值时，就会调用赋值构造
void opeator = (类&)
{
}
什么时会调用：对象 = 对象；
编译器会生成一个缺省的赋值构造，它负责把一个对象的内存拷贝给另一个对象。
什么情况需要实现赋值构造：
当需要深拷贝时，需要自己动手实现赋值构造，也就是拷贝构造与赋值构造需要同时实现。
编译器会自动生成四个成员函数：构造、析构、赋值构造、拷贝构造。 #include <iostream>
#include <cstring>
using namespace std;
class User
{
char* name;
char pass[7];
public:
User(const char* name,const char* pass)
{
this->name = new char[strlen(name)+1];
strcpy(this->name,name);
strcpy(this->pass,pass);
}
void show(void)
{
cout<<name <<" " <<pass <<endl;
}
~User(void)
{
cout<<"析构"<<&name <<endl;
delete[] name;
}
User(User& that)
{
name = new char[strlen(that.name)];
strcpy(name,that.name);
strcpy(pass,that.pass);
cout << "我是拷贝构造" << endl;
}
User& operator = (const User& that)
{
cout<< this <<" "<< &that << endl;
if(this != &that)
{
cout<<"我是赋值构造"<<endl;
// 释放旧空间
delete[] name;
// 申请新空间
name = new char[strlen(that.name)+1];
// 拷贝内容
strcpy(name,that.name);
strcpy(pass,that.pass);
/*
User temp(that);
swap(name,temp.name);
*/
}
return *this;
}
};
int main()
{
User u1("a","aa");
User u2("bbbb","bb");
User u3("ccc","cc");
//赋值构造
u1 = u1;
//u2 = u1 = u3;
u1.show();
u2.show();
u3.show();
}六、关于拷贝构造、赋值构造的建议
1、缺省的拷贝构造、赋值构造函数不光会拷贝本类的数据，也会调用成员类对象和父类的拷贝构造和赋值构造，而不是单纯的按字节复制，因此尽量少用指针成员。
2、在函数参数中，尽量使用类指针或引用来当参数（不要直接使用类对象），减少调用拷贝构造和赋值构造的机会，也可以降低数据传递的开销。
3、如果由于特殊原因无法实现完整的拷贝构造、赋值构造，建议将它们私有化，防止误用。
4、一旦为一个类实现了拷贝构造，那么也一定要实现赋值构造。（<=>）七、静态成员
类成员一旦被 static 修饰就会变成静态成员，而是单独一份存储在bss或data内存段中，所有的类对象共享（静态成员属于类，而不属于某个对象）。
静态成员在类内声明，但必须在类外定义、初始化。与成员函数一样需要加“类名::”限定符表示它属于哪个类，但不需要再额外增加 static.
成员函数也可以被static修饰，这种函数叫静态成员函数，这种成员没有this指针，因此在静态函数中不能直接访问类的成员，但可以直接访问静态成员，但可以直接访问静态成员变量、静态成员函数。
静态成员变量、函数依然受访问控制限定符的影响。
因为在代码编译完成后，静态成员已经定义完成（有了存储空间），一次可以不用活类对象而直接调用，类名::静态成员名
静态成员变量可以被当做全局变量来使用（访问限定符必须是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();
Singleton sig1 = Singleton::get_object();
sig.show();
sig1.show();
} 懒汉模式：
用静态成员指针来指向单例类的唯一实例对象，只有真正调用获取实例的静态接口时，实例对象才被创建。
优点：什么时候用什么时候创建，节约内存。
缺点：在第一次调用获取实例对象的静态接口时，才真正创建，如果在多线程操作情况下有可能被创建出多个实例对象（虽然可能性很低），存在线程不安全问题。
#include <iostream>
#include <pthread.h>
using namespace std;
//pthread_mutex_lock = PTHREAD_MUTEX_INITIALIZER;
class Singleton
{
private:
Singleton(void)
{
}
static Singleton* object;
public:
static Singleton& get_object(void)
{
if(NULL == object)
{
object = new Singleton;
}
return *object;
}
void show(void)
{
cout<< "我是对象："<<object <<endl;
}
};
Singleton* Singleton::object;
int main()
{
Singleton sig = Singleton::get_object();
Singleton sig1 = Singleton::get_object();
sig.show();
sig1.show();
}
