• C++ 类构造函数 & 析构函数


    类的构造函数

    类的构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。

    构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回 void。构造函数可用于为某些成员变量设置初始值。

    下面的实例有助于更好地理解构造函数的概念:

    1. #include
    2. using namespace std;
    3. class Line
    4. {
    5. public:
    6. void setLength( double len );
    7. double getLength( void );
    8. Line(); // 这是构造函数
    9. private:
    10. double length;
    11. };
    12. // 成员函数定义,包括构造函数
    13. Line::Line(void)
    14. {
    15. cout << "Object is being created" << endl;
    16. }
    17. void Line::setLength( double len )
    18. {
    19. length = len;
    20. }
    21. double Line::getLength( void )
    22. {
    23. return length;
    24. }
    25. // 程序的主函数
    26. int main( )
    27. {
    28. Line line;
    29. // 设置长度
    30. line.setLength(6.0);
    31. cout << "Length of line : " << line.getLength() <
    32. return 0;
    33. }

    编译执行结果:

    1. Object is being created
    2. Length of line : 6

    带参数的构造函数

    默认的构造函数没有任何参数,但如果需要,构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值,如下面的例子所示:

    1. #include
    2. using namespace std;
    3. class Line
    4. {
    5. public:
    6. void setLength( double len );
    7. double getLength( void );
    8. Line(double len); // 这是构造函数
    9. private:
    10. double length;
    11. };
    12. // 成员函数定义,包括构造函数
    13. Line::Line( double len)
    14. {
    15. cout << "Object is being created, length = " << len << endl;
    16. length = len;
    17. }
    18. void Line::setLength( double len )
    19. {
    20. length = len;
    21. }
    22. double Line::getLength( void )
    23. {
    24. return length;
    25. }
    26. // 程序的主函数
    27. int main( )
    28. {
    29. Line line(10.0);
    30. // 获取默认设置的长度
    31. cout << "Length of line : " << line.getLength() <
    32. // 再次设置长度
    33. line.setLength(6.0);
    34. cout << "Length of line : " << line.getLength() <
    35. return 0;
    36. }

    编译执行结果:

    1. Object is being created, length = 10
    2. Length of line : 10
    3. Length of line : 6

    类对象初始化的时候加括号与不加括号有什么区别~

    1. #include
    2. using namespace std;
    3. class A
    4. {
    5. public:
    6. A()
    7. {
    8. cout << "A()" << endl;
    9. }
    10. A(int a)
    11. {
    12. cout << "A(int a)" << endl;
    13. }
    14. };
    15. int main()
    16. {
    17. //栈上
    18. //warning C4930 : “A a(void)” : 未调用原型函数(是否是有意用变量定义的 ? )
    19. A a();//这里声明了一个函数,没有传入的参数,返回值为类类型
    20. cout << "~~~~~~~~~~~" << endl;
    21. A b;//默认调用“对象名()”这个构造函数构造对象
    22. cout << "~~~~~~~~~~~" << endl;
    23. A c(1);//默认调用相应的构造函数构造对象
    24. //堆上,加括号不加括号无差别,都调用默认的构造函数
    25. A *d = new A();
    26. A *e = new A;
    27. //对于内置类型而言,加括号是进行了初始化,不加是未进行初始化
    28. int *f = new int();
    29. int *g = new int;
    30. cout << *f << endl;
    31. cout << *g << endl;
    32. system("pause");
    33. return 0;
    34. }

    linux不认识这 system(“pause”); 这个代码。

    我们可以删掉这个端代码。也可以修改为 pause();fa267072492942ea9962785918ccaac2.png

    使用初始化列表来初始化字段

    使用初始化列表来初始化字段:

    1. Line::Line( double len): length(len)
    2. {
    3. cout << "Object is being created, length = " << len << endl;
    4. }

    上面的语法等同于如下语法:

    1. Line::Line( double len)
    2. {
    3. length = len;
    4. cout << "Object is being created, length = " << len << endl;
    5. }

    假设有一个类 C,具有多个字段 X、Y、Z 等需要进行初始化,同理地,您可以使用上面的语法,只需要在不同的字段使用逗号进行分隔,如下所示:

    1. C::C( double a, double b, double c): X(a), Y(b), Z(c)
    2. {
    3. ....
    4. }

    类的析构函数

    类的析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。

    析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。

    下面的实例有助于更好地理解析构函数的概念:

    1. #include
    2. using namespace std;
    3. class Line
    4. {
    5. public:
    6. void setLength( double len );
    7. double getLength( void );
    8. Line(); // 这是构造函数声明
    9. ~Line(); // 这是析构函数声明
    10. private:
    11. double length;
    12. };
    13. // 成员函数定义,包括构造函数
    14. Line::Line(void)
    15. {
    16. cout << "Object is being created" << endl;
    17. }
    18. Line::~Line(void)
    19. {
    20. cout << "Object is being deleted" << endl;
    21. }
    22. void Line::setLength( double len )
    23. {
    24. length = len;
    25. }
    26. double Line::getLength( void )
    27. {
    28. return length;
    29. }
    30. // 程序的主函数
    31. int main( )
    32. {
    33. Line line;
    34. // 设置长度
    35. line.setLength(6.0);
    36. cout << "Length of line : " << line.getLength() <
    37. return 0;
    38. }

    编译执行结果:

    1. Object is being created
    2. Length of line : 6
    3. Object is being deleted

    一个类内可以有多个构造函数,可以是一般类型的,也可以是带参数的,相当于重载构造函数,但是析构函数只能有一个

    示例:

    1. class Matrix
    2. {
    3. public:
    4. Matrix(int row, int col); //普通构造函数
    5. Matrix(const Matrix& matrix); //拷贝构造函数
    6. Matrix(); //构造空矩阵的构造函数
    7. void print(void);
    8. ~Matrix();
    9. };

     

     

  • 相关阅读:
    vue 部署到本机IIS 部署 SPA 应用
    十七、完整神经网络模型训练步骤
    Javaweb05-Ajax
    每天一个数据分析题(二百九十五)
    上海市青少年算法2022年11月月赛(丙组)
    RustDay06------Exercise[91-100]
    Android四大组件之BroadcastReceiver(四)
    将labelImg生成的指定xml标签中某一类的检测框复制给其他图片的xml
    Halo 开源项目学习(七):缓存机制
    高比例风电电力系统储能(火电机组、风能、储能)运行及配置分析附Matlab代码
  • 原文地址:https://blog.csdn.net/m0_74712453/article/details/133051145