C++的三大特性 ，封装、继承、多态？（一）

C++的三大特性：封装、继承、多态。

一、封装：将属性和行为作为一个整体，表现生活中的事物。一般来说就是把变量和函数一起放在一个类里，此时变量叫做成员变量，函数叫做成员函数。

封装的意义一：将属性和行为作为一个整体，表现生活中的事物。

 1 #include<iostream>
 2 using namespace std;
 3 
 4 //求圆的周长
 5 const double pi = 3.14;
 6 
 7 class circle
 8 {
 9 public:
10     int m_r;
11     double calculate()
12     {
13         return 2 * pi * m_r;
14     }
15 
16 };
17 int main()
18 {
19     //类与对象，通过类实例化一个对象，c1就是具体的圆
20     circle c1;
21     c1.m_r = 10;
22     cout << "圆的周长为：" << c1.calculate() << endl;
23     return 0;
24 }

封装的意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

1.public    公共权限：类内类外都可以访问

2.protected  保护权限：类外不可以访问 ，类内可以访问   子类（派生类）可以访问基类中的保护内容

3.private   私有权限 ：类外不可以访问，类内可以访问  ，子类也不可以访问父类的私有内容。

 1 #include<iostream>
 2 using namespace std;
 3 
 4 class person
 5 {
 6 public:
 7     //公共权限 ，让类外的也可以访问
 8     string m_Name;  //姓名
 9 
10 protected:
11     //保护权限 ，不想让类外访问，但想让子类可以访问
12     string m_Car;
13 
14 private:
15     //私有权限 ，只想让类内的可以访问，类外和子类都不可以访问
16     string m_Password;
17 
18 public:  //类内有的一个函数，public,protected,private 都可以访问
19     void func()
20     {
21         m_Name = "张老三";
22         m_Car = "拖拉机";
23         m_Password = "123456";
24         cout << m_Name << endl;
25         cout << m_Car << endl;
26         cout << m_Password << endl;
27     }
28 };
29 int main()
30 {
31     person p;  //用person类实例化一个对象p,类对象(属于类外）只能访问自己类的public成员，不能访问protected,private成员。
32     p.m_Name = "李四";
33     //p.m_Car = "奔驰";//报错，不可访问
34     //p.m_password = "123";
35 p.func();
36 
37     return 0;
38 }

注意：虽然把成员变量和成员函数放在已给类里，但类内的成员变量和成员函数是分开存储的，只有非静态成员变量才是属于类的对象上。非静态成员函数，
静态成员函数，静态成员变量都不属与类的对象上。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class  person
 5 {
 6 
 7 };
 8 class person2
 9 {
10     int  m_A;  //非静态成员变量 属于类的对象上
11 
12     void func(){} //非静态成员函数 ，不属于类对象上
13 
14     static int m_B; //静态成员变量 不属于类对象上
15     static void  func2(){}  //静态成员函数  也不属于类对象上。
16 };
17 int person2::m_B = 0;
18 int main()
19 {
20     person p;
21     //空对象占用内存空间为：1 
22     //C++编译器回个每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
23     //每个空对象也站有一个独一无二的内存地址。
24     cout << sizeof(p) << endl; //输出为：1
25     
26     person2 p2;
27     cout << sizeof(p2) << endl;  //输出为：4,只有普通成员变量才是属于类对象上的
28     return 0;
29 }

既然成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码，那么这一块代码是如何区分
是哪个对象调用自己呢？
那就用到this指针，this指针指向被调用的成员函数所属的对象（谁调用，就指向谁）。
this指针的用途：
　　1.当形参和成员变量同名时，用this指针来区分。
　　2.在类的非静态成员函数中返回对象本身，可使用return *this。

 1 #include <iostream>
 2 using namespace std;
 3 
 4 //this指针的用途
 5 
 6 class person
 7 {
 8 public:
 9     person(int age)
10     {
11         //当形参和成员变量同名时，可用this指针来区分
12         this->age = age;
13     }
14 
15     person& personAddPerson(person p)
16     {
17         this->age += p.age;
18         //返回对象本身
19         return *this;
20     }
21     int age;
22 };
23 
24 int main()
25 {
26     person p1(10);
27     cout << "p1.age:" << p1.age << endl;  //10
28 
29     person p2(10);
30     p2.personAddPerson(p1).personAddPerson(p1).personAddPerson(p1);
31     cout << "p2.age:" << p2.age << endl;  //40
32     return 0;
33 }