[C++知识库]C++入门

1、面向对象
三大特性：封装 继承 多态
四大特性：抽象 封装 继承 多态
2、编程语言主要目的----模拟现实
3、面向对象：属性和行为
4、this指针：指向本对象的指针，在编译时期加上的。5、自动加this指针的三种情况：
普通成员方法的第一个参数，默认加上this指针

void work(/* Person *this */)//每一个成员方法在传参的时候都会默认传一个this指针
	{
		//this = NULL;
		cout << _name << ":work" << endl;//默认加上this的解引用 this->_name

在普通成员方法内使用到普通成员的地方，加上this->

void work(/* Person *this */)
	{
		cout << _name << ":work" << endl;//默认加上this的解引用 this->_name
		eat();//this->_eat;
	}
	void eat()
	{
		cout << _name << "eat" << endl;
	}

在调用成员方法的时候加上参数this指针

void work(/* Person *this */)//每一个成员方法在传参的时候都会默认传一个this指针

6、构造函数
构造函数的作用：类对象被创建的时候，编译系统为对象分配内存空间，并自动调用该构造函数，有构造函数完成成员的初始化工作，所以构造函数的作用就是初始化对象的数据成员。
构造函数的分类：

• 无参构造函数
• 待默认值的构造函数
• 有参的构造函数
• 拷贝构造函数
  • 拷贝构造函数是用一个已存在的对象给另一个已经生成对象初始化的时候自动调用的成员方法
    如果没有自己实现，系统会自动生成一个浅拷贝函数
    注意：拷贝构造一定要传引用，防止死递归。

当对象进行调用的时候，默认调用的成员方法。
构造函数名和类名一致，没有返回值。
如果没有实现构造函数，系统会生成一个默认构造函数(除了this指针以外没有参数的构造函数)。
当自己实现了构造函数之后，系统就不会用默认构造函数了。

7、析构函数
析构函数(没有参数)：对象生存周期满了之后，自动调用的函数
~+名字就是析构函数
先构造的后析构(因为栈帧空间是先开辟的，在底层，析构函数时从栈帧上部向下寻找）
析构函数如果没有自己实现，系统会默认生成一个析构函数，但什么都不做，一旦自己实现，就不会生成了
8、等号运算符重载
当使用一个已存在的对象，给另一个已存在的对象赋值时候自动调用的成员方法。
如果不自己实现 ,就会自动生成一个浅拷贝的等号运算符重载函数。
综合程序：

class Person
{
public:
	int _age;
	int _sex;
	char* _name;//成员属性
	Person()//无参数构造
	{
		_name = NULL;
		cout << "Person()" << endl;
	}

	Person(int age)//一个参数构造
	{
		cout << "Person(int age)" << endl;
		_age = age;
		_name = NULL;
	}
	Person(int age, int sex,const char* name)//多参数构造
	{
		cout << "Person(int age, int sex,  char* name)" << endl;
		_age = age;
		_sex = sex;
		//_name = name;//浅拷贝 指针给指针赋值
		//深拷贝
		_name = new char[strlen(name) + 1];
		memset(_name, 0, strlen(name) + 1);
		for (int i = 0; i < strlen(name); i++)
		{
			_name[i] = name[i];
		}
	}
	Person(const Person& src)//拷贝构造
	{
		cout << "Person( Person src)" << endl;
		_age = src._age;
		_sex = src._sex;
		//预防浅拷贝
		if (NULL != src._name)
		{
			_name = new char[strlen(src._name) + 1];
			memset(_name, 0, strlen(src._name) + 1);
			for (int i = 0; i < strlen(src._name); i++)
			{
				_name[i] = src._name[i];
			}
		}
		else
		{
			_name = NULL;
		}
	}
	Person& operator=(const Person& src)//等号运算符重载
	{
		cout << "void operator=(const Person& src)" << endl;
		//防止自赋值 
		if (this == &src)
		{
			return *this;
		}
		//防止内存泄漏
		delete[]_name;
		//防止浅拷贝
		if (NULL != src._name)
		{
			_name = new char[strlen(src._name) + 1];
			memset(_name, 0, strlen(src._name) + 1);
			for (int i = 0; i < strlen(src._name); i++)
			{
				_name[i] = src._name[i];
			}
		}
		else
		{
			_name = NULL;
		}
	}

	
	~Person()//析构函数
	{
		if (NULL != _name)
		{
			cout << _name << endl;
		}
		cout << "~Person()" << endl;
		if (NULL != _name)
		{
			delete[]_name;
		}
		_name = NULL;
	}
	void work(/* Person *this */)//每一个成员方法在传参的时候都会默认传一个this指针
	{
		//this = NULL;
		cout <<_name<<":work" << endl;//默认加上this的解引用 this->_name
		eat();//this->_eat;
	}
	void eat()
	{
		cout << _name<<"eat" << endl;
	}
	void show()
	{
		if (NULL != _name)
		{
			cout << "name:" << _name << endl;
		}
		cout << "age:" << _age << endl;
		cout << "sex" << _sex << endl;
	}
};
//
Person fun(Person& p)
{
	int a = 10;
	Person tmp(10);
	return tmp;//返回一个对象 不可以返回引用，函数调用结束之后，底层指针就会变为野指针
}

    Person(const Person src)//实参构造形参需要调动拷贝构造，循环往复
	{
		_age = src._age;
		_sex = src._sex;
		_name = new char[strlen(src._name) + 1];
		memset(_name, 0, strlen(src._name) + 1);
		for (int i = 0; i < strlen(src._name); i++)
		{
			_name[i] = src._name[i];
		}
	}
	char name[] = { "zhangsan" };
	Person p1(32, 1, name);
	Person p2(p1);//拷贝构造
	p1.show();
	p2.show();

9、权限
public
private
class中默认权限是private
struct中默认的权限是public
权限选择：
必须要对外界提供的，就放在public，其他的都放在private
一般成员属性都放在private，如果外界需要使用就提供公有接口。
附：
初始化-----在定义的时候给值，内存划分时候给值
赋值------定义之后给值，内存划分完之后给值
10、初始化列表
初始化列表
只有构造函数有初始化列表
必须初始化的成员需要放在初始化列表
在本对象构造之前需要完成的动作，必须放在初始化列表
const 成员必须放在初始化列表
11、const成员函数
常对象在定义对象时就就指定对象为常对象，常对象中的数据成员为常变量且必须要有初始化。

p1 const t1(10,89,90);//也可以把const放在类名前边

常对象只能调用常成员函数-----构造函数，析构函数，静态函数不影响
这样做是为了非const型的成员函数书可以修改常对象中的数据成员的值，因为常成员函数是不可以修改对象中的数据成员的值的。
常成员函数中只能调用常成员函数—静态函数不影响
常成员函数定义方法：

void Person()const;

哪些成员函数需要写成常成员函数？
1、如果成员函数内不需要改动成员，并且没有对外暴露成员引用或者指针，则可以直接写成常成员函数。
2、如果成员方法内部不需要改动成员，但是对外暴露成员引用或者指针，就写成两个成员函数(const和非const方法),形成重载。
3、如果成员方法内部需要改动成员，就写成普通方法。
12、static
静态成员变量

• 静态成员在一个类只有一份，无论构造多少对象，都只有一份;
• 存储在数据段; 必须在类外的 .cpp文件中进行初始化，且只能初始化一次;
• 静态成员变量的访问可以不依赖于对象–不依赖于this指针，使用类的作用域可以直接访问;
• 静态成员变量属于整个类
• 静态成员变量的生命期不依赖于任何对象，为程序的生命周期
• 静态成员变量需要在类外单独分配空间且初始化必须在类外

static int value;

静态成员函数

• 静态成员函数没有this指针;
• 静态成员函数的访问可以不依赖于对象–不依赖于this指针，使用类的作用域可以直接访问;
• 静态成员方法内只能使用静态成员;
• 静态成员函数只能直接访问类的静态成员变量和静态成员函数
• 可以通过对象名、类名直接访问类的公有静态函数

static int Person();

//单例模式
//要求：限制只能产生一个对象
//在项目中任意地方都可以获取这个唯一的对象
class Only
{
public:
	static Only* get_Only()
	{
		if (NULL == _only)
		{
			_lock.lock();
			if (NULL == _only)
			{
				_only = new Only();
			}
			_lock.unlock();
		}
		return _only;
	}
	
private:
	Only();
	static mutex _lock;
	static Only* _only;
};
Only* Only::_only = NULL;
mutex Only::_lock = mutex();

单例模式在此处不做介绍，详解链接：https://blog.csdn.net/zhanghuaichao/article/details/79459130