• C++笔记：类和对象(一)-＞封装

    类和对象

            认识类和对象

             先来回忆一下C语言中的类型和变量，类型就像是定义了数据的规则，而变量则是根据这些规则来实际存储数据的容器。类是我们自己定义的一种数据类型，而对象则是这种数据类型的一个具体实例。类就可以理解为类型，而对象就可以理解为变量，而且对象是更加高级的变量。

            类型 = 类型数据 + 类型操作

            比如double类型

            他的数据类型占用8字节，并且可以表示成小数。

            类型操作可以加减乘除，但是它不支持模(%)运算。

            那么类就是包含了类型数据和类型操作的一个集合。

            也可以理解为数据就是类的属性，操作就是类的行为

            通过下面我定义的一个人的类，那么height,sex, age都是这个类的类型数据，而类型操作就是函数run和函数speak。

    1. class People {
    2.     double height;//身高
    3.     char sex;//性别
    4.     int age;//年龄
    5.     string name;//姓名
    6.     void run() {//跑
    7.         cout << "I can run" << endl;
    8.     }
    9.     void speak() {//说话
    10.         cout << "I can speak" << endl;
    11.     }
    12. };

            那么我需要一个特定的人的时候，我就需要定义一个对象用来存这个特定人的属性。

            下面的用类定义一个对象，并且对他的属性进行赋值。

    1. People a;
    2. a.name = "Zhang san";
    3. a.age = 18;
    4. a.sex = '1';//女0，男1
    5. a.height = 1.89;

            而我需要这个人进行说话或者跑时，就需要调用他相应的操作，也就是函数。

    1. a.run();
    2. a.speak();

            访问权限

            public：是公共的资源，是谁都可以访问的资源，比如空气，阳光，公共场合都是谁都可以访问进行使用的。

            private：是私有的资源，是只能类自己进行访问的资源，比如每个人自己的私人物品，是只能自己使用和访问的。

            protected：是受保护的资源，是只能自己访问以及自己的子类访问的资源，比如你儿子可以使用你的东西。(在后续文章继承时会用到protected权限)

            friendly：是在关键字friend声明后，它允许被声明后的类或函数访问这一个类的私有或受保护的资源，比如你的好兄弟在你的允许下可以访问和使用你的私人物品。(在后续的文章中会更新到使用)

            重点：这里的访问权限是规定的类外对该类类内的访问权限。

            比如我在一个类中定义了一个访问权限为私有的方法，那么我只能在这个类的内部进行调用，在类外是无法调用的，除非我对这个方向进行了friend友元声明。

            对于为什么要为什么要有访问权限的设置，看如下代码：

    1. #include
    2. using namespace std;
    3.  
    4.  
    5. class People {
    6. public :
    7. int age;
    8.     void speak() {
    9.         cout << "my age is "<< age << endl;
    10.         return ;
    11.     }
    12. };
    13.  
    14.  
    15. int main() {
    16.     People a;
    17.     a.age = -100;
    18.     a.speak();
    19.     return 0;
    20. }

            如果对于age是public公有访问的，那么在设置年龄的将不会受到限制，对于这份代码可能没有问题，如果在以后设计项目或者工程时，就会造成灾难性的错误。

            那么正确的写法应该如下，把age设置为私有的，对age赋值时，定义一个函数来进行对age赋值，并判断值是否在正确范围内，对于获取age值也定义一个函数进行来获取。

    1. #include
    2. using namespace std;
    3.  
    4.  
    5. class People {
    6. public :
    7.     void speak() {
    8.         cout << "my age is "<< age << endl;
    9.         return ;
    10.     }
    11.     void set_age(int x) {
    12.         if (age <= 0 || age > 1000) {
    13.             perror("your age is error\n");
    14.             exit(1);
    15.         }
    16.         age = x;
    17.         return ;
    18.     }
    19.     int get_age() {
    20.         return age;
    21.     }
    22. private :
    23.     int age;
    24. };
    25.  
    26.  
    27. int main() {
    28.     People a;
    29.     a.set_age(-100);
    30.     a.speak();
    31.     return 0;
    32. }

    构造函数和析构函数

            定义一个对象的流程：

         对于构造函数的详细解析如下代码：

    1. #include
    2. using namespace std;
    3.  
    4. class A {
    5. public :
    6.     A() {//默认构造函数
    7.         cout << "default constructor" << endl;
    8.     }
    9.     //如果这里没有const关键字,传入的对象是const声明的那么就会报错
    10.     //如果没有&(引用),那么将会造成无限套娃的拷贝构造
    11.     //假如这里没有&，那么这里的形参就相当于实参给他赋值
    12.     //而赋值就是 A a = b, b是实参传入的值
    13.     //那这里就会又调用构造函数,形成无限套娃
    14.     A(const A &a) {
    15.         this->x = a.x;
    16.         this->y = a.y;
    17.         cout << "copy constructor" << endl;
    18.     }
    19.     A(int x, int y) {//有参构造函数
    20.         cout << "have parameter constructor" << endl;
    21.         this->x = x;//this表示当前对象的地址
    22.         this->y = y;
    23.     }
    24.     void operator=(const A &a) {//这个函数是=运算符重载，是类中默认有的
    25.         cout << "this is assigment"  << endl;
    26.         return ;
    27.     }
    28.     A(int x) {//转换构造函数
    29.         cout << "conversion constructor" << endl;
    30.         this->x = x;
    31.         this->y = 0;
    32.     }
    33.     void output() {
    34.         cout << "(" << x << ", " << y << ")" << endl;
    35.     }
    36.     ~A() {//析构函数
    37.         cout << "destructor" << endl;
    38.     }
    39. private :
    40.     int x, y;
    41. };
    42.  
    43.  
    44. void func(A a) {
    45.     cout << "func : ";
    46.     a.output();
    47.     return ;
    48. }
    49.  
    50.  
    51. int main() {
    52.     A a;//调用默认构造函数
    53.     cout << "1-------------------------" << endl;
    54.     A b(1, 2);//调用有参构造
    55.     cout << "2-------------------------" << endl;
    56.     //这里就调用了拷贝构造函数
    57.     A e = b;
    58.     cout << "3-------------------------" << endl;
    59.     //这里只是运用了普通赋值运算符
    60.     //通过执行会发现没有执行任何构造函数
    61.     a = b;
    62.     cout << "4-------------------------" << endl;
    63.     //调用转换构造，将int类型转换为A类型
    64.     //这里也可以是另一个类型的对象，那也是转换构造
    65.     //不过还需要从新定义一个需要转换构造的函数,里面的参数就是对应的类型
    66.     A c(3);
    67.     cout << "5-------------------------" << endl;
    68.     //这里调用的是拷贝构造函数，将对象b进行拷贝给函数形参a
    69.     func(b);
    70.     func(c);
    71.     cout << "6-------------------------" << endl;
    72.     //对于这中函数调用情况
    73.     //这里就会用到转换构造
    74.     //他会隐式的将int类型5通过转换构造转会为A类型
    75.     func(5);
    76.     cout << "7-------------------------" << endl;
    77.     //这里相当于A d(4);
    78.     //这里可以这样理解
    79.     //等号类型相同编程才能通过
    80.     //那么4，int类型就会通过转换构造变成A类型
    81.     //如果没有转换构造那么就编译无法通过
    82.     A d = 4;
    83.     a = 6;
    84.     cout << "8-------------------------" << endl;
    85.     return 0;
    86. }

    构造函数的初始化列表

    构造函数中的初始列表使用：

    1. #include
    2. using namespace std;
    3.  
    4. class C {
    5. public:
    6.     C(int n) {
    7.         this->num = n;
    8.         cout << "C coversion constructor" << endl;
    9.     }
    10.     void output() {
    11.         cout << num;
    12.     }
    13. private :
    14.     int num;
    15. };
    16.  
    17. class A {
    18. public :
    19.     //:后面是构造函数的初始化列表
    20.     A(int a) : a(a), b(10), c(6) {
    21.         cout << "A constructor" << endl;
    22.     }
    23.     void output() {
    24.         cout << " " <" " << b << " ";
    25.         c.output();
    26.         cout << endl;
    27.         return ;
    28.     }
    29. private :
    30.     int a, b;
    31.     C c;
    32. };
    33.  
    34.  
    35. int main() {
    36.     A a(2);
    37.     a.output();
    38.     return 0;
    39. }

    构造函数和析构函数的调用顺序

    如下这份代码：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5.  
    6. class A {
    7. public :
    8.     A() {};
    9.     A(string n)  {
    10.         name = n;
    11.         cout << name << " class A construtor" << endl;
    12.     }
    13.     ~A() {
    14.         cout << name << " class A destructor" << endl;
    15.     }
    16. int *p;
    17. private :
    18.     string name;
    19. };
    20.  
    21. class B {
    22. public :
    23.     //:a(a)
    24.     //:后面是构造函数时，最该对象中的成员属性进行初始化操作
    25.     B(string n, A &a) : a(a){
    26.         name = n;
    27.         cout << name << " class B construtor" << endl;
    28.         //new关键字可以理解为，C语言中malloc去堆区中开辟一段空间
    29.         a.p = new int[10];
    30.         return ;
    31.     }
    32.     A &a;//创建一个引用属性，这里&a可以暂时理解为取a的地址
    33.     ~B() {
    34.         //delete就相当于C语言中的free对开辟空间的释放
    35.         delete a.p;
    36.         cout << name << " class B destructor" << endl;
    37.     }
    38. private :
    39.     string name;
    40. };
    41.  
    42.  
    43. int main() {
    44.     A a("a");
    45.     B b("b", a);
    46.     return 0;
    47. }

    执行结果：

            可以发现，析构顺序是构造顺序反过来的，通过代码可以发现在B中的有参构造中用到了a对象的引用，然后对a对象的p指针开辟了一段空间，如果析构时顺序和构造顺序一样的那么，在析构b对象时，去delete a.p去释放开辟的空间时，a对象已经被析构掉了，那就也无法去找a对象中的指针p了。

    类属性与方法 

            对于上面的代码的类中，它们只有成员属性和成员方法。

            就拿文章中的第一份代码来看，对于属性，也就是类中的变量，他所存储的值是跟着对象改变而改变的，而类中的两个方法(函数)，也是随着对象改变而改变的，因为它们的输出也是不同的。所以这些叫做成员属性和成员方法。

    1. class People {
    2.     double height;//身高
    3.     char sex;//性别
    4.     int age;//年龄
    5.     string name;//姓名
    6.     void run() {//跑
    7.         cout << name << " can run" << endl;
    8.     }
    9.     void speak() {//说话
    10.         cout << name << " can speak" << endl;
    11.     }
    12. };

     下面这份代码是对成员属性和成员方法的使用：

    1. #include
    2. using namespace std;
    3.  
    4.  
    5. class Point {
    6.     public :
    7.  
    8.     Point() : x(0), y(0) {} //默认构造
    9.     //区分x和y
    10.     //在x(x),括号外是成员属性x,括号内是形参x
    11.     Point(int x, int y) : x(x), y(y) {} //有参构造
    12.     void set_x (int x) { this->x = x; }
    13.     void set_y (int y) { this->y = y; }
    14.     int get_x() { 
    15.         //访问类中的类属性
    16.         Point::get_x_cnt += 1;
    17.         return this->x; 
    18.     }
    19.     int get_y() { return this->y; }
    20.     //这里是直接定义了类方法
    21.     static int x_cnt() {
    22.         return Point::get_x_cnt;
    23.     }
    24.     private :
    25.     //这里只是声明了这个变量
    26.     //get_x_cnt,记录变量x在被get时,在整个程序执行时被调用了多少次
    27.     static int get_x_cnt;
    28.     int x, y;
    29. };
    30.  
    31. //这里就是定义了get_x_cnt, 并且给他的值进行了初始化
    32. int Point::get_x_cnt = 0;
    33.  
    34.  
    35.  
    36. int main() {
    37.     Point p1(3, 4), p2(5, 6);
    38.     cout << p1.get_x() << ", " << p1.get_y() << endl;
    39.     cout << p2.get_x() << ", " << p2.get_y() << endl;
    40.     p1.get_x();
    41.     p1.get_x();
    42.     p1.get_x();
    43.     cout << "x_cnt : " << Point::x_cnt() << endl;
    44.     return 0;
    45. }

     const 方法

    对于const和mutable关键字使用，对于上一份代码的修改：

    1. #include
    2. using namespace std;
    3.  
    4.  
    5. class Point {
    6.     public :
    7.     Point() : x(0), y(0) , get_x_cnt(0){} //默认构造
    8.     Point(int x, int y) : x(x), y(y), get_x_cnt(0) {} //有参构造
    9.     void set_x (int x) { this->x = x; }
    10.     void set_y (int y) { this->y = y; }
    11.     int get_x() const { //修改处
    12.         get_x_cnt += 1;
    13.         return this->x; 
    14.     }
    15.     int get_y() const { return this->y; }//修改处
    16.     int x_cnt() const {//修改处
    17.         return get_x_cnt;
    18.     }
    19.     private :
    20.     //现在get_x_cnt，表示当前对象对get_x函数的调用次数
    21.     //mutable关键字表示不收const关键之的限制
    22.     //所以就算有const关键字，那么mutable声明的变量也可以进行修改
    23.     mutable int get_x_cnt;
    24.     int x, y;
    25. };
    26.  
    27.  
    28.  
    29.  
    30. int main() {
    31.     const Point p(10, 15), p2(1, 2);
    32.     cout << p.get_x() << ", " << p.get_y() << endl;
    33.     p2.get_x();
    34.     p2.get_x();
    35.     cout << "p1 : get_x_cnt = " << p.x_cnt() << endl;
    36.     cout << "p2 : get_x_cnt = " << p2.x_cnt() << endl;
    37.     return 0;
    38. }

    类的声明和定义

    还是对类属性和类方法的那份代码进行修改：

    1. #include
    2. using namespace std;
    3.  
    4. //在类中只放方法的声明
    5. class Point {
    6.     public :
    7.     Point();
    8.     Point(int x, int y);
    9.     void set_x (int x);
    10.     void set_y (int y);
    11.     int get_x() const;
    12.     int get_y() const;
    13.     static int x_cnt();
    14.     private :
    15.     static int get_x_cnt;
    16.     int x, y;
    17. };
    18.  
    19. //对于类中的方法进行实现
    20. //那么就可以将这两部分拆开
    21. //定义放在源文件中，声明放在头文件中
    22. Point::Point() : x(0), y(0) {}
    23. Point::Point(int x, int y) : x(x), y(y) {}
    24. void Point::set_x(int x) {
    25.     this->x = x; 
    26. }
    27.  
    28. void Point::set_y(int y) {
    29.     this->y = y; 
    30. }
    31.  
    32. int Point::get_x() const{
    33.     Point::get_x_cnt += 1;
    34.     return x; 
    35. }
    36.  
    37. int Point::get_y() const{
    38.     return y;
    39. }
    40.  
    41. int Point::x_cnt() {
    42.     return Point::get_x_cnt; 
    43. }
    44.  
    45. int Point::get_x_cnt = 0;
    46.  
    47. int main() {
    48.     Point p1(3, 4), p2(5, 6);
    49.     cout << p1.get_x() << ", " << p1.get_y() << endl;
    50.     cout << p2.get_x() << ", " << p2.get_y() << endl;
    51.     p1.get_x();
    52.     p1.get_x();
    53.     p1.get_x();
    54.     cout << "x_cnt : " << Point::x_cnt() << endl;
    55.     return 0;
    56. }

    default和delete关键字

        delete和default关键字引用代码：

    1. #include
    2. using namespace std;
    3.  
    4. class A {
    5. public :
    6.     //A() = delete;
    7.     A() {
    8.         cout << "default constructor" << endl;
    9.     }
    10.     A(int n) : x(n) {
    11.         cout << "conversion constructor" << endl;
    12.     }
    13.     A(const A &) {
    14.         cout << "copy constructor" << endl;
    15.     }
    16. private :
    17.     int x;
    18. };
    19.  
    20. class B {
    21. public :
    22.     B() = default;
    23.     B(const B&) = default;
    24. private :
    25.     A a1, a2, a3;
    26. };
    27.  
    28. class C {
    29. public :
    30.     C() = default;
    31.     //C(const C&) {}//这种情况叫撒比构造
    32.     C(const C&) = default;
    33. private :
    34.     A a1, a2, a3;
    35. };
    36.  
    37. class Point {
    38. public :
    39.     Point() = default;//请求编译器生成默认构造函数
    40.     Point(int x, int y) : x(x), y(y) , p(new int(5)), a(1){}
    41.     //Point(const Point &) = delete;//删除编译器的拷贝构造函数
    42.     //Point(const Point &) = default;//拷贝函数生成默认行为,在使用这个拷贝构造函数时就会造成双重释放的报错
    43.     //这就是深拷贝
    44.     Point(const Point &a) : x(a.x + 1), y(a.y + 2), a(a.a){
    45.         //如果这里成员属性a直接用这样去赋值拷贝
    46.         //那么成员属性a就会使用A类的默认构造函数进行构造
    47.         //而A类的默认构造函数已经被删除了，那么就会报错
    48.         //this->a = a.a;
    49.         this->p = new int;
    50.         *(this->p) = *(a.p);
    51.     }
    52.     ~Point() {
    53.         delete p;
    54.     }
    55. private :
    56.     A a;
    57.     int *p;
    58.     int x, y;
    59. };
    60.  
    61.  
    62. int main() {
    63.     Point p1(1, 2), p2 = p1;
    64.     return 0;
    65. }

     对象和引用

            

    代码演示：

    1. #include
    2. using namespace std;
    3.  
    4. class A {
    5. public :
    6.     A() = default;
    7.     A(const A&) = default;
    8. private :
    9.  
    10. };
    11.  
    12. class B {
    13. public :
    14.     B(A &a) : a(a) {}
    15. private :
    16.     A &a;
    17. };
    18.  
    19. class C {
    20. public :
    21.     C()  = default;
    22.     C(const C &) = default;
    23.     static void destroy(C *c) {
    24.         delete c; 
    25.         return ;
    26.     }
    27. private :
    28.     ~C() {}
    29. };
    30.  
    31. int main() {
    32.     A a;
    33.     B b(a);
    34.     C *c = new C();
    35.     C::destroy(c);
    36.     return 0;
    37. }

    返回值优化

    先回顾一下一个对象是如何进行创建的：

    如下代码：

    1. #include
    2. using namespace std;
    3.  
    4. class A {
    5. public :
    6.     A() {
    7.         cout << this << " default constructor" << endl;
    8.     }
    9.     A(const A &) {
    10.         cout << this << " copy constructor" << endl;
    11.     }
    12.     string s;
    13. };
    14.  
    15. A func() {
    16.     //这里创建temp调用了默认构造
    17.     A temp;
    18.     cout << "temp = " << &temp << endl;
    19.     temp.s = "hello func";
    20.     //return这里会有一个匿名对象
    21.     //然后temp会通过拷贝构造拷贝给这个匿名对象
    22.     return temp;
    23. }
    24.  
    25. int main() {
    26.     //然后这里的a通过拷贝构造，拷贝这个匿名对象
    27.     //那么创建a对象最终会调用
    28.     //一次默认构造，两次拷贝构造对吧
    29.     A a = func();
    30.     cout << "a = " << &a << endl;
    31.     return 0;
    32. }

    执行结果：

    会发现结果只调用了一次默认构造，也就是在调用func函数时创建temp进行调用的默认构造，这就就是编译器进行了返回值优化，可以看到对象a的地址和对象的temp的地址一摸一样都没变，说明中间的这些拷贝过程就是浪费资源。

    那么我在编译时关闭了，返回值优化，再看结果

    和我对于代码的分析是一样的。

    总结：

            对于上面的内容，只是我们在程序设计时需要掌握的知识点，应为没有掌握这些知识点，你也无法去实现你对应思想的代码。

            最后来说一下封装，这篇文章最主要的内容就是封装一个类，在下一篇文章C++类中的重载也是封装的一部分。而封装是什么，在设计代码的过程中，我们回去思考一个类他应该有什么属性，什么行为，然后我们就可以将这些属性和行为封装成为一个类。 对象是在程序运行中主要的逻辑，而类就是用来将对象进行分类的。不同的对象对于不同的类，就有不同的属性和行为，而这种代码设计逻辑就是封装。

            总的来说对于封装，可以理解为现实世界中的人和其他物种，我们具体的每个人就是对象，而人就想当于类，而类就去定义了我们的属性和行为，而不同的人有不同的行为和属性，那就是对象。人类就相当于封装了我们的属性和行为。所以在设计一个类去封装时我们需要考虑的就是他有什么属性，什么行为。

    下个内容：C++笔记：C++中的重载

  • 相关阅读:
    Redis常见命令
    iOS键盘通知弹框使用小结
    智能合约语言（eDSL）—— wasmtime实现合约引擎补充
    【嵌入式C语言】常见数据转化函数
    运维成本降低 50%，丽迅物流是如何应对大规模容器镜像管理挑战的
    【模型推理加速系列】06: 基于resnet18加速方案评测
    易基因｜干货：手把手教你做RNA m5C甲基化测序分析（RNA-BS）
    若依框架解读（微服务版）—— 4.认证，登出（Gateway网关）
    数据库系统概念学习1
    【毕业设计】基于javaEE+SSH+mysql的码头船只出行及配套货柜码放管理系统设计与实现（毕业论文+程序源码）——码头船只出行及配套货柜码放管理系统
  • 原文地址：https://blog.csdn.net/qq_58240849/article/details/137831741