C++之封装学习总结

1、C++类的封装

C++类的定义格式如下

class classname
{
public:
	/*code*/
protected:
	/*code*/
private:
	/*code*/
};

访问权限

1. public

定义在这个权限下的变量和函数，都是可以直接通过对象名访问在这个权限下的所有变量和函数。这个权限下一般定义函数。

2. protected

定义在这个权限下的变量和函数，通过对象名是不能直接访问其变量和函数，但是派生类是可以访问里面的变量和函数的。
提示：派生类也就是子类，是通过继承基类得来的，基类又可以称为父类。

3. private

定义在这个权限下，对象是不能访问其变量和函数，派生类也不可以访问其变量和函数。这个权限下一般定义的是变量，是为了保护对象的变量不会被随意的改变。也是为了其封装。

构造函数

1.无参构造函数

构造函数：对类的实例（对象）的变量赋初始值。
构造函数是没有返回值的，它的函数名必须与类名保持一致

class People
{
public:
	People()
	{
	
	}
private:
	string name;
	int age;
}

这个就是无参构造函数，函数不需要参数，没有任何需要传入的参数。

2.全参构造函数

class People
{
public:
	People(string _name,int _age)
	{
		name = _name;
		age = _age;
	}
private:
	string name;
	int age;
}

3.拷贝构造函数

class People
{
public:
	People(const People &p)
	{
	/*code*/
	}
private:
	string name;
	int age;
}

拷贝构造函数的使用常见有以下几种

void show(People p)
{/*code*/}
People getPeople()
{
	/*code*/
	People p;
	return p;//3、隐式调用拷贝函数
}
int main()
{
	//在栈区上创建一个变量
	People p1;
	People p2 = p1;//1、隐式调用拷贝构造函数
	People p3;
	show(p3);//2、隐式调用拷贝构造
	People p4(p2);//4、显示调用拷贝构造函数
}

1. 当需要给一个创建对象赋初始值时。
2. 当作为参数传入函数时。
3. 当函数返回值为这个类型时。
4. 当然还可以显示调用拷贝构造函数

---

4.初始化列表

class People
{
public:
	People(string _name,int _age) : name(" "),age(0)//初始化列表，c++11特性
	{
		name = _name;
		age = _age;
	}
private:
	string name;
	int age;
}

5、析构函数

class People
{
public:
	//析构函数
	~People()
	{
		/*code*/
	}
private:
	string name;
	int age;
}

析构函数一般是在对象销毁时，程序自动调用的函数，其目的是为了释放创建对象时所使用的堆区内存。

6、this指针

当对象调用非静态成员函数时，编译器会把对象名取地址传入到所调用函数参数当中

class People
{
public:
	void show()
	{
		cout << this-> name <<endl;
		cout << this->age <<endl;
	}
private:
	string name;
	int age;
}

int main()
{
	People p;
	p.name = "jack"
	p.age = age;
	p.show()
	//这个函数实际上是show(&p)这样调用的，其中&p就是一个this指针
}

static修饰成员变量和成员函数

修饰成员变量

当修饰成员变量时，这个成员变量是放在私有权限（private）下(本文偷个懒，就放在pubilc权限下)，这样就可以通过类名直接访问

class People
{
public :
	//类里面声明静态变量
	static int static_var;
}
//类外面定义静态变量
People::static_var = 100;
int main()
{
	//直接通过类名访问变量
	cout << People::static_var << endl;
}

修饰成员函数

当修饰成员变量时，这个成员变量建议是放在公用权限（public）下，这样就可以通过类名直接访问

class People
{
public :
	//类里面声明成员静态函数
	static int show();
}
//类外面定义静态函数
int People::show()
{
	/*code*/
}
int main()
{
	//直接通过类名访问变量
	cout << People:: << endl;
}

const修饰成员变量、成员函数和对象

修饰成员变量

用const修饰的成员变量是不可以被修改的，只能读取。当试图修改时，编译器会报错。

修饰成员函数

claass People
{
public:
	static int static_i;
	void show() const;
	int getAge() const;
	void setAge();
private:
	int age;
}
People::static_i = 100;
void People::show() const
{
	getAge()//正确，const修饰函数可以调用const修饰的函数
	setAge()//错误，const修饰的函数不能调用非const函数
	static_i = 200//正确，const修饰的函数可以修改静态成员变量
}
int getAge() const
{
	return age;
}
int setAge(int age;)
{
	this->age = age；//通过this指针访问成员变量
}

const修饰的函数可以调用const修饰的函数，但不能调用非const修饰的函数。
const修饰的函数不能修改成员变量

修饰对象

int main()
{
	People p1;
	
	//只能调用const修饰的成员函数，不能调用非const成员函数
	const People p2;
}

友元函数与友元类

当一个函数想调用类的私有成员变量时，可以先在类中声明为有缘函数，这样，这个函数就可以通过对象直接访问其私有变量。
但是这样做就破环了类的封装性，不建议使用。
这个常用于 重载操作符函数当中的一部分。

class People
{
public :
	friend void show(People &p);
private:
	int age;
}
void People::show(People &p)
{
	cout << p.age << endl; 
}

内联函数

关键字 inline
如果在函数头加上这个关键字，就相当于告诉编译器，当调用这个函数时，直接把函数内容复制到函数调用所在的地方，不用调用，节约调用所带来的例如上下文切换带来的额外的开销（时间）。
如果加在成员函数上时，相当于告诉编译器不用去别的文件找这个成员函数的定义，我这里就有。

运算符重载

关键字 operator

void operate/*需要运算符*/ （/*参数*/）