C++深度解析(36)-构造函数-初始化 initialize

最新推荐文章于 2026-06-25 13:44:06 发布

转载最新推荐文章于 2026-06-25 13:44:06 发布 · 1.4k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：https://blog.csdn.net/xiaodingqq/article/details/85123096

标签

#构造函数 #初始化 initialize

10C++上手学习专栏收录该内容

30 篇文章

订阅专栏

本文深入探讨了C++中对象的构造与初始化过程，包括不同存储区域的对象初始化行为，构造函数的作用及如何确保对象拥有确定的初始状态。

本文链接： https://blog.csdn.net/xiaodingqq/article/details/85123096

C++深度解析对象的构造（上）（16）

对象中成员变量的初始值

示例程序：


 
   
    
   
   
    
     #include <stdio.h>
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     //Test是一个自定义数据类型
    
   

   
    
   
   
    
     class Test
    
   

   
    
   
   
    
     {
    
   

   
    
   
   
    
     private:
    
   

   
    
   
   
        
     int i;
    
   

   
    
   
   
        
     int j;
    
   

   
    
   
   
    
     public:
    
   

   
    
   
   
        
     int getI() {
     return i;}
    
   

   
    
   
   
        
     int getJ() {
     return j;}
    
   

   
    
   
   
    
     };
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     //在全局的数据区占用存储空间，在全局数据区的变量的初始值为0
    
   

   
    
   
   
    
     Test gt; 
     //全局对象
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     int main()
    
   

   
    
   
   
    
     {
    
   

   
    
   
   
        
     printf(
     "gt.i = %d\n", gt.getI()); 
     //0
    
   

   
    
   
   
        
     printf(
     "gt.j = %d\n", gt.getJ()); 
     //0
    
   

   
    
   
   
     
    
   

   
    
   
   
        
     //占用的存储空间在栈上
    
   

   
    
   
   
    
         Test t1;
     //局部对象
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     printf(
     "t1.i = %d\n", t1.getI()); 
     //随机值
    
   

   
    
   
   
        
     printf(
     "t1.j = %d\n", t1.getJ()); 
     //随机值
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     //类对象的指针，Test是一个自定义数据类型
    
   

   
    
   
   
        
     //类得到的是数据类型，所以通过类数据类型在全局数据区、堆、栈空间都能生成对象
    
   

   
    
   
   
    
         Test* pt = 
     new Test;
     //堆空间分配
    
   

   
    
   
   
        
     printf(
     "pt->i = %d\n", pt->getI()); 
     //0，结果只是巧合
    
   

   
    
   
   
        
     printf(
     "pt->j = %d\n", pt->getJ()); 
     //0，结果只是巧合
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     delete pt;
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     return 
     0;
    
   

   
    
   
   
    
     }

结果如下：

分析：类是一种特殊的自定义类型，可以用来定义变量，占用存储空间。对象t1占用的存储空间在栈上，对象gt占用的存储空间在全局数据区上（全局数据区占用存储空间的变量，初始值为0）。

上述程序对象的初始化的小结：

从程序设计的角度，对象只是变量，因此：

在栈上创建对象时，成员变量初始为随机值。

在堆上创建对象时，成员变量初始为随机值。

在静态存储区（全局对象，被static修饰的局部对象）创建对象时，成员变量初始为0值。

对象的成员变量，不管在什么存储区，创建对象时，初始化固定

一般而言，对象都需要一个确定的初始状态。

在类中提供一个public的initialize函数。

对象创建后立即调用initialize函数进行初始化。

示例程序：


 
   
    
   
   
    
     #include <stdio.h>
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     //Test是一个自定义数据类型
    
   

   
    
   
   
    
     class Test
    
   

   
    
   
   
    
     {
    
   

   
    
   
   
    
     private:
    
   

   
    
   
   
        
     int i;
    
   

   
    
   
   
        
     int j;
    
   

   
    
   
   
    
     public:
    
   

   
    
   
   
        
     int getI() {
     return i;}
    
   

   
    
   
   
        
     int getJ() {
     return j;}
    
   

   
    
   
   
        
     void initialize()
    
   

   
    
   
   
    
         {
    
   

   
    
   
   
    
             i = 
     1;
    
   

   
    
   
   
    
             j = 
     2;
    
   

   
    
   
   
    
         };
    
   

   
    
   
   
    
     };
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     Test gt; 
     //全局对象
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     int main()
    
   

   
    
   
   
    
     {   
    
   

   
    
   
   
    
         gt.initialize();
     //要立即调用,否则对象的成员变量的初始值还依旧一样
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     printf(
     "gt.i = %d\n", gt.getI());
    
   

   
    
   
   
        
     printf(
     "gt.j = %d\n", gt.getJ());
    
   

   
    
   
   
     
    
   

   
    
   
   
    
         Test t1;
     //局部对象
    
   

   
    
   
   
        
    
   

   
    
   
   
    
         t1.initialize();
     //要立即调用,否则对象的成员变量的初始值还依旧一样
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     printf(
     "t1.i = %d\n", t1.getI()); 
    
   

   
    
   
   
        
     printf(
     "t1.j = %d\n", t1.getJ());
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     //类对象的指针，Test是一个自定义数据类型
    
   

   
    
   
   
    
         Test* pt = 
     new Test;
     //堆空间分配
    
   

   
    
   
   
        
    
   

   
    
   
   
    
         pt->initialize();
     //要立即调用,否则对象的成员变量的初始值还依旧一样
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     printf(
     "pt->i = %d\n", pt->getI());
    
   

   
    
   
   
        
     printf(
     "pt->j = %d\n", pt->getJ());
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     delete pt;
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     return 
     0;
    
   

   
    
   
   
    
     }

结果如下：

分析：initialize()函数，在创建对象要立即调用。存在的问题，initialize只是一个普通函数，必须显示调用。如果未调用initialize函数，运行结果是不确定的。

构造函数

构造函数：与类名相同。

构造没有任何返回类型的声明

构造函数在对象定义时自动被调用

实例程序：


 
   
    
   
   
    
     #include <stdio.h>
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     //Test是一个自定义数据类型
    
   

   
    
   
   
    
     class Test
    
   

   
    
   
   
    
     {
    
   

   
    
   
   
    
     private:
    
   

   
    
   
   
        
     int i;
    
   

   
    
   
   
        
     int j;
    
   

   
    
   
   
    
     public:
    
   

   
    
   
   
        
     int getI() {
     return i;}
    
   

   
    
   
   
        
     int getJ() {
     return j;}
    
   

   
    
   
   
        
     //构造函数，名字与类名相同,没有返回值类型
    
   

   
    
   
   
    
         Test()
    
   

   
    
   
   
    
         {
    
   

   
    
   
   
            
     printf(
     "Test() Begin\n");
    
   

   
    
   
   
            
    
   

   
    
   
   
    
             i = 
     1;
    
   

   
    
   
   
    
             j = 
     2;
    
   

   
    
   
   
            
    
   

   
    
   
   
            
     printf(
     "Test() End\n");
    
   

   
    
   
   
    
         };
    
   

   
    
   
   
    
     };
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     Test gt;
     //调用Test()构造方法
    
   

   
    
   
   
     
    
   

   
    
   
   
    
     int main()
    
   

   
    
   
   
    
     {     
    
   

   
    
   
   
        
     printf(
     "gt.i = %d\n", gt.getI());
    
   

   
    
   
   
        
     printf(
     "gt.j = %d\n", gt.getJ());
    
   

   
    
   
   
     
    
   

   
    
   
   
    
         Test t1;
     //调用Test()构造方法
    
   

   
    
   
   
         
    
   

   
    
   
   
        
     printf(
     "t1.i = %d\n", t1.getI()); 
    
   

   
    
   
   
        
     printf(
     "t1.j = %d\n", t1.getJ());
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     //类对象的指针，Test是一个自定义数据类型
    
   

   
    
   
   
    
         Test* pt = 
     new Test;
     //调用Test()构造方法
    
   

   
    
   
   
         
    
   

   
    
   
   
        
     printf(
     "pt->i = %d\n", pt->getI());
    
   

   
    
   
   
        
     printf(
     "pt->j = %d\n", pt->getJ());
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     delete pt;
    
   

   
    
   
   
        
    
   

   
    
   
   
        
     return 
     0;
    
   

   
    
   
   
    
     }