cpp_06_缺省构造_拷贝构造_拷贝赋值_初始化表

最新推荐文章于 2024-11-04 09:49:03 发布
最新推荐文章于 2024-11-04 09:49:03 发布
阅读量1.2k 收藏 20
点赞数 17
分类专栏： Cpp 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33331020/article/details/135172791
版权

1  构造函数

1.1  构造函数可重载：

                构造函数可以通过形参表的差别化形成重载关系

                重载关系的构造函数，通过构造函数的实参类型进行匹配

                使用缺省参数可以减少构造函数重载的数量

// consover.cpp 构造函数的重载
#include <iostream>
using namespace std;

class Human {
public:
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
/*  Human( ) {
        cout << "1. Human() --> ";
        m_age = 0;
        m_name = "无名";
    }
    Human( int age ) {
        cout << "2. Human(int) --> ";
        m_age = age;
        m_name = "无名";
    }*/
    Human( int age=0, const char* name="无名" ) {//使用缺省值，减少上2个重载构造函数
        cout << "3. Human(int,const char*) --> ";
        m_age = age;
        m_name = name;
    }
private:
    int m_age;
    string m_name;
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()
    h.getinfo( );

    Human h2(22); // 定义h2,利用h2.Human(22)
    h2.getinfo( );

    Human h3(22,"张飞"); // 定义h3,利用h3.Human(22,"张飞")
    h3.getinfo( );
    return 0;
}

1.2  四类构造函数：

        构造函数本没有分类，按参数个数，可分为四类：

                多参构造函数                   //2参及以上

                无参（缺省）构造函数    //0参

                拷贝构造函数                  //单参

                类型转换构造函数           //单参

2  缺省构造函数

2.1  理论

        1）也称无参构造函数，但其未必真的没有任何参数：

              为一个有参构造函数的每个形参都提供一个缺省值，同样可以达到无参构造函数的效果。

        2）如果一个类没有定义任何构造函数，那么编译器会为其提供一个无参构造函数：

                对基本类型的成员变量进行定义，并初始化为随机数；

                对类类型的成员变量进行定义，调用相应类型的无参构造函数。

              （由此强烈建议，为每个类提供无参的构造函数，因为它可能作为另外类的成员变量）

        3）如果一个类定义了构造函数，无论这个构造函数是否带有参数，编译器都不再为这个类

              提供无参构造函数，

              但仍会对成员变量进行定义/初始化为随机数，程序员自己按需再赋值即可：

                            Human( int age=0, const char* name="无名" ) {
                                  //【int m_age;】定义m_age,初值为随机数
                                  //【string m_name;】定义m_name,利用m_name.string()
                                  m_age = age;
                                  m_name = name;
                            }

// defaultcons.cpp 缺省构造函数
#include <iostream>
using namespace std;

class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {
       【int m_age;】定义m_age,初值为随机数
       【string m_name;】定义m_name,利用m_name.string()
    }*/
    Human( int age=0, const char* name="无名" ) {
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类缺省构造函数被调用" << endl;
        m_age = age;
        m_name = name;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)
    h.getinfo( );

    Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)
    h2.getinfo();
    return 0;
}

 

2.2  缺省构造过程

        

       

2.3  缺省构造函数 必要性！

        强烈建议，为每个类提供无参的构造函数，因为它可能作为另外类的成员变量：

//hastodeflt.cpp
// 强烈建议大家在设计一个类时，给这个类提供一个无参构造函数,
//因为这个类对象非常有可能作为另一个的成员变量出现
#include <iostream>
using namespace std;

class A { // 当前A类有无参构造 
public:
    A( int i=0 ) { 
        m_i = i;
    }
private:
    int m_i;
};

class Human {
public:
    Human( int age=0, const char* name="无名" ) {
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        //【A m_a;】定义m_a,利用m_a.A()
        cout << "Human类缺省构造函数被调用" << endl;
        m_age = age;
        m_name = name;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
    A m_a; // 类类型的成员变量
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)
    h.getinfo( );

    Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)
    h2.getinfo();
    return 0;
}

3  拷贝构造函数

3.1  理论

        what？ ①构造函数只有1个形参      ②且参数类型与类名相同。

        class  类名{

                类名( const  类名&  that ){ ... }   // const 和 & 非必须，有了更好

                                                                  // &提升效率，const变万能引用

        }; 

        1）作用：利用一个已定义的对象，来定义其同类型的副本对象，即对象克隆。

        2）如果一个类没有定义拷贝构造函数，那么编译器会为其提供一个默认拷贝构造函数。

              -对基本类型成员变量进行定义，并赋初值（按字节复制）；

              -对类类型成员变量进行定义，并调用相应类型的拷贝构造函数。

        3）如果自己定义了拷贝构造函数，编译器将不再提供默认拷贝构造函数，这时所有与成员复制有关的操作，都必须自己编写代码完成。

                    Human( const Human& that ) { 
                          //【int m_age;】定义m_age,初值为随机数   编译器完成
                          //【string m_name;】定义m_name,利用m_name.string()   编译器完成
                          cout << "Human类拷贝构造函数被调用" << endl;    //手写
                          m_age = that.m_age;        //手写
                          m_name = that.m_name;  //手写
                    }

        4）由3）可知，自己写的效率低。因定义和赋值，进行了2次赋值（用初始化表可规避）。

        5）若拷贝构造函数不能满足要求，需自己定义。

// copycons.cpp 拷贝构造函数
#include <iostream>
using namespace std;

class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {
       【int m_age;】定义m_age,初值为随机数
       【string m_name;】定义m_name,利用m_name.string()
    }*/
    Human( int age=0, const char* name="无名" ) {
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类缺省构造函数被调用" << endl;
        m_age = age;
        m_name = name;
    }
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 
       【int m_age=that.m_age;】定义m_age,初值为that.m_age
       【string m_name(that.m_name);】定义m_name,
                               利用m_name.string(that.m_name)-->string类拷贝构造函数
    }*/
    Human( const Human& that ) { 
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类拷贝构造函数被调用" << endl;
        m_age = that.m_age;
        m_name = that.m_name;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)
    h.getinfo( );

    Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)
    h2.getinfo();

    Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数
    h3.getinfo();
    return 0;
}

3.2  拷贝构造过程

        

3.3  拷贝构造函数的调用时机

        一切出现对象克隆的情况，都会调用拷贝构造函数：

        1）用已定义对象作为同类型对象的构造实参 

        2）以对象的形式向函数传递参数 

        3）从函数中返回对象 

        注意：某些拷贝构造过程会因编译优化而被省略。

// copytime.cpp 拷贝构造函数被调用的时间点
#include <iostream>
using namespace std;

class Human {
public:
    Human( int age=0, const char* name="无名" ) {
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        m_age = age;
        m_name = name;
    }
    Human( const Human& that ) { 
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类拷贝构造函数被调用" << endl;
        m_age = that.m_age;
        m_name = that.m_name;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
};
// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
void foo( Human v ) {
    // ...
}
Human bar( ) {
    Human m;
    return m; // 利用m克隆一个无名对象
}
int main( void ) {

    Human h2(22,"张飞");

    Human h3(h2); // = h2; // (1)触发拷贝构造函数

    foo( h3 ); // (2)触发拷贝构造函数

    Human h4 = /*|...|*/ bar(); // 会触发2次拷贝构造函数，但编译器优化为0次

    // -fno-elide-contructors   不让编译器优化
    return 0;
}

4  拷贝构造与拷贝赋值的区别

        拷贝构造函数的对象是新创建的， 最好用初始化表

        拷贝赋值函数的对象是已有的，    不能用初始化表

5  拷贝赋值函数（不是构造函数）

5.1  理论

        what？  ① operator=    ② 参数只有一个  ③ 参数类型与类名相同

        class  类名{

                类名&  operator=( const  类名&  that ) { ... }  // &提升传参效率，const变万能引用

        };

        1）作用：用于一个已定义存在的对象，给已存在的同类型对象赋值，即对象赋值。

        2）如果一个类没有定义拷贝赋值函数，那么编译器会为其提供一个默认拷贝赋值函数。

                -对基本类型成员变量，值传递（按字节复制）

                -对类类型成员变量，调用相应类型的拷贝赋值函数。

        3）如果自己定义了拷贝赋值函数，编译器将不再提供默认拷贝赋值函数，这时所有与成员复制有关的操作，都必须自己写代码完成。（编译器也不会在自定义的函数中定义成员变量/包子馅，因为这不是构造函数。成员变量早就有了。）

        4）若默认拷贝赋值函数不能满足要求时，需自己定义。

// copyassignment.cpp 拷贝赋值函数:用于 对象之间的赋值
#include <iostream>
using namespace std;

class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {
       【int m_age;】定义m_age,初值为随机数
       【string m_name;】定义m_name,利用m_name.string()
    }*/
    Human( int age=0, const char* name="无名" ) {
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类缺省构造函数被调用" << endl;
        m_age = age;
        m_name = name;
    }
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 
       【int m_age=that.m_age;】定义m_age,初值为that.m_age
       【string m_name(that.m_name);】定义m_name,
                                 利用m_name.string(that.m_name)-->string类拷贝构造函数
    }*/
    Human( const Human& that ) { 
        //【int m_age;】定义m_age,初值为随机数
        //【string m_name;】定义m_name,利用m_name.string()
        cout << "Human类拷贝构造函数被调用" << endl;
        m_age = that.m_age;
        m_name = that.m_name;
    }
//  如果类没有提供拷贝赋值函数,编译器将提供一个默认的拷贝赋值函数
/*  Human& operator=( const Human& that ) {
        this->m_age = that.m_age;
        this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->
                                    // string类的拷贝赋值函数
        return *this;
    }*/
    Human& operator=( const Human& that ) {
        // 编译器不会再拷贝赋值函数中塞任何操作
        cout << "Human类的拷贝赋值函数被调用" << endl;
        this->m_age = that.m_age;
        this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->
                                    // string类的拷贝赋值函数
        return *this;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)
    h.getinfo( );

    Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)
    h2.getinfo();

    Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数
    h3.getinfo();

    Human h4; // 定义h4,利用h4.Human()-->h4维护的内容为(无名,0)
    cout << "h4被赋值前---";
    h4.getinfo();

    h4 = h3; // h4.operator=(h3)-->触发拷贝赋值函数
    cout << "h4被赋值后---";
    h4.getinfo();
    return 0;
}

5.2  拷贝赋值过程

        

6  初始化表

6.1  理论

        初始化表只能在构造函数中使用。

        通过在类的构造函数中使用初始化表，可以通知编译器该类的成员变量如何被初始化。

        类中的基本类型成员变量，最好在初始化表中显示指明如何初始化，否则初值不确定。

        类中的类类型成员变量，最好在初始化表中显示指明如何初始化，否则将调用相应类型的无参构造函数（维护一个空串""，即\0）。

// initlist.cpp
// 初始化表 -- 只能在构造函数中使用(指导编译器如何给定义出来的成员变量做初始化)
#include <iostream>
using namespace std;

class Human {
public:
//  如果类没有提供任何构造函数,编译器将提供一个无参的构造函数
/*  Human() {
       【int m_age;】定义m_age,初值为随机数
       【string m_name;】定义m_name,利用m_name.string()
    }*/
    Human( int age=0, const char* name="无名" ) : m_age(age),m_name(name) {
        //【int m_age=age;】定义m_age,初值为age
        //【string m_name(name);】定义m_name,利用m_name.string(name)
        cout << "Human类缺省构造函数被调用" << endl;
    }
//  如果类没有提供拷贝构造函数,编译器将提供一个默认的拷贝构造函数
/*  Human( const Human& that ) { 
       【int m_age=that.m_age;】定义m_age,初值为that.m_age
       【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)-->
                                       //                     string类拷贝构造函数
    }*/
    Human( const Human& that ) : m_age(that.m_age), m_name(that.m_name) { 
        //【int m_age=that.m_age;】定义m_age,初值为that.m_age
        //【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)
        cout << "Human类拷贝构造函数被调用" << endl;
    }
//  如果类没有提供拷贝赋值函数,编译器将提供一个默认的拷贝赋值函数
/*  Human& operator=( const Human& that ) {
        this->m_age = that.m_age;
        this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->
                                    //                  string类的拷贝赋值函数
        return *this;
    }*/
    Human& operator=( const Human& that ) {
        // 编译器不会再拷贝赋值函数中塞任何操作
        cout << "Human类的拷贝赋值函数被调用" << endl;
        this->m_age = that.m_age;
        this->m_name = that.m_name; // this->m_name.operator=(that.m_name)-->
                                    //                  string类的拷贝赋值函数
        return *this;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << endl;
    }
private:
    int m_age; // 基本类型的成员变量
    string m_name; // 类类型的成员变量
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {
    Human h; // 定义h,利用h.Human()-->h维护的内容为(无名,0)
    h.getinfo( );

    Human h2(22,"张飞"); // 定义h2,利用h2.Human(22,"张飞")-->h2维护的内容为(张飞,22)
    h2.getinfo();

    Human h3(h2); // = h2; // 定义h3,利用h3.Human(h2)-->触发拷贝构造函数
    h3.getinfo();

    Human h4; // 定义h4,利用h4.Human()-->h4维护的内容为(无名,0)
    cout << "h4被赋值前---";
    h4.getinfo();

    h4 = h3; // h4.operator=(h3)-->触发拷贝赋值函数
    cout << "h4被赋值后---";
    h4.getinfo();
    return 0;
}

6.2  初始化表 过程图 

 

6.3  必须在初始化表中指明的情境

        类的常量型成员变量和引用型成员变量，必须在初始化表中显示初始化。

// hastoinit.cpp 必须使用初始化表的情况
#include <iostream>
#include <cstring>
using namespace std;

class Human {
public:
    Human( int age=0, const char* name="无名", float score=0.0 )
                    : m_age(age),m_name(name),m_score(score),m_len(strlen(name)) {
        //【int m_len=strlen(name);】
        //【int m_age=age;】定义m_age,初值为age
        //【string m_name(name);】定义m_name,利用m_name.string(name)
        //【const float m_score=score;】
        cout << "Human类缺省构造函数被调用" << endl;
    }
    Human( const Human& that ) 
        :m_age(that.m_age),m_name(that.m_name),m_score(that.m_score),m_len(that.m_len){
        //【int m_len = that.m_len;】
        //【int m_age=that.m_age;】定义m_age,初值为that.m_age
        //【string m_name(that.m_name);】定义m_name,利用m_name.string(that.m_name)
        //【const float m_score=that.m_score;】
        cout << "Human类拷贝构造函数被调用" << endl;
    }
    void getinfo( ) {
        cout << "姓名: " << m_name << ", 年龄: " << m_age << ", 成绩:" << m_score
             << ", 名字长度:" << m_len << endl;
    }
private:
    int m_len; // 保存名字字符串的长度
    int m_age;
    string m_name; // 保存名字字符串
    const float m_score; // 常量型的成员变量
//    int m_len; // 保存名字字符串的长度
};

// 模拟类的设计者(类库、别人设计的类、自己设计的类)
// --------------------------------
// 模拟用户(使用类的人)
int main( void ) {

    Human h2(22,"张飞",88.5); // 触发缺省构造函数
    h2.getinfo();

    Human h3(h2); // 触发拷贝构造函数
    h3.getinfo();

    return 0;
}

6.4  初始化顺序

        类的成员变量按其在类中的声明顺序依次被初始化，而与其在初始化表中的顺序无关。

        为了 避开 顾及声明顺序，在初始化表中定义每个成员变量时，尽量不要牵扯其他成员变量，可以考虑用形参代替其他成员变量。。

// twodimensional.cpp 设计一个二维坐标系的 类
#include <iostream>
using namespace std;

class TwoDimensional {
public:
    TwoDimensional( int x=0, int y=0 ) : m_x(x), m_y(y) {
        //【int m_x=x;】定义m_x初值为x
        //【int m_y=y;】 定义m_y初值为y
    }
    TwoDimensional( const TwoDimensional& that ) : m_x(that.m_x), m_y(that.m_y) {
        //【int m_x=that.m_x;】
        //【int m_y=that.m_y;】
    }
    TwoDimensional& operator=( const TwoDimensional& that ) {
        m_x = that.m_x;
        m_y = that.m_y;
    }
    void getinfo( /* TwoDimensional* this */ ) { // 非常函数
        cout << "横坐标: " << m_x << ", 纵坐标: " << m_y << endl;
    }
private:
    int m_x; // 横坐标
    int m_y; // 纵坐标
};

int main( void ) {
    TwoDimensional a(100,300); // 定义a,利用a.TwoDimensional(100,300)
    a.getinfo( );

    TwoDimensional b(a); // = a;  --> 触发拷贝构造函数
    b.getinfo( );

    TwoDimensional c;
    c.getinfo( );
    
    c = b; // --> 拷贝赋值函数
    c.getinfo( );

    return 0;
}

wwwwood
关注
专栏目录
Day39、构造函数重载、缺省构造函数、拷贝构造函数、初始化表
tangzihao_c的博客
09-24 593
一、            构造函数和初始化表 1、构造函数可以重载 1）构造函数通过参数表的差别化形成重载关系，创建对象时通过构造实参类型选择匹配，表示不同的对象创建方式 2）可以适当使用缺省参数，减少构造函数重载版本数量，但注意不要和缺省参数构造歧义错误。   1#include   2using namespace std;   3class student{   4publi
构造、拷贝构造、拷贝赋值、析构 C++
生活需要深度
01-11 406
限定符 含义 const const类型的对象在程序执行期间不能被修改改变。 volatile 修饰符volatile告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以加快读写效率。 restrict 由restrict修饰的指针是唯一一种访问它所指向的对象的方式。只有 C99 增加了新的类型限定符 restrict。 ...
cpp_07_类型转换构造_析构函数_深拷贝_静态成员
wwwwood的博客
12-27 1357
类型转换构造 析构函数 深拷贝 静态成员
CPP_类默认函数：构造函数，拷贝构造函数，赋值函数和析构函数
weixin_30954607的博客
09-09 318
类默认函数：构造函数，拷贝构造函数，赋值函数和析构函数 // person.h #ifndef _PERSON_H_ #define _PERSON_H_ class Person{ public : Person(); Person(int myage, char *myname); Person(const Per...
Cpp真经1--拷贝构造与拷贝赋值
weixin_43604927的博客
01-03 619
浅拷贝/深拷贝 如果类中包含了指针形式的成员变量，缺省的拷贝构造只是复制了指针变量自身，而没有复制指针所指向的内容，这种拷贝方式被称为浅拷贝。浅拷贝将会导致不同对象之间的数据共享，如果数据在堆区，析构时还可能会引发"double free",导致进程终止，所以就必须自定义一个指针复制指针所指向内容的拷贝构造函数，即深拷贝。当两个对象进行赋值操作时，比如“i3=i2”,编译器会自动将其处理为i3.operator=(i3)成员函数调用形式，其中"operator="被称为拷贝赋值操作符函数，由该函数实现两个对
C++ 拷贝构造函数 赋值构造函数
u014571231的专栏
05-12 526
C++ 拷贝构造函数 赋值构造函数 拷贝构造函数和赋值构造函数的异同
【C++】拷贝构造函数和赋值函数
小鱼菜鸟的博客
07-23 221
0.需要注意的问题 1、拷贝构造函数和赋值函数，都需要注意深拷贝和浅拷贝的问题 2、赋值构造函数必须能够处理自我赋值的问题，因为自我赋值会出现指针指向一个已经释放的内存。还有赋值构造函数必须注意它的函数原型，参数必须是引用类型，返回值也必须是引用类型，否则在传参和返回的时候都会再次调用一次拷贝构造函数。 (拷贝构造函数和赋值函数的实现：https...
赋值运算符重载和拷贝构造函数
一首小夜曲
08-02 1540
C++本质：类的赋值运算符=的重载，以及深拷贝和浅拷贝 关键词：构造函数，浅拷贝，深拷贝，堆栈(stack)，堆heap，赋值运算符 摘要:     在面向对象程序设计中，对象间的相互拷贝和赋值是经常进行的操作。     如果对象在申明的同时马上进行的初始化操作，则称之为拷贝运算。例如：         class1 A("af"); class1 B=A;      此时其实际调
拷贝构造函数的调用以及浅拷贝与深拷贝的理解
lq.nadal的博客
03-02 1721
拷贝构造函数的调用以及浅拷贝与深拷贝的理解 &amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;&amp;amp;amp;amp;nbsp;今天一直在研究拷贝构造函数相关的东西，我这个大四老狗感觉又回到了大一学C++的时候。瞎捣鼓了一天，略微还
合成拷贝构造函数与拷贝构造函数初始化
g1ider的专栏
04-25 1949
// copyconstructor.cpp : Defines the entry point for the console application. // #include "stdafx.h" class A { public: A(){} ~A(){} int v; }; class B { public: B(){} //B(B &b) : a(b.a) {} //
C++构造函数的初始化列表
qq_42591783的博客
10-16 1320
目录 先谈赋值 多次赋值 定义 初始化 初始化列表 不能对同一个变量多次进行初始化 注意 不使用初始化列表初始化A类对象 自定义类型成员有相应的默认构造函数时 初始化列表中的初始化顺序 调试证明： 类中的static成员进行初始化 概念 特性 C++11初始化新玩法 先谈赋值 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。 虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始...
Cpp_继承
Jerry的专栏
02-29 2366
一、继承的基本概念第一级抽象：从具体的对象抽象出共同的属性和行为。学生：姓名、年龄、学号、吃饭、睡觉、学习 教师：姓名、年龄、工资、吃饭、睡觉、授课 第二级抽象：将类型之间共性抽取出来形成超集，将类型之间的个性具体化的不同子集中。人类：姓名、年龄、吃饭、睡觉 - 超集体现共性 - 基类 | 派生 ^ 学生是人类的一部分：学号、学习 \ 子集 - 子类 V
C++ 笔记4 | 构造函数和初始化列表
jackJruit的博客
04-10 233
十四 、构造函数和初始化列表 1 构造函数可以重载，也可以带有缺省参数 //匹配string的无参构造函数 string s; //匹配string的有参(const char*)构造函数 string s("hello"); --------------------------------- http://www.cplusplus.com/ 2 缺省构造函数(无参构造函数) 1）如果类中没有定义任何构造函数,编译器会为该类提供一个缺省(无参)构造函数： –》对于基本类型成员变量不做初始化
C++拷贝控制的艺术：拷贝构造函数与赋值运算符重载实战指南
C++语言提供了强大的拷贝控制机制，其中包括拷贝构造函数、赋值运算符和析构函数等，这些机制深刻影响着对象的生命周期。在深入讨论拷贝构造函数和赋值运算符之前，我们需要对拷贝控制有一个全面的认识。 拷贝控制...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 259
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2400
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 600
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
最新发布
weixin_42300449的博客
11-04 205
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 203
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值