[C++知识库]关于c++中调用构造函数的一些事项

最后修改时间2022/3/9

一.默认构造函数

????????我们知道，当我们创建某个类的对象时，编译器将自动调用构造函数。如果我们在类的定义中没有声明定义构造函数，则将调用一个编译器自动创建的不带参数的默认构造函数。

//默认构造函数
//default construction
ClassName::ClassName()
{
}

????????相反，如果我们定义了构造函数，则编译器将不会自动创建默认构造函数。若这时恰好我们自定义的构造函数，是有参数且不带缺省值(默认值)的。那么，当我们调用一个无参的构造函数时，编译器就会报错。

Error："no matching function for call to 'ClassName::ClassName()'",
//不存在默认构造函数

????????所以我们可以在编写类时，定义两个构造函数，其中一个是不带参数的默认构造函数，或者只定义一个有缺省值的构造函数，就可以很好避免这种错误。

二.某些情况下调用(拷贝)构造函数

? ? ? ? 在一些“隐秘”的情况下，编译器也是会调用构造函数的。例如，我们定义了一个存放字符串的类String，其类定义如下

class String
{
    private:
        char * str;
        int len;
        static int num;
        
    public:
        String();
        String(const char *);
        String(String&);
        ~String();
        static int GetNum(){ return num; }

};

下面是几个类中公有函数的简单实现

int String::num = 0;

String::String()
{
    len = 1;
    str = new char[1];
    str = 0;
    num++;
}

String::String(const char * s)
{
    len = strlen(s);
    str = new char[len+1];
    strcpy(str, s);
    num++;
}

String::String(String &s)
{
    len = s.len;
    str = new char[len+1];
    strcpy(str, s.str);
    num++;
}

String::~String()
{
    delete[] str;
}

? ? ? ? 在上面的代码中，我们首先设置了静态数据成员num的值，然后定义了不带参数的默认构造函数和一个带参数的构造函数。还有一个拷贝构造函数和一个析构函数。

? ????????同时我们在上面公有函数定义的部分，再添加一个如下的=运算符重载?（当然同时也要在头文件中声明该函数）

String& String::operator=(const String &s)
{
    if(this == &s)
        return *this;

    delete[] str;
    len = s.len;
    str = new char[len];
    strcpy(str, s.str);
    return *this;
}

????????? 如果此时我们在main函数中，运行以下代码

String st1("Yuki");
char temp[3] = "yu";
st1 = temp; 
cout<<String::GetNum();

? ? ? ? 在这里，程序将会输出数字2，因为程序第三行的st1="yu";也将会调用构造函数。原因也是很容易想清楚的，当我们把“yu”这个字符串赋值给st1时，会产生一个从字符串向我们定义的String类对象转化的过程，相当于我们调用了st1=String("yu");这个语句。然后又通过赋值运算符将其赋值了过去。这样也就不难明白为什么会调用构造函数了。

? ? ? ? 但是，如果我们把main函数中的代码稍微改变一下，变成下面这样

String st1("Yuki");
String temp;
st1 = temp; 
cout<<String::GetNum();

????????此时运行程序，程序又会输出数字1，因为这里main函数中的第三行没有调用构造函数。这里不像上一步，此处的temp也是我们定义的String类的对象，是直接通过我们重载的赋值运算符赋值的过程，所以不存在转化的过程，也就不存在调用构造函数的过程了。

? ? ? ? 接着，如果我们又稍微改动一点，改成下面这样

String st1("Yuki");
String temp = st1; 
cout<<String::GetNum();

? ? ? ? 此时程序又会输出2了，因为这里的第二行是一个对象初始化的过程，一定会调用(拷贝)构造函数。 但是具体分两种实现。一种是，相当于运行了代码String temp(st1)，这种情况下，不使用我们重载过的赋值运算符，而是直接调用拷贝构造函数，将对象st1作为参数传递到构造函数中。第二种是，先利用拷贝构造函数创建一个临时变量，然后再通过我们重载的赋值操作符，赋值给对象temp。也就是说当用一个对象去初始化另一个对象的时候，一定会调用拷贝构造函数。这样就很容易理解了。

? ? ? ? 接着我们又尝试，再定义一个赋值运算符重载的重载，然后再运行之前的main函数代码

String st1("Yuki");
char temp[3] = "yu";
st1 = temp; 
cout<<String::GetNum();

? ? ? ? 新定义的重载如下

String& String::operator=(const char * ch)
{
    delete[] str;
    len = strlen(ch);
    str = new char[len + 1];
    strcpy(str, ch);
    return *this;
}

? ? ? ? 这时候我们运行程序，又会发现什么呢？此时依旧会输出1。因为这里我们重载的赋值运算符允许直接接受字符串作为参数传递，所以程序直接调用了重载的赋值运算符，不需要再调用构造函数。