• 【c++】cpp类和对象

    （1）类的封装

    封装的多层含义

    • 把属性和⽅法进⾏封装
    • 对属性和⽅法进⾏访问控制
    • 类的内部和类的外部
    • 类的访问控制关键字
      • public:  修饰的成员变量和函数，可以在类的内部和类的外部访问
      • private:  修饰的成员变量和函数，只能在类的内部被访问，不能在类的外部访问
      • protected:  修饰的成员变量和函数，只能在类的内部被访问，不能在类的外部访问，⽤ 在继承⾥⾯

    案例：设计⽴⽅体类(cube)，求出⽴⽅体的⾯积和体积。求两个⽴⽅体，是否相等（全局函数和成员函数都要实现）。

    1. #include 
    2.  
    3. class Cube
    4. {
    5. public:
    6.     void setA(int a){m_a = a;}
    7.     void setB(int b){m_b = b;}
    8.     void setC(int c){m_c = c;}
    9.     void setABC(int a = 0, int b = 0, int c = 0)
    10.     {
    11.         m_a = a;
    12.         m_b = b;
    13.         m_c = c;
    14.     }
    15.     int getA(){return m_a;}
    16.     int getB(){return m_b;}
    17.     int getC(){return m_c;}
    18. public:
    19.     int getV()
    20.     {
    21.         m_v = m_a * m_b * m_c;
    22.         return m_v;
    23.     }
    24.     int getS()
    25.     {
    26.         m_s = 2 * (m_a * m_b + m_a * m_c + m_b * m_c);
    27.         return m_s;
    28.     }
    29.     int judgeCube(Cube &v1, Cube &v2) //不建议这样写
    30.     {
    31.         if ((v1.getA() == v2.getA()) 
    32.         && (v1.getB() == v2.getB()) 
    33.         && (v1.getC() == v2.getC()))
    34.             return 1;
    35.         return 0;
    36.     }
    37.     int judgeCube(Cube &v2) //成员函数 函数重载
    38.     {
    39.         if ((m_a == v2.getA()) 
    40.         && (m_b == v2.getB()) 
    41.         && (m_c == v2.getC()))
    42.             return 1;
    43.         return 0;
    44.     }
    45. private:
    46.     int m_a;
    47.     int m_b;
    48.     int m_c;
    49.     int m_v;
    50.     int m_s;
    51. };
    52.  
    53. // 全局函数 PK 成员函数
    54. // 1相等 0不相等
    55. int judgeCube(Cube &v1, Cube &v2)
    56. {
    57.     if ((v1.getA() == v2.getA()) 
    58.     && (v1.getB() == v2.getB()) 
    59.     && (v1.getC() == v2.getC()))
    60.         return 1;
    61.     return 0;
    62. }
    63.  
    64. int main()
    65. {
    66.     Cube v1, v2;
    67.     v1.setABC(1, 2, 3);
    68.     std::cout << v1.getS() << std::endl;
    69.     std::cout << v1.getV() << std::endl;
    70.  
    71.     
    72.     // 用成员函数判断两个立方体是否相等
    73.     v2.setABC(1, 2, 4);
    74.     if (v1.judgeCube(v1, v2) == 1)
    75.         std::cout << "v1 = v2" << std::endl;
    76.     else
    77.         std::cout << "v1 != v2" << std::endl;
    78.  
    79.     // 用成员函数判断两个立方体是否相等
    80.     v1.setABC(1, 2, 4);
    81.     if (v1.judgeCube(v2) == 1)
    82.         std::cout << "v1 = v2" << std::endl;
    83.     else
    84.         std::cout << "v1 != v2" << std::endl;
    85.  
    86.     // 用全局函数判断两个立方体是否相等
    87.     if (judgeCube(v1, v2) == 1)
    88.         std::cout << "v1 = v2" << std::endl;
    89.     else
    90.         std::cout << "v1 != v2" << std::endl;
    91.  
    92.     return 0;
    93. }
    94.

    （2）类的声明和实现分开

    设计.h和.cpp，一个声明，一个实现。为了避免同⼀个头⽂件被include多次带来重复编译，头⽂件要么用#ifndef 宏名  #define 宏名  #endif编写头文件，要么用#pragma once。#ifndef由语⾔⽀持移植性更好，推荐使用。

    案例：带有数组成员的类

    myarrray.h

    1. #ifndef _MYARRAY_H_
    2. #define _MYARRAY_H_
    3.  
    4. class Array
    5. {
    6. public:
    7.     Array(int length);
    8.     Array(const Array &obj); //加了const更好
    9.     ~Array();
    10. public:
    11.     void setdata(int index, int value);
    12.     int getdata(int index);
    13.     int getLenth();
    14. private:
    15.     int m_length;
    16.     int *m_space;
    17. };
    18.  
    19. #endif

    myarray.cpp

    1. #include 
    2. #include "myarray.h"
    3.  
    4. //作用域不要忘写
    5. //构造函数
    6. Array::Array(int length)  
    7. {
    8.     if (length < 0){length = 0;}
    9.     m_length = length;
    10.     m_space = new int[length];
    11.     // this->m_length = length;
    12.     // this->m_space = new int[length];
    13. }
    14. //构造函数的重载
    15. Array::Array(const Array &obj) 
    16. {
    17.     m_length = obj.m_length;
    18.     m_space = new int[m_length];
    19.     for (int i = 0; i < m_length; i++)
    20.         m_space[i] = obj.m_space[i];
    21. }
    22. //析构函数
    23. Array::~Array()
    24. {
    25.     if (m_space != NULL)
    26.     {
    27.         delete[] m_space;
    28.         m_space = NULL;
    29.         m_length = -1;
    30.     }
    31. }
    32. //成员函数
    33. void Array::setdata(int index, int value)
    34. {
    35.     if (0 <= index && index <= m_length)
    36.         m_space[index] = value;
    37. }
    38. int Array::getdata(int index)
    39. {
    40.     if (0 <= index && index <= m_length)
    41.         return m_space[index];
    42.     return -1;
    43. }
    44. int Array::getLenth()
    45. {
    46.      return m_length;
    47. }

    main.cpp

    1. #include 
    2. #include "myarray.h"
    3.  
    4. int main()
    5. {
    6.     Array array1(4);
    7.     for (int i = 0; i < array1.getLenth(); i++)
    8.     {
    9.         array1.setdata(i, i + 100);
    10.         std::cout << array1.getdata(i) << "\t";
    11.     }
    12.     std::cout << std::endl;
    13.  
    14.     Array array2 = array1;
    15.     for (int i = 0; i < array2.getLenth(); i++)
    16.     {
    17.         std::cout << array2.getdata(i) << "\t";
    18.     }
    19.     std::cout << std::endl;
    20.  
    21.     return 0;
    22. }

    编译运行

    1. [root@centos1 test]# g++ -o main main.cpp myarray.cpp
    2. [root@centos1 test]# ./main
    3. 100     101     102     103
    4. 100     101     102     103
    5. [root@centos1 test]#

    （3）对象的构造和析构

    定义和调用说明

    1 构造函数定义

    • C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构造函数。
    • 构造函数默认是无参数的，当类中没有定义构造函数时，编译器默认提供⼀个⽆参构造函数， 并且其函数体为空。也可以在定义时自行设计有参数和函数体。
    • 没有任何返回类型的声明。

    2 构造函数的调⽤

    • ⾃动调⽤：⼀般情况下C++编译器会⾃动调⽤构造函数
    • ⼿动调⽤：在⼀些情况下则需要⼿⼯调⽤构造函数

    3 析构函数定义及调⽤

    • C++中的类可以定义⼀个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
    • 语法：~ClassName()
    • 析构函数没有参数也没有任何返回类型的声明
    • 析构函数在对象销毁时⾃动被调⽤
    • 析构函数调⽤机制：C++编译器⾃动调⽤

    有参数的构造函数，构造函数重载，拷贝构造函数

    ⼆个特殊的构造函数：

    • 默认无参构造函数。当类中没有定义构造函数时，编译器默认提供⼀个⽆参构造函数， 并且其函数体为空。
    • 默认拷贝构造函数。当类中没有定义拷⻉构造函数时，编译器默认提供⼀个默认拷⻉构造函数，简单的进⾏成员变量的值复制。

    示例代码

    1. #include 
    2. #include 
    3.  
    4. class Test
    5. {
    6. public:
    7.     Test() //无参数构造函数
    8.     {
    9.         age = 0;
    10.         strcpy(name, "tom");
    11.     }
    12.     Test(int age) //有参数构造函数 //构造函数重载
    13.     {
    14.         this->age = age;
    15.         strcpy(name, "tom");
    16.     }
    17.     Test(int age, char *name) //有参数构造函数  //构造函数重载
    18.     {
    19.         this->age = age;
    20.         strcpy(this->name, name);
    21.     }
    22.     Test(const Test &obj) // 拷贝构造函数
    23.     {
    24.         this->age = obj.age;
    25.         this->name = obj.name;
    26.     }
    27.     ~Test()  //析构函数
    28.     {
    29.         std::cout << "object destroyed" << std::endl;
    30.     }
    31. public:
    32.     void printT()
    33.     {
    34.         std::cout << "name = " << name << std::endl;
    35.         std::cout << "age = " << age << std::endl;
    36.         std::cout << "---------------" << std::endl;
    37.     }
    38. private:
    39.     char *name = new char[20];
    40.     int age;
    41. };
    42.  
    43.  
    44.  
    45. int main()
    46. {
    47.     // 1.c++编译器自动的调用构造函数
    48.     Test t0; // 自动调用无参数构造函数
    49.     t0.printT();
    50.     char name1[] = "hello";
    51.     Test t1(10, name1); // 自动调用参数构造函数
    52.     t1.printT();
    53.  
    54.     // 2.手动调用构造函数
    55.     char name2[] = "world";
    56.     Test t2 = Test(100, name2); 
    57.     t2.printT();
    58.     strcpy(name2, "good");
    59.     Test t3 = Test(1000, name2); //t4对象的初始化
    60.     t2 = t3;
    61.     t2.printT();
    62.  
    63.     // 3.对象赋值
    64.     t0 = t1; 
    65.     std::cout << &t0 << "," << &t1 << std::endl;  // 不同
    66.     t0.printT();
    67.     //对象的初始化 和 对象的赋值 是两个不同的概念
    68.  
    69.     // 4.拷贝构造函数
    70.     Test t4 = Test(t3);
    71.     //Test t4 = t3; // 等价的方式 // 对象的初始化
    72.     t4.printT();
    73.     std::cout << &t3 << "," << &t4 << std::endl; // 不同
    74.  
    75.     return 0;
    76. }
    77.

    编译运行

    1. [root@centos1 test]# g++ main.cpp -o main -std=c++11
    2. [root@centos1 test]# ./main
    3. name = tom
    4. age = 0
    5. ---------------
    6. name = hello
    7. age = 10
    8. ---------------
    9. name = world
    10. age = 100
    11. ---------------
    12. name = good
    13. age = 1000
    14. ---------------
    15. 0x7ffd41eaa4e0,0x7ffd41eaa4c0
    16. name = hello
    17. age = 10
    18. ---------------
    19. name = good
    20. age = 1000
    21. ---------------
    22. 0x7ffd41eaa490,0x7ffd41eaa480
    23. object destroyed
    24. object destroyed
    25. object destroyed
    26. object destroyed
    27. object destroyed
    28. [root@centos1 test]#

    匿名对象的去和留

    可以用函数返回对象，为匿名对象。关于匿名对象的去和留，结论如下：

    • 返回的匿名对象，若没人接盘，则这个匿名对象构造后会直接析构。
    • 返回的匿名对象，若赋值给另外一个同类型的对象，那么匿名对象在构造后会被析构。
    • 返回的匿名对象，若直接来初始化另外一个同类型的对象，那么匿名对象会直接转成新的对象。

    示例代码

    1. #include 
    2.  
    3. class Location
    4. {
    5. public:
    6.     Location(int xx = 0, int yy = 0)
    7.     {
    8.         X = xx;
    9.         Y = yy;
    10.         std::cout << "Object Created\n";
    11.     }
    12.     Location(const Location &p) //拷贝构造函数
    13.     {
    14.         X = p.X;
    15.         Y = p.Y;
    16.         std::cout << "Object Copy" << std::endl;
    17.     }
    18.     ~Location()
    19.     {
    20.         std::cout << "(" << X << "," << Y << ") "
    21.                   << "Object Destroyed" << std::endl;
    22.     }
    23. public:
    24.     int GetX() { return X; }
    25.     int GetY() { return Y; }
    26. private:
    27.     int X, Y;
    28. };
    29.  
    30. void PrintLocation(Location p) //打印对象的属性
    31. {
    32.     std::cout << "Funtion:" << p.GetX() << "," << p.GetY() << std::endl;
    33. }
    34.  
    35. Location GenLocation() //返回一个匿名对象
    36. {
    37.     Location A(1, 2);
    38.     return A;
    39. }
    40.  
    41. // 匿名对象的去和留，关键看，返回时如何接盘
    42. // = 在赋值和初始化这两种情况时有所不同
    43. int main()
    44. {
    45.     // (1)若返回的匿名对象，赋值给另外一个同类型的对象，那么匿名对象会被析构
    46.     std::cout << "--------B--------" << std::endl;
    47.     Location B;  // 调用一次构造函数
    48.     B = GenLocation(); // 调用构造函数  // 然后调用析构函数
    49.     
    50.  
    51.     //(2)若返回的匿名对象，直接来初始化另外一个同类型的对象
    52.     // 那么匿名对象会直接转成新的对象
    53.     std::cout << "--------C--------" << std::endl;
    54.     Location C = GenLocation();  // 调用一次构造函数
    55.     
    56.  
    57.     //(3)没人接盘 //这个匿名对象构造后会直接析构
    58.     std::cout << "----------------" << std::endl;
    59.     GenLocation(); // 调用一次构造函数  // 然后调用析构函数
    60.     
    61.  
    62.     std::cout << "--------end--------" << std::endl;
    63.     // 程序结束时
    64.     // B调用一次析构函数
    65.     // C调用一次析构函数
    66.  
    67.     return 0;
    68. }
    69.

    编译运行

    1. [root@localhost test]# g++ main.cpp -o main
    2. [root@localhost test]# ./main
    3. --------B--------
    4. Object Created
    5. Object Created
    6. (1,2) Object Destroyed
    7. --------C--------
    8. Object Created
    9. ----------------
    10. Object Created
    11. (1,2) Object Destroyed
    12. --------end--------
    13. (1,2) Object Destroyed
    14. (1,2) Object Destroyed
    15. [root@localhost test]#

    类中嵌套对象的初始化与对象初始化列表

    情况描述：如果我们设计的类中有一个成员，它本身是另一个类，而且这个成员构造函数只有带参数的构造函数，没有默认构造函数。这时要对这个类成员进行初始化，就必须调用这个类成员的带参构造函数，如果没有初始化列表，那么他将无法完成第一步，就会报错。

    解决办法：C++在构造函数中提供初始化列表对成员变量进行初始化。

    语法规则：作用域::类名(参数1, 参数2, ...):成员类名1(实参值a, 实参值b，...), 成员类名2((实参值m, 实参值n，...)

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

    • 构造函数顺序：先执行被组合对象的构造函数 。如果组合对象有多个，按照定义顺序,，而不是按照初始化列表的顺序。初始化列表先于构造函数的函数体执行。
    • 析构函数 : 和构造函数的调用顺序相反

    示例：在B类中，组合了一个 A类对象，A类设计了构造函数，但构造函数只有带参的构造函数，根据构造函数的调用规则，必须要调用A类的带参构造函数。

    示例代码

    1. #include 
    2. #include 
    3.  
    4. class A
    5. {
    6. public:
    7.     A(int _a)
    8.     {
    9.         a = _a;
    10.         std::cout << "generate A " << a << std::endl;
    11.     }
    12.     ~A()
    13.     {
    14.         std::cout << "destroy A " << a << std::endl;
    15.     }
    16. protected:
    17. private:
    18.     int a;
    19. };
    20.  
    21. class B
    22. {
    23. public:
    24.     //B(int _b1, int _b2): a1(_b1), a2(_b2)
    25.     B(int _b1, int _b2): a1(1), a2(2)
    26.     {
    27.         b1 = _b1;
    28.         b2 = _b2;
    29.         std::cout << "generate B " << std::endl;
    30.     }
    31.     B(int _b1, int _b2, int m, int n):a1(m), a2(n)
    32.     {
    33.         b1 = _b1;
    34.         b2 = _b2;
    35.         std::cout << "generate B " << std::endl;
    36.     }
    37.     ~B()
    38.     {
    39.         std::cout << "destroy B " << std::endl;
    40.     }
    41. protected:
    42. private:
    43.     int b1;
    44.     int b2;
    45.     A a2;
    46.     A a1;
    47. };
    48.  
    49. void objplay()
    50. {
    51.     B(1, 2);
    52. }
    53.  
    54. int main()
    55. {
    56.     objplay();
    57.     return 0;
    58. }

    运行结果

    1. generate A 2
    2. generate A 1
    3. generate B 
    4. destroy B 
    5. destroy A 1
    6. destroy A 2

    类中const常量初始化与对象初始化列表

    当类成员中含有⼀个const对象时，或者是⼀个引⽤时，他们也必须要通过成员初始化列表进⾏初始化，因为这两种对象要在声明后⻢上初始化，⽽在构造函数中，做的是对他们的赋值，这样是不被允许的。

    示例代码

    1. #include 
    2. #include 
    3.  
    4. class A
    5. {
    6. public:
    7.     A(int _a)
    8.     {
    9.         a = _a;
    10.         std::cout << "generate A " << a << std::endl;
    11.     }
    12.     ~A()
    13.     {
    14.         std::cout << "destroy A " << a << std::endl;
    15.     }
    16. public:
    17.     int geta(){return a;}
    18. protected:
    19. private:
    20.     int a;
    21. };
    22.  
    23. class B
    24. {
    25. public:
    26.     B(int _b1, int _b2): a1(_b1), a2(_b2), c(_b2)
    27.     // B(int _b1, int _b2): a1(1), a2(2), c(0)
    28.     {
    29.         b1 = _b1;
    30.         b2 = _b2;
    31.         std::cout << "generate B " << std::endl;
    32.     }
    33.     B(int _b1, int _b2, int m, int n):a1(m), a2(n), c(0)
    34.     {
    35.         b1 = _b1;
    36.         b2 = _b2;
    37.         std::cout << "generate B " << std::endl;
    38.     }
    39.     ~B()
    40.     {
    41.         std::cout << "destroy B " << std::endl;
    42.     }
    43. public:
    44.     void print()
    45.     {
    46.         std::cout << "---------" << std::endl;
    47.         std::cout << b1 << std::endl;
    48.         std::cout << b2 << std::endl;
    49.         std::cout << a2.geta() << std::endl;
    50.         std::cout << a1.geta() << std::endl;
    51.         std::cout << c << std::endl;
    52.     }
    53. protected:
    54. private:
    55.     int b1;
    56.     int b2;
    57.     A a2;
    58.     A a1;
    59.     const int c;
    60. };
    61.  
    62. void objplay()
    63. {
    64.     B obj_b1 = B(1, 2);
    65.     obj_b1.print();
    66.  
    67.     B obj_b2(3, 4);
    68.     obj_b2.print();
    69. }
    70.  
    71. int main()
    72. {
    73.     objplay();
    74.     return 0;
    75. }
    76.

    运行结果

    1. generate A 2
    2. generate A 1
    3. generate B 
    4. ---------
    5. 1
    6. 2
    7. 2
    8. 1
    9. 2
    10. generate A 4
    11. generate A 3
    12. generate B 
    13. ---------
    14. 3
    15. 4
    16. 4
    17. 3
    18. 4
    19. destroy B 
    20. destroy A 3
    21. destroy A 4
    22. destroy B 
    23. destroy A 1
    24. destroy A 2

    （4）new和delete用法

    在软件开发过程中，常常需要动态地分配和撤销内存空间。在C语⾔中是利⽤库函数malloc和 free来分配和撤销内存空间的。C++提供了较简便⽽功能较强的运算符new和delete来取代 malloc和free函数。

    注意：new和delete是运算符，不是函数，因此执⾏效率⾼。

    虽然为了与C语⾔兼容，C++仍保留malloc和free函数，但建议⽤户不⽤malloc和free函数，⽽ ⽤new和delete运算符。

    new用法举例：

    • new int;  //开辟⼀个存放整数的存储空间，返回⼀个指向该存储空间的地址(即指针)
    • new int(100);  //开辟⼀个存放整数的空间，并指定该整数的初值为100，返回⼀个指向该 存储空间的地址
    • new char[10];  //开辟⼀个存放字符数组(包括10个元素)的空间，返回⾸元素的地址
    • new int[5][4];  //开辟⼀个存放⼆维整型数组(⼤⼩为5*4)的空间，返回⾸元素的地址
    • float *p=new float(3.14159);  //开辟⼀个存放单精度数的空间，并指定该实数的初值为 3.14159，将返回的该空间的地址赋给指针变量p
    • Box *pt;  //定义⼀个指向Box类对象的指针变量pt
    • pt=new Box;  //在pt中存放了新建对象的起始地址
    • Box *pt = new Box ;
    • Box *pt=new Box(12,15,18);

    注意⽤new分配数组空间时不能指定初值。如果由于内存不⾜等原因⽽⽆法正常分配空间，则new会 返回⼀个空指针NULL，⽤户可以根据该指针的值判断分配空间是否成功。

    delete用法：

    若P是⼀个指向数组的指针，则delete p表示清空内存⾸地址，delete[] p表示清空整个数组 对应的堆中内存空间。

    malloc-free和new-delete区别：

    • malloc不会调⽤类的构造函数，new能执⾏类型构造函数
    • free不会调⽤类的析构函数，delete操作符 能执⾏类的析构函数

    示例代码

    1. #include 
    2. #include 
    3.  
    4. class Test
    5. {
    6. public:
    7.     Test(int _a)
    8.     {
    9.         a = _a;
    10.         std::cout << "generate A" << std::endl;
    11.     }
    12.     ~Test()
    13.     {
    14.         std::cout << "destroy A" << std::endl;
    15.     }
    16. protected:
    17. private:
    18.         int a;
    19. };
    20.  
    21. int main()
    22. {
    23.     // 1.基础类型
    24.     // 用malloc这个函数
    25.     int *p1 = (int *)malloc(sizeof(int));
    26.     *p1 = 10;
    27.     free(p1);
    28.  
    29.     // 用new这个运算符
    30.     int *p2 = new int;
    31.     *p2 = 20;
    32.     free(p2);
    33.  
    34.     int *p3 = new int(30);
    35.     delete p3;
    36.  
    37.     // 2.数组
    38.     // malloc
    39.     int *p4 = (int *)malloc(sizeof(int) * 10); // int array[10];
    40.     p4[0] = 1;
    41.     free(p4);
    42.  
    43.     // new
    44.     int *pArray = new int[10];
    45.     pArray[1] = 2;
    46.     delete[] pArray; 
    47.  
    48.     char *pArray2 = new char[25];
    49.     delete[] pArray2;
    50.  
    51.     // 3.给对象分配堆内内存空间
    52.     std::cout << "---------malloc------------" << std::endl;
    53.     Test *testp1 = (Test *)malloc(sizeof(Test));
    54.     std::cout << "---------free------------" << std::endl;
    55.     free(testp1);
    56.  
    57.     std::cout << "----------new-----------" << std::endl;
    58.     Test *testp2 = new Test(1);
    59.     std::cout << "----------delete-----------" << std::endl;
    60.     delete testp2;
    61.  
    62.     return 0;
    63. }

    运行结果

    1. ---------malloc------------
    2. ---------free------------
    3. ----------new-----------
    4. generate A
    5. ----------delete-----------
    6. destroy A

    （5）static与静态成员变量(函数)

    静态成员变量

    思考：每个变量，拥有属性。有没有⼀些属性，归所有对象拥有？

    把⼀个类的成员修饰为 static 时，这个类⽆论有多少个对象被创建，这些同类对象共享这个 static 成员。

    • 静态成员在类的内部声明，但要在类的外部初始化。静态成员局部于类，它不是对象成员。
    • 静态不初始化时，只要不调⽤这个静态成员编译就不会报错，但只有调⽤时才会报错。
    • 静态成员只有在初始化后，才会分配内存空间。
    1. #include 
    2.  
    3. class counter
    4. {
    5. public:
    6.     static int num; //声明静态数据成员
    7. public:
    8.     void setnum(int i) { num = i; } //成员函数访问静态数据成员
    9.     void shownum() { std::cout << num << std::endl; }
    10. };
    11.  
    12. // 在类的外部初始化静态数据成员
    13. // 只能初始化一次
    14. int counter::num = 0; 
    15.  
    16. int main()
    17. {
    18.     counter a, b;
    19.  
    20.     //调用成员函数访问私有静态数据成员
    21.     a.shownum(); //0
    22.     b.shownum(); //0
    23.  
    24.     //只要有一个对象改变了静态成员的值
    25.     //则所有对象调用该静态成员时的值也会变
    26.     a.setnum(10);
    27.     a.shownum(); //10
    28.     b.shownum(); //10
    29.  
    30.     //若静态数据成员是public的
    31.     //还可以直接通过类访问静态成员
    32.     std::cout << counter::num << std::endl;
    33.  
    34.     return 0;
    35. }

    静态成员函数

    用static修饰成员函数，成为静态函数。

    对于静态成员函数，是全部对象公有函数，提供不依赖于类数据结构的共同操作，它没有this指针。

    • 在类外调⽤静态成员函数⽤ “类名::静态函数”作限定词，或通过对象调⽤。

    • 注意静态函数中，不能使用普通成员变量，也不能调用普通成员函数，只能使用静态成员变量

    1. #include 
    2.  
    3. class Worker
    4. {
    5. public:
    6.     void company_age_add(){company_age++;}
    7.     void print_company_age1()
    8.     {
    9.         std::cout << "normal print: company_age=" << company_age << std::endl;
    10.     }
    11.     static void print_company_age2() //静态成员函数
    12.     {
    13.         std::cout << "static print: company_age=" << company_age << std::endl;
    14.  
    15.         // std::cout << "age:" << age << std::endl; 
    16.         // error C2597: 对非静态成员“Worker::age”的非法引用
    17.         // 静态函数中 不能使用 普通成员变量 普通成员函数
    18.     }
    19. protected:
    20. private:
    21.     int age;
    22.     int salary;
    23.     static int company_age; //静态成员变量
    24. };
    25.  
    26.  
    27. int Worker::company_age = 10;
    28.  
    29. int main()
    30. {
    31.     Worker w1, w2, w3;
    32.     // 1.普通成员函数调用静态成员变量
    33.     w1.print_company_age1(); // normal print: company_age=10
    34.     
    35.     w2.company_age_add();
    36.     w3.print_company_age1(); // normal print: company_age=11
    37.  
    38.     // 2.调用静态成员函数
    39.     // 第一种：用对象.
    40.     w3.print_company_age2();  // static print: company_age=11 
    41.     // 第二种：类::
    42.     Worker::print_company_age2(); // static print: company_age=11 
    43.  
    44.     return 0;
    45. }

    （6）c++编译器对成员变量和函数的处理机制

    内存占用机制

    C++类对象中的成员变量和成员函数是分开存储的。

    • 成员变量：
      • 普通成员变量：存储于对象中，与struct变量有相同的内存布局和字节对⻬⽅式
      • 静态成员变量：存储于全局数据区中
    • 成员函数：存储于代码段中。
    1. #include 
    2. #include 
    3.  
    4. class C1
    5. {
    6. public:
    7.     int i; // 4个字节
    8.     int j; // 4个字节
    9.     int k; // 4个字节
    10. protected:
    11. private:
    12. }; //共12个字节
    13.  
    14. class C2
    15. {
    16. public:
    17.     int i;
    18.     int j;
    19.     int k;
    20.     static int m;
    21. public:
    22.     int getK() const { return k; }  
    23.     void setK(int val) { k = val; } 
    24. protected:
    25. private:
    26. };
    27.  
    28. struct S1
    29. {
    30.     int i;
    31.     int j;
    32.     int k;
    33. }; // 12
    34.  
    35. struct S2
    36. {
    37.     int i;
    38.     int j;
    39.     int k;
    40.     static int m;
    41. }; // 12
    42.  
    43.  
    44. int main()
    45. {
    46.     printf("c1:%d \n", sizeof(C1)); //12
    47.     printf("c2:%d \n", sizeof(C2)); //12
    48.     printf("s1:%d \n", sizeof(S1)); //12
    49.     printf("s2:%d \n", sizeof(S2)); //12
    50.     return 0;
    51. }

    this指针

    C++中类的普通成员函数都隐式包含⼀个指向当前对象的this指针。比如类成员函数Test(int a, int b)其实是Test(Test *this, int a, int b)。

    静态成员函数与普通成员函数的区别：静态成员函数不包含指向具体对象的指针，普通成员函数 包含⼀个指向具体对象的指针。

    1. #include 
    2.  
    3. class Test
    4. {
    5. public:
    6.     Test(int a, int b)
    7.     {
    8.         this->a = a;
    9.         this->b = b;
    10.     }
    11.  
    12.     void print1(int a) //这个a是函数形参的a
    13.     {
    14.         std::cout << "----------print1----------" << std::endl;
    15.         for (int i = 0; i < a; i++)
    16.         {
    17.             std::cout << "a: " << this->a << std::endl; //打印对象的属性a的值
    18.             std::cout << "b: " << this->b << std::endl;
    19.         }
    20.     }
    21.  
    22.     void print2() 
    23.     {
    24.         std::cout << "----------print2----------" << std::endl;
    25.         // 当函数形参没有与成员变量同名的形参时
    26.         // 函数内部可以不用this，直接访问成员变量
    27.         std::cout << "a: " << a << std::endl; //打印对象的属性a的值
    28.         std::cout << "b: " << b << std::endl;
    29.  
    30.     }
    31.  
    32. protected:
    33. private:
    34.     int a;
    35.     int b;
    36. };
    37.  
    38. int main()
    39. {
    40.     Test t1(1, 2);
    41.     t1.print1(3);
    42.  
    43.     t1.print2();
    44.  
    45.     return 0;
    46. }

    ⽤const限定this指针

    C++中类的普通成员函数都隐式包含⼀个指向当前对象的this指针。比如类成员函数Test(int a, int b)其实是Test(Test *this, int a, int b)。

    将const写在成员函数处，比如void OperateVar(int a, int b) const，将会对this指针和this下的成员进行修饰，只有只读属性，使得this和this成员不能被改变。

    注意：

    • const 无论写在函数什么位置，都没有关系，像下面这样都可以

      • void OperateVar(int a, int b) const

      • const void OperateVar(int a, int b)

      • void const OperateVar(int a, int b)

    • const修饰的是谁？

      • const修饰的是形参a吗？不是

      • const修饰的是属性this->a  this->b

      • const修饰的是this指针所指向的内存空间， 修饰的是this指针

    1. #include 
    2.  
    3. class Test
    4. {
    5. public:
    6.     Test(int a, int b) //---> Test(Test *this, int a, int b)
    7.     {
    8.         this->a = a;
    9.         this->b = b;
    10.     }
    11.     void printT()
    12.     {
    13.         std::cout << "a: " << a << "\t";
    14.         std::cout << "b: " << this->b << std::endl;
    15.     }
    16.  
    17.     void OperateVar(int a, int b) const
    18.     // void const OperateVar(int a, int b)  
    19.     // const void OperateVar(int a, int b)
    20.     {
    21.         a = 100;
    22.         // this->a = 100; //因为const，会报错
    23.         // this->b = 200; //因为const，会报错
    24.         // this = 0x11;   //因为const，会报错
    25.         std::cout << "a: " << this->a << "\t";
    26.         std::cout << "b: " << this->b << std::endl;
    27.     }
    28. protected:
    29. private:
    30.     int a;
    31.     int b;
    32. };
    33.  
    34. int main()
    35. {
    36.     int *m_space = new int[0];
    37.     if (m_space == NULL)
    38.     {
    39.         return -1;
    40.     }
    41.  
    42.     Test t1(1, 2);
    43.     t1.printT();
    44.     //a: 1  b: 2
    45.  
    46.     t1.OperateVar(100, 200);
    47.     //a: 1  b: 2
    48.  
    49.     return 0;
    50. }

    end

  • 相关阅读:
    datepicker设置中文
    Linux上编译sqlite3库出现undefined reference to `sqlite3_column_table_name‘
    Zookeeper快速入门（Zookeeper概述、安装、集群安装、选举机制、命令行操作、节点类型、监听器原理）
    Qt优秀开源项目之九：qTox
    “亚马逊依赖”之下，傲基科技的品牌势能如何提升？
    【数据结构】——顺序表
    万宾科技智能井盖传感器，提升市政井盖健康
    MySQL之导入导出&视图&索引&执行计划
    初识webGL
    CSS常见用法 以及JS基础语法
  • 原文地址：https://blog.csdn.net/hutaotaotao/article/details/138139427