C/C++学习之路（一）

╰半夏微凉° 2022-07-16 05:59 209阅读 0赞

## C/C++学习之路（一） ##

今天我想要写的是关于调用构造函数的问题。

首先，我们先来弄懂关于构造函数的定义。在百度百科上，是这么定义的：构造函数 ，是一种特殊的方法。主要用来在创建对象时初始化对象， 即为对象成员变量赋初始值，总与new运算符一起使用在创建对象的语句中。特别的一个类可以有多个构造函数 ，可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载。

那么，先来看一道题：

![SouthEast][]

当我第一次看到这一道题的时候，我第一反应的答案是：9。然后看了一下答案，发现答案是4。于是乎我再一次翻看了构造函数的定义，才恍然大悟自己先前的想法是不对的。

要想解决上面的问题，我们先要弄懂以下两个问题：

一、 构造函数是干什么的  
class Counter  
\{  
public:  
         // 类Counter的构造函数  
         // 特点：以类名作为函数名，无返回类型  
         Counter()  
         \{  
                m\_value = 0;  
         \}           
private:      
         // 数据成员  
         int m\_value;  
\}  
         该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作  
eg:    Counter c1;  
        编译系统为对象c1的每个数据成员(m\_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m\_value值设置为0  
故：  
        **构造函数的作用：初始化对象的数据成员。**  
         二、 构造函数的种类  
class Complex  
\{           
private :  
        double    m\_real;  
        double    m\_imag;  
public:  
        //    无参数构造函数  
        // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做  
        // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来  
        Complex(void)  
        \{  
             m\_real = 0.0;  
             m\_imag = 0.0;  
        \}           
        //    一般构造函数（也称重载构造函数）  
        // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）  
        // 例如：你还可以写一个 Complex( int num)的构造函数出来  
        // 创建对象时根据传入的参数不同调用不同的构造函数  
        Complex(double real, double imag)  
        \{  
             m\_real = real;  
             m\_imag = imag;           
         \}  
        //    复制构造函数（也称为拷贝构造函数）  
        //    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中  
        //    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述  
        Complex(const Complex & c)  
        \{  
                // 将对象c中的数据成员值复制过来  
                m\_real = c.m\_real;  
                m\_img    = c.m\_img;  
        \}             
        // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象  
        // 例如：下面将根据一个double类型的对象创建了一个Complex对象  
        Complex::Complex(double r)  
        \{  
                m\_real = r;  
                m\_imag = 0.0;  
        \}  
        // 等号运算符重载  
        // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建  
        // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作  
        Complex &operator=( const Complex &rhs )  
        \{  
                // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回  
                if ( this == &rhs )  
                \{  
                        return \*this;  
                \}  
                // 复制等号右边的成员到左边的对象中  
                this->m\_real = rhs.m\_real;  
                this->m\_imag = rhs.m\_imag;  
               // 把等号左边的对象再次传出  
               // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c  
               // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)      
                return \*this;  
        \}  
\}  
         下面使用上面定义的类对象来说明各个构造函数的用法：  
void main()  
\{  
        // 调用了无参构造函数，数据成员初值被赋为0.0  
        Complex c1，c2;  
        // 调用一般构造函数，数据成员初值被赋为指定值  
        Complex c3(1.0,2.5);  
        // 也可以使用下面的形式  
        Complex c3 = Complex(1.0,2.5);          
        //    把c3的数据成员的值赋值给c1  
        //    由于c1已经事先被创建，故此处不会调用任何构造函数  
        //    只会调用 = 号运算符重载函数  
        c1 = c3;          
        //    调用类型转换构造函数  
        //    系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1  
        c2 = 5.2;          
       // 调用拷贝构造函数( 有下面两种调用方式)  
        Complex c5(c2);  
        Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2  
\}

当你理解了以上的内容是再看上面我出的题，就知道答案原来是这样来的：

a\[4\]是类数组，有4个对象，调用构造函数4次，而\*p\[5\]是指针数组，也就是5个元素存放的是指向MyClass类型的对象的指针，没有初始化的指针为空，不指向任何对象，也不调用构造函数。

如果你懂了，我们再来看一道题：

##          类的对象MyClass a,b\[2\],\*c,\*\*d,\*e\[2\],\*g=new char B\[2\]分别调用几次构造函数？为什么？ ##

##          MyClass a：定义一个对象，调用1次构造函数。 ##

##          b\[2\]：定义含有两个元素的数组，实际上定义两个对象，所以调用2次构造函数。 ##

##          \*c：定义指向类对象的指针，但没有进行实际的内存分配，所以不调用构造函数。 ##

##          \*\*d：定义指向类对象指针的指针，但没有进行实际的内存分配，所以不调用构造函数。 ##

##          \*e\[2\]：定义含有两个指向类对象的指针的数组，但没有进行实际的内存分配，所以不调用构造函数。 ##

##          \*g=new MyClass \[2\]，涉及到内存的分配，调用2次构造函数。 ##

##          总结：只有涉及到内存分配的时候，才会调用构造函数。普通对象调用一次，对象数组调用N次(该数组含有N个元素)。只定义指针而不给指针赋值，则不涉及内存分配，不调用构造函数。 ##

##  ##