C++的封装

c++中的类可以看做c语言结构体的升级版

是一个面向对象思想化的结构体

c++的类中可以装很多东西

包括变量，指针，函数等

• c++类的权限概念：

        首先：所有权限等级下的东西本类内都可以访问到；

public：共有权限，可以直接通过对象访问，子类成员可以访问

protected：保护权限，不可以直接通过对象访问，子类成员可以访问

private：私有权限，不可以直接通过对象访问，子类成员不可以访问

注：struct默认权限为共有public，class默认权限为私有private

示例：

class Student
{
public:            //公共权限

        void setStudent(string str, int num)
       {
                name = str;
                Id = num;
        }

        void printStudent()
       {
                cout << "name: " << name << endl;
                cout << "Id: " << Id << endl;
        }


protected:        //保护权限

        string name;


private:          //私有权限

        int Id;
};

上面的类中，我们无法直接通过对象直接改变保护权限和私有权限的函数或者变量

要直接访问的东西，就需要将它写在共有权限中（或者友元）

• 创建对象，赋值，打印操作：

void test1()
{
    Student s;
    //这是一种创建对象的方式，不做初始化

    s.setStudent("老六", 12138);
    //调用setStudent函数，直接传值即可

    s.printStudent();
    //调用打印函数
}

• 构造函数和析构函数

        默认情况下，c++至少给一个类添加3个函数
        1，默认构造函数
        2，默认析构函数
        3，默认拷贝构造函数

        简单来说，构造函数的作用是为用户初始化类内的数据，析构函数作用就是为了对象销毁时做收尾工作。

构造函数：初始化改类
用户未定义时系统会自动添加一个内容为空的构造函数
无返回值也不写void
函数名与类名相同
可以有参数，可以发生重载

析构函数：销毁
用户未定义时系统会自动添加一个内容为空的析构函数
无返回值也不写void
函数名称前加~
不能有参数，无法重载

一般在类内有开辟堆区空间时要写一个析构函数，专门用以释放内存。

class text1
{
public:
	text1()
	{
		cout << "构造函数" << endl;
	}

	~text1()
	{
		cout << "析构函数" << endl;
	}

};

        无参构造函数：用户写了一个之后，相当于重载系统自带的版本，之后的无参构造就会调用这个构造函数。

        有参构造函数：是构造函数的重载，用户可以传值来实现对象的初始化

        拷贝构造函数：是构造函数的重载，可以用传入其他对象来实现对象的初始化

        注：

        若用户定义了有参构造函数，c++不再提供默认无参构造，但是会提供默认拷贝构造
        若用户定义拷贝构造函数，c++不再提供其它任何构造函数

class Student
{
public:
	Student()
	{
		cout << "构造函数" << endl;
	}

    //有参构造函数
	Student(int x)
	{
		cout << "有参构造函数" << endl;
		age = x;
	}

	//拷贝构造函数
	Student(const Student& p)
	{
		cout << "拷贝构造函数" << endl;
		age = p.age;
	}

	~Student()
	{

		cout << "析构函数" << endl;
	}

private:
	int age;
};

void test2()
{
	Student p;

	//有参构造函数调用
	Student p1(10);

	//拷贝构造函数调用：
	Student p3(p1);
	//同时使用对象作为函数返回值时，会自动调用拷贝构造函数

	//显示法初始化：
	Student p4 = Student(10);

	//匿名对象法，一般由别的对象里面的指针管理，一般做套娃管理
	Student (5);

	//隐式转换法：
	//Student p5 = 10;
	//相当于 Student p4 = Student(10)
}

• c++可以类内声明函数，类外实现函数，在做这种操作时需要给函数加上作用域

class Point
{
public:
	void setX(int x);

    int getX();
private:
	int m_X;
};

void Point::setX(int x)    //setX前面这一坨，就是作用域
{
	m_X = x;
}

int Point::getX()
{
	return m_X;
}

• this指针在类内时指向该类自身，可以通过this指针区分 类的变量 和 其他变量，解决名称冲突，也可以当作一个指向本类的指针，解引用后可以当作类本身使用。

class Person
{
public:
	Person(int age)
	{
		this->age = age;	//this指针，解决名称冲突
	}
	void addAge(int num)
	{
		if (!this->age)
		{
			return;
		}
		age += num;		
		//类中调用自身成员变量默认给前面加一个this
		//相当于this.age += num;
	}

	Person& personAdd(Person &p) //传入另一个实例化的对象
	{
		this->age += p.age;
		return *this;            //可以解引用后返回引用，其作用就是返回这个类本身
	}

private:
    int age;
};