C++：面向对象

面向对象

• 构造函数
• 析构函数
• 拷贝构造
• 等号运算符重载
• 静态成员和静态成员方法

#include<iostream>
#include<vld.h>
using namespace std;


//面向过程
//面向对象：对象-类//将变量和函数封装
//四大特征：抽象，封装，继承，多态

//struct默认属性public
//class默认属性private

int school = 985;

class Person
{
private:

	char* _name;
	int _age;
	int _sex;

	//含有必须初始化的成员变量，需要加入初始化列表，进行初始化
	//运算符重载无法包含初识化列表
	const int _id;
	int& _school;

	//静态成员在类外进行初始化
	static int _n;

public:

	//类中只存在一个静态成员，类共用，不属于单独对象
	//必须在类外进行初始化
	//静态成员访问不依赖于this指针，即不依赖于成员
	static int _num;


	//构造函数，构造对象时调用，必须存在一个构造函数
	//没有构造函数会自动生成一个无参数的默认构造函数
	//构造函数允许重载
	Person()
		:_id(1),_school(school)//初始化列表
	{
		_num++;
	}

	Person(const char* name, int age, int sex)
		:_id(1), _school(school)
	{
		_name = new char[strlen(name) + 1];
		for (int i = 0; i <= (int)strlen(name); i++)
		{
			_name[i] = name[i];
		}

		_age = age;
		_sex = sex;

		_num++;
	}

	//拷贝构造函数
	/*//浅拷贝，系统默认生成浅拷贝的构造函数，_name指向同一内存，析构释放时会发生重复释放
	Person(Person& src)
	{
		_name = src._name;
		_age = src._age;
		_sex = src._sex;
	}*/
	//深拷贝
	Person(const Person& src)//需要传递引用，直接传递对象，形参也许要调用拷贝构造，陷入循环
		:_id(1), _school(school)
	{
		_name = new char[strlen(src._name) + 1];
		for (int i = 0; i <= (int)strlen(src._name); i++)
		{
			_name[i] = src._name[i];
		}
		_age = src._age;
		_sex = src._sex;

		_num++;
	}

	//等号运算符重载
	/*//系统默认生成浅拷贝的等号运算符重载函数
	void operator=(const Person& src)
	{
		_name = src._name;
		_age = src._age;
		_sex = src._sex;
	}*/
	
	//增加返回值，实现连等于
	Person& operator=(const Person& src)
	{
		if (&src != this)//当自赋值，即对象等于自己时，会释放原来的空间，变成野指针
		{
			delete[]_name;//重载后需要释放原来的内存空间

			_name = new char[strlen(src._name) + 1];
			for (int i = 0; i <= (int)strlen(src._name); i++)
			{
				_name[i] = src._name[i];
			}
			_age = src._age;
			_sex = src._sex;

		}

		return *this;//解引用，返回当前对象
	}

	//成员方法
	//this指针，指向当前对象的指针
	//在当前对象被成员方法使用、调用的时候，自动加载
	void Eat()const//eat(Person* this)
	{
		cout <<_name<< ": eat ……" << endl;//this->_name
	}
	void Walk()const
	{
		cout <<_name<< ": walk ……" << endl;
	}
	void Show()const
	{
		cout << _name << ", " << _age << ", " << _sex << endl;
	}

	char* Get_name()//提供成员方法访问private成员
	{
		return _name;
	}
	const char* Get_name()const//成员方法重载，const限定不能修改成员
	{
		return _name;
	}

	static int Get_n()//提供静态成员方法访问private静态成员，但是不能访问其他成员，没有特定对象
	{
		return _n;
	}

	//析构函数，对象生存周期结束，被销毁时自动调用
	//必须存在一个析构函数，没有析构函数会自动生成一个析构函数
	//析构函数无参数，不能重载
	/*~Person()
	{
		cout << "~Person" << endl;
	}*/
	~Person()
	{
		delete[]_name;

		_num--;
	}
	/*void destory()
	{
		delete[]_name;
	}*/
	
};

int Person::_num = 0;//静态成员初始化
int Person::_n = 0;

int main()
{
	//Person per;//构造Person类型的对象
	//per.Init("zhangsan", 23, 1);
	Person per("zhangsan", 23, 1);

	per.Eat();//per.eat(this), this = &per
	per.Walk();
	per.Show();


	//拷贝构造
	Person per1 = per;
	//Person per1(per);
	per1.Show();


	//等号运算符重载
	per = per1;

	Person per2;
	per2 = per;

	per = per;

	per1 = per2 = per;//从右向左


	//静态成员的访问，private属性不可访问
	cout << Person::_num << endl;
	cout << per._num << endl;
	//cout << Person::_n << endl;

	//不能通过类作用域直接调用非静态的成员方法，缺少特定对象，需要使用静态的成员方法
	cout << Person::Get_n() << endl;
	cout << per.Get_n() << endl;

	//const成员调用成员方法，可以在成员方法参数列表的末尾加const，限定this指针
	const Person per3("lisi", 22, 1);
	per3.Show();
	//成员方法不修改成员，使用const
	//不一定修改的成员方法，提供重载


	return 0;
}

单例模式

• 只能产生一个对象，任何位置都能访问

class Only
{
public:
	static Only* Get_Only()//静态成员方法
	{
		if (NULL == _Only)
		{
			_Only = new Only();
		}

		return _Only;
	}
	
private:
	static Only* _Only;//静态成员

	Only()//构造函数
	{

	}
};

Only* Only::_Only = NULL;//静态成员初始化