C++构造函数和析构函数的学习（一）-成都创新互联网站建设

成都创新互联网站制作

028-86922220

关于创新互联

多方位宣传企业产品与服务 突出企业形象

公司简介 公司的服务 荣誉资质 新闻动态 联系我们

C++构造函数和析构函数的学习（一）

    构造函数是类中特殊的成员函数。

创新互联主要企业基础官网建设，电商平台建设，移动手机平台，微信小程序开发等一系列专为中小企业按需定制产品体系；应对中小企业在互联网运营的各种问题，为中小企业在互联网的运营中保驾护航。

    创建类类型的新对象的，系统会自动调用构造函数。

    构造函数的调用是为了保证每个数据成员都能被正确初始化。

    构造函数的作用初始化。

    通常情况下，构造函数应声明为公有函数，构造它不能像其他成员函数那样被显式的调用。

    构造函数被声明为私有有特殊的用途。

    构造函数可以有任意类型和任意个数的参数，一个类可以有多个构造函数。

    如果程序未声明构造函数，默认会生成一个空的构造函数。

    不带参数的构造函数称为默认构造函数。

    如果有一个构造函数，系统不再生成默认构造函数

 

Test.h

  1. //Test.h 
  2. # ifndef _TEST_H_ 
  3. # define _TEST_H_ 
  4.  
  5. class Test 
  6. { 
  7. public: //如果程序未声明构造函数，默认会生成一个空的构造函数
  8.     Test(); 
  9. private: 
  10.     int num_; 
  11. }; 
  12.  
  13. # endif //_TEST_H_ 

Test.cpp

  1. //Test.cpp 
  2. # include "Test.h" 
  3. # include  
  4. using namespace std; 
  5.  
  6. Test::Test() 
  7. { 
  8.     num_ = 0; 
  9.     cout << "Initializing Default " << endl; 
  10. } 

main.cpp

 

  1. # include  
  2. # include "Test.h" 
  3. using namespace std; 
  4.  
  5. int main(void) 
  6. { //自动调用构造函数
  7.     Test t; 
  8.  
  9.     return 0; 
  10. } 

 运行结果：

C++构造函数和析构函数的学习（一）

 //    如果有一个构造函数，系统不再生成默认构造函数

 

Test.h

  1. //Test.h 
  2. # ifndef _TEST_H_ 
  3. # define _TEST_H_ 
  4.  
  5. class Test 
  6. { 
  7. public: //如果程序未声明构造函数，默认会生成一个空的构造函数
  8.     Test(int num); 
  9. private: 
  10.     int num_; 
  11. }; 
  12.  
  13. # endif //_TEST_H_ 

Test.cpp

  1. //Test.cpp 
  2. # include "Test.h" 
  3. # include  
  4. using namespace std; 
  5.  
  6. Test::Test(int num) 
  7. { 
  8.     num_ = num; 
  9.     cout << "Initializing " << num_ << endl; 
  10. } 

main.cpp

 

  1. # include  
  2. # include "Test.h" 
  3. using namespace std; 
  4.  
  5. int main(void) 
  6. { //自动调用构造函数
  7.     Test t(10); 
  8.  
  9.     return 0; 
  10. } 

 运行结果:

C++构造函数和析构函数的学习（一）

 

 

构造函数重载的实例：

 

Test.h

  1. //Test.h 
  2. # ifndef _TEST_H_ 
  3. # define _TEST_H_ 
  4.  
  5. class Test 
  6. { 
  7. public: //如果程序未声明构造函数，默认会生成一个空的构造函数
  8. Test();
  9.     Test(int num); 
  10. private: 
  11.     int num_; 
  12. }; 
  13.  
  14. # endif //_TEST_H_ 

Test.cpp

  1. //Test.cpp 
  2. # include "Test.h" 
  3. # include  
  4. using namespace std; 
  5.  
  6. Test::Test()
  7. {
  8. num_ = 0;
  9.     cout << "Initializing default " << endl; 
  10. } 
  11.  
  12. Test::Test(int num) 
  13. { 
  14.     num_ = num; 
  15.     cout << "Initializing " << num_ << endl; 
  16. } 

main.cpp

  1. # include  
  2. # include "Test.h" 
  3. using namespace std; 
  4.  
  5. int main(void) 
  6. { //自动调用构造函数
  7.     Test t1;
  8. Test t2(10); 
  9.  
  10.     return 0; 
  11. } 

 运行结果:

C++构造函数和析构函数的学习（一）

 

 构造函数与new运算符

  1. //构造函数与new运算符 
  2.  
  3. # ifndef _TEST_H_ 
  4. # define _TEST_H_ 
  5.  
  6. class Test 
  7. { 
  8. public: 
  9.     ////可以显式的写一个默认构造函数，这样两个函数就成了重载 
  10.     Test(); 
  11.     Test(int num); 
  12.     //析构函数不能重载 
  13.     //析构函数不能带参数，如果带参数就可以重载 
  14.     ~Test(); 
  15.     void Display(); 
  16. private: 
  17.     int num_; 
  18. }; 
  19.  
  20. # endif  

Test.cpp

  1. # include "Test.h" 
  2. # include  
  3. using namespace std; 
  4.  
  5. void Test::Display() 
  6. { 
  7.     cout << num_ << endl; 
  8. } 
  9. Test::Test() 
  10. { 
  11.     num_ = 0; 
  12.     cout<<"Initializing Default" << endl; 
  13.      
  14. } 
  15. Test::Test(int num) 
  16. { 
  17.     num_ = num; 
  18.     cout<<"Initializing "<
  19. } 
  20.  
  21. Test::~Test() 
  22. { 
  23.     cout << "Destory " << num_ << endl; 
  24. } 

main.cpp

  1. # include  
  2. # include "Test.h" 
  3. using namespace std; 
  4.  
  5. int main(void) 
  6. { 
  7.     Test t; 
  8.     t.Display();  
  9.  
  10.     Test t2(20);         
  11.     t2.Display();  
  12. //不仅仅分配了内存，还调用了构造函数 
  13.     Test * t3 = new Test(20);  //new operator 
  14.     t3->Display(); 
  15. //不仅仅释放了内存，也调用了析构函数      
  16.     delete t3; 
  17.  
  18.     return 0; 
  19. } 

 

运行结果：

C++构造函数和析构函数的学习（一）

 

//全局对象的构造先于main函数 

 

  1.  
  2. # ifndef _TEST_H_ 
  3. # define _TEST_H_ 
  4.  
  5. class Test 
  6. { 
  7. public: 
  8.     ////可以显式的写一个默认构造函数，这样两个函数就成了重载 
  9.     Test(); 
  10.     Test(int num); 
  11.     //析构函数不能重载 
  12.     //析构函数不能带参数，如果带参数就可以重载 
  13.     ~Test(); 
  14.     void Display(); 
  15. private: 
  16.     int num_; 
  17. }; 
  18.  
  19. # endif  

Test.cpp

  1. # include "Test.h" 
  2. # include  
  3. using namespace std; 
  4.  
  5. void Test::Display() 
  6. { 
  7.     cout << num_ << endl; 
  8. } 
  9. Test::Test() 
  10. { 
  11.     num_ = 0; 
  12.     cout<<"Initializing Default" << endl; 
  13.      
  14. } 
  15. Test::Test(int num) 
  16. { 
  17.     num_ = num; 
  18.     cout<<"Initializing "<
  19. } 
  20.  
  21. Test::~Test() 
  22. { 
  23.     cout << "Destory " << num_ << endl; 
  24. } 

 

main.cpp

  1. # include "Test.h" 
  2. using namespace std; 
  3.  
  4. //全局对象的构造先于main函数 
  5. Test t(10); 
  6.  
  7. int main(void) 
  8. { 
  9.     cout << "Entering main ..." << endl; 
  10.     cout << "Exiting  main ..." << endl; 
  11.  
  12.     return 0; 
  13. } 

运行结果：

C++构造函数和析构函数的学习（一）

 

 

    默认析构函数是一个空函数

    析构函数没有参数

    析构函数不能被重载

 

    析构函数与数组

Test.h

  1. //Test.h 
  2. # ifndef _TEST_H_ 
  3. # define _TEST_H_ 
  4.  
  5. class Test 
  6. { 
  7. public: 
  8.     ////可以显式的写一个默认构造函数，这样两个函数就成了重载 
  9.     Test(); 
  10.     Test(int num); 
  11.     //析构函数不能重载 
  12.     //析构函数不能带参数，如果带参数就可以重载 
  13.     ~Test(); 
  14.     void Display(); 
  15. private: 
  16.     int num_; 
  17. }; 
  18.  
  19. # endif //_TEST_H_ 

Test.cpp

  1. //Test.cpp 
  2. # include  
  3. # include "Test.h" 
  4. using namespace std; 
  5.  
  6. void Test::Display() 
  7. { 
  8.     cout << num_ << endl; 
  9. } 
  10. Test::Test() 
  11. { 
  12.     num_ = 0; 
  13.     cout<<"Initializing Deafule " << endl; 
  14. } 
  15. Test::Test(int num) 
  16. { 
  17.     num_ = num; 
  18.     cout<<"Initializing "<
  19. } 
  20.  
  21. Test::~Test() 
  22. { 
  23.     cout << "Destory " << num_ << endl; 
  24. } 

 

main.cpp

  1. //main.cpp 
  2. # include  
  3. # include "Test.h" 
  4. using namespace std; 
  5.  
  6. int main(void) 
  7. {      //定义对象数组 
  8.     Test t[2] = {10,20}; 
  9.     //动态对象 
  10.     Test* t2 = new Test(2); //传递参数2 
  11.     delete t2; 
  12.     //没有传递任何参数，创建了两个对象 
  13.     Test* t3 = new Test[2]; 
  14.     delete[] t3; 
  15.      
  16.     return 0; 
  17. } 

运行结果：

C++构造函数和析构函数的学习（一）

    析构函数不能重载

 

    析构函数不能带参数，如果带参数就可以重载

 

    析构函数可以显式调用，一般很少用到，会实现一些特殊的效果：

  1. //main.cpp 
  2. # include "Test.h" 
  3.  
  4. int main(void) 
  5. { 
  6.     Test t; 
  7.     t.~Test(); //析构函数被调用了两次 
  8.     //析构函数很少调用，可以显式调用 
  9.     return 0; 
  10. } 

 


分享标题：C++构造函数和析构函数的学习（一）
路径分享：http://kswsj.cn/article/jcpogi.html

其他资讯