学习记录——day40 类中特殊的成员函数

已于 2024-08-30 18:55:27 修改
阅读量801 收藏 18
点赞数 11
文章标签： 学习
于 2024-08-29 20:26:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64918301/article/details/141687472
版权

一、类中提供的特殊成员函数

构造函数、析构函数、拷贝构造函数、拷贝复制函数、移动构造函数、移动复值函数、取地址运算符重载

        如果用户不显性定义这些函数，系统也会提供指向函数，如果用户显性定义了这些函数，系统就不会提供了。

        这些函数无论是系统提供还是用户定义，都不需要手动调用，特殊时机，系统自动调用

二、构造函数

        使用类去实例化对象时，为对象进行资源的申请以及初始化使用的

1、构造函数相关概念

1、构造函数没有返回值（不是 void ，单纯没有）
2、函数名与类同名
3、访问权限，一般为public
4、类名(形参列表){函数体内容}

 2、调用时机：当使用类实例化对象时，系统自动调用

1、栈区空间：使用类实例化对象时，系统自动调用

                类名 变量名(实参)； //此时就调用的构造函数

2、堆区空间：只有在使用new申请空间时，自动调用构造函数

                类名 *指针名；                 //此时仅仅只是定义一个指针变量，并没有为对象分配空间

                指针名 = new 类名(实参); //此时调用的构造函数

#include <iostream>


using namespace std;


class Stu
{
public:
    Stu()
    {
        cout<<"Stu的构造函数"<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;


    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

3、构造函数定义相关

1）构造函数分为有参构造和无参构造函数，有参构造函数可以为成员属性进行初始化，这些构造函数之间构成重载关系

2）一个类中可以有多个构造函数，每个对象仅仅只会调用一个构造函数

3）如果类中没有定义构造函数，那么，系统会自动提供一个无参构造函数，用于对对象空间的申请，如果程序员自己定义了构造函数，系统就不再提供那个无参构造了，如果还想使用无参构造，需要自己定义一个无参构造

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;


public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;
        this->age = a;
        cout<<"Stu::有参构造"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;


    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;


    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

4、构造函数初始化

使用方式：

        类名（形参1，形参2，。。。形参n）:成员1（形参1），成员2（形参2）......成员n(形参n)

{函数体内容}

说明：在构造函数的小括号后，由冒号引出初始化列表，括号外时成员变量，括号内是形参

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;


public:
    //无参构造
    Stu()
    {
        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string n, int a, double s):name(n),age(a),score(s)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;


    //申请一个对象，调用有参构造
    Stu s2("zhangsan", 18);          //此时调用了有参构造
    s2.show();
    cout<<"**************************************"<<endl;




    //申请一个对象，调用有参构造
    Stu s3("lisi", 20, 99.8);
    s3.show();
    cout<<"**************************************"<<endl;




    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    return 0;
}

5、必须使用初始化列表的情况

1）当构造函数的形参名和成员变量名同名时，可以使用初始化列表来解决

2）当类中有const修饰的成员变量时，对该变量也必须进行初始化，使用初始化列表解决

3）当类中有引用成员时，对该成员的操作也必须使用初始化列表完成

4）当类中有其他类的成员子对象时，对该成员的操作也必须使用初始化列表完成，如果没有使用初始化列表调用有参构造，则系统会自动调用成员子对象的无参构造

#include <iostream>


using namespace std;


class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}


private:
    string name;


};






class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象


public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity")
    {


        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }
};


int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;

    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数

    return 0;
}

三、析构函数

        功能：在对象消亡时，用于给对象回收空间使用的

1、析构函数相关概念

1）没有返回值（不是 void ，就是没有）

2）函数名：类名前加个波浪线 ~类名

3）权限：一般为public

4）没有参数，所以，一个类中只有一个析构函数，不能进行重载

5）格式： ~类名（）

 2、调用时机：当对象的生命周期结束后，用于回收内存空间

        栈区：当栈空间释放后，系统会自动调用该类的析构函数

        堆区：当使用delete关键字释放对象空间时，系统自动调用

3、如果没有手动定义析构函数，系统会提供一个析构函数，用于回收类对象的空间，如果手动定义了析构函数，那么，系统就不再提供默认的析构函数了

4、析构函数示例

#include <iostream>


using namespace std;


class Toy
{
public:
    Toy() {cout<<"Toy::无参构造"<<endl;}
    Toy(string n):name(n) {cout<<"Toy::有参构造"<<endl;}


private:
    string name;


};






class Stu
{
private:
    string name;
    int age;
    double score;
    const int value;        //类中有const类型的成员
    int &key;             //类中有引用成员
    Toy t;               //类中有其他类的成员子对象
    int *ptr;         //指针成员


public:
    //无参构造
    Stu():value(1314), key(*(new int(520))), t("hello kity"), ptr(new int(666))
    {


        cout<<"Stu的无参构造函数"<<endl;
    }
    //自定义有参构造
    Stu(string n, int a, int &k):value(1314), key(k)
    {
        this->name = n;         //对成员的赋值操作
        this->age = a;
        cout<<"Stu::有参构造1"<<endl;
    }


    //定义有参构造:使用初始化列表完成对成员的初始化工作
    Stu(string name, int age, double score, int &k):name(name),age(age),score(score),value(1314),key(k)
    {
        cout<<"Stu::有参构造2"<<endl;
    }


    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }


    //定义析构函数
    ~Stu()
    {
        delete ptr;          //释放指针的空间
        cout<<"STU::析构函数"<<endl;
    }
};




int main()
{
    //在栈区申请对象空间
    Stu s1;                       //此时调用了无参构造，只为对象申请了空间，但是没有为对象初始化
    s1.show();
    cout<<"**************************************"<<endl;




    //堆区空间申请对象
    Stu *ptr;          //此时不调用构造函数
    ptr = new Stu;      //此时调用构造函数


    //释放ptr的空间
    delete ptr;       //此时会调用析构函数


    return 0;
}

四、拷贝构造函数

        拷贝构造函数，是一个特殊的构造函数

1、相关概念

1）没有返回值
2）函数名与类同名
3）参数：该类的其他对象的引用
4）访问权限：一般为public
5）定义格式：
            类名 (类名 &other)

2、调用时机

1）使用一个类对象给另一个类对象初始化时
        string  s1("hello world");               //调用有参构造
        string s2 = s1;                      //调用拷贝构造
        string s3(s1);                       //调用拷贝构造
2）使用值传递时，实参取代形参的过程时，系统调用拷贝构造
3）使用值返回时，返回结果也是调用拷贝构造

3、如果没有手动定义拷贝构造函数，那么系统会自动提供一个拷贝构造函数来完成对新对象中成员的初始化工作，如果手动定义了拷贝构造函数，系统就不再提供了

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;


public:
    Stu() {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){cout<<"Stu::析构函数"<<endl;}           //析构函数
    //自定义拷贝构造函数
    Stu(Stu &other):name(other.name),age(other.age),score(other.score)
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }


    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
    }

};




//定义函数传递对象
Stu fun(Stu s)
{
    s.show();
    cout<<"fun 函数结束"<<endl;


    return s;
}


int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;


    Stu s3(s1);              //调用拷贝构造
    s3.show();


    cout<<"********************************************"<<endl;
    //调用功能函数
    fun(s1);
    cout<<"********************************************"<<endl;


    return 0;
}

4、类中成员指针的释放问题（深浅拷贝问题）

        定义一个类时，如果没有手动提供拷贝构造函数，系统会自动提供一个拷贝构造函数，来完成对象中成员的初始化工作，这个拷贝构造函数称为浅拷贝，如果类中没有指针成员，使用浅拷贝是没有问题的。
        如果类中有指针成员，并且指向的其他空间时，使用浅拷贝就会出现多个对象中指针成员指向同一个内存空间，析构指针空间时，会造成对同一块内存空间的多次释放的情况，造成段错误（double free）,此时就需要深拷贝。
        深拷贝需要程序手动定义拷贝构造函数，在拷贝构造函数的初始化列表中，给新对象的指针成员重新分配空间，将原来对象指针空间指向的内容拷贝到该空间中即可完成深拷贝。

#include <iostream>

using namespace std;

class Stu
{
private:
    string name;
    int age;
    double score;
    int *ptr;              //指针成员

public:
    Stu() {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s),ptr(new int(520)) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){
        delete ptr;             //释放堆区空间
        cout<<"Stu::析构函数"<<endl;
    }           //析构函数
    //自定义拷贝构造函数:深拷贝
    Stu(Stu &other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }

    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
        cout<<"*ptr = "<<*ptr<<endl;
        cout<<"ptr = "<<ptr<<endl;
    }

};

int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;

    return 0;
}

五、移动构造函数

        如果类中不显性定义拷贝构造函数或者移动构造函数，那么系统会自动提供这两个函数，如果程序员手动定义了其中任意一个函数，系统就两个都不提供了，如果需要使用，则需要程序员自己手动定义

1、相关概念

        1）移动构造函数，是将临时空间或将亡空间，托管给一个新的对象。

        2）没有返回值

        3）函数名与类同名

        4）参数：该类的其他对象的右值引用

        5）访问权限：一般为public

        6）定义格式： 类名 (类名 &&other)

2、调用示例

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;
    int *ptr;              //指针成员


public:
    Stu() {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s),ptr(new int(520)) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){
        delete ptr;             //释放堆区空间
        cout<<"Stu::析构函数"<<endl;
    }           //析构函数
    //自定义拷贝构造函数:深拷贝
    Stu(Stu &other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }


    //自定义移动构造函数
    Stu(Stu &&other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::移动构造函数"<<endl;
    }

    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
        cout<<"*ptr = "<<*ptr<<endl;
        cout<<"ptr = "<<ptr<<endl;
    }

};

int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;


    //调用移动构造函数
    Stu s3 = move(s1);
    s3.show();
    cout<<"********************************************"<<endl;


    return 0;
}

六、拷贝赋值函数

        拷贝赋值函数也称等号运算符重载

1、相关概念

2、调用时机

当使用一个类对象给另一个类对象赋值时，会自动调用拷贝赋值函数

        string s1("hello world"); //有参构造

        string s2 = s1; //拷贝构造

        string s3; //无参构造

        s3 = s1; //拷贝赋值函数

3、拷贝复制函数，如果不手动定义，系统会默认提供一个拷贝复制函数，如果手动定义了拷贝复制函数，那么系统就不会提供了。如果手动定义了移动构造函数，拷贝赋值函数不可用

 4、拷贝赋值函数也涉及深浅拷贝的问题：

        定义一个类时，如果没有手动提供拷贝赋值函数，系统会自动提供一个拷贝赋值函数，来完成对象中成员的赋值工作，这个拷贝赋值函数称为浅拷贝，如果类中没有指针成员，使用浅拷贝是没有问题的。

        如果类中有指针成员，并且指向的其他空间时，使用浅拷贝就会出现多个对象中指针成员指向同一个内存空间，析构指针空间时，会造成对同一块内存空间的多次释放的情况，造成段错误（double free）,此时就需要深拷贝。

        深拷贝需要程序手动定义拷贝赋值函数，在拷贝赋值函数的函数体内，给新对象的指针成员重新分配空间，将原来对象指针空间指向的内容拷贝到该空间中即可完成深拷贝。

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;
    int *ptr;              //指针成员


public:
    Stu():ptr(new int(0)) {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s),ptr(new int(520)) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){
        delete ptr;             //释放堆区空间
        cout<<"Stu::析构函数"<<endl;
    }           //析构函数
    //自定义拷贝构造函数:深拷贝
    Stu(const Stu &other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }


    //自定义移动构造函数
    Stu(Stu &&other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::移动构造函数"<<endl;
    }


    //自定义拷贝赋值函数
    Stu & operator=(const Stu &other)
    {
        if(this != &other)         //防止自己给自己赋值
        {
            //完成成员的赋值工作
            this->name = other.name;
            this->age = other.age;
            this->score = other.score;
            //        delete this->ptr;               //释放自己之前的空间
            //        this->ptr = new int(*other.ptr);         //深拷贝
            *this->ptr = *other.ptr;               //深拷贝
        }


        cout<<"拷贝赋值函数"<<endl;
        return *this;                //返回自身的引用
    }




    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
        cout<<"*ptr = "<<*ptr<<endl;
        cout<<"ptr = "<<ptr<<endl;
    }

};


int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;


    //调用移动构造函数
    Stu s3 = move(s1);
    s3.show();
    cout<<"********************************************"<<endl;


    //调用拷贝赋值函数
    Stu s4;                  //无参构造
    s4 = s1;                   //拷贝赋值函数  s4.operator=(s1)

    s4.show();
    cout<<"********************************************"<<endl;

    return 0;
}

七、移动赋值函数

        如果没有手动定义移动赋值函数，也没有手动定义任意一个特殊成员函数，此时，系统会自动提供一个移动赋值函数。如果提供了任意一个特殊成员函数，移动赋值函数就不提供了

#include <iostream>


using namespace std;


class Stu
{
private:
    string name;
    int age;
    double score;
    int *ptr;              //指针成员


public:
    Stu():ptr(new int(0)) {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s),ptr(new int(520)) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){
        delete ptr;             //释放堆区空间
        cout<<"Stu::析构函数"<<endl;
    }           //析构函数
    //自定义拷贝构造函数:深拷贝
    Stu(const Stu &other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }


    //自定义移动构造函数
    Stu(Stu &&other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::移动构造函数"<<endl;
    }


    //自定义拷贝赋值函数
    Stu & operator=(const Stu &other)
    {
        if(this != &other)         //防止自己给自己赋值
        {
            //完成成员的赋值工作
            this->name = other.name;
            this->age = other.age;
            this->score = other.score;
            //        delete this->ptr;               //释放自己之前的空间
            //        this->ptr = new int(*other.ptr);         //深拷贝
            *this->ptr = *other.ptr;               //深拷贝
        }


        cout<<"拷贝赋值函数"<<endl;
        return *this;                //返回自身的引用
    }


    //定义移动赋值函数
    Stu & operator=(Stu &&other)
    {
        if(this != &other)         //防止自己给自己赋值
        {
            //完成成员的赋值工作
            this->name = other.name;
            this->age = other.age;
            this->score = other.score;
            //        delete this->ptr;               //释放自己之前的空间
            //        this->ptr = new int(*other.ptr);         //深拷贝
            *this->ptr = *other.ptr;               //深拷贝
        }


        cout<<"移动赋值函数"<<endl;
        return *this;                //返回自身的引用
    }




    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
        cout<<"*ptr = "<<*ptr<<endl;
        cout<<"ptr = "<<ptr<<endl;
    }




};


class name
{
public:
    name() {}
};






int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;


    //调用移动构造函数
    Stu s3 = move(s1);
    s3.show();
    cout<<"********************************************"<<endl;


    //调用拷贝赋值函数
    Stu s4;                  //无参构造
    s4 = s1;                   //拷贝赋值函数  s4.operator=(s1)


    s4.show();
    cout<<"********************************************"<<endl;


    Stu s5;            //无参构造
    s5 = move(s1);     //移动赋值函数
    s5.show();
    cout<<"********************************************"<<endl;
    


    return 0;
}

七、取地址运算符重载

        功能：取得当前类对象的地址

1、相关概念

        1）返回值：当前类的指针

        2）参数：无

        3）权限：一般为public

        4）格式： 类名 * operator&()

2、 如果没有手动定义取地址运算符重载函数，系统会自动提供一个取地址运算符重载函数，如果手动定义了，系统就不再提供了

#include <iostream>

using namespace std;

class Stu
{
private:
    string name;
    int age;
    double score;
    int *ptr;              //指针成员

public:
    Stu():ptr(new int(0)) {cout<<"Stu::无参构造"<<endl;}          //无参构造
    Stu(string n, int a, double s):name(n),age(a),score(s),ptr(new int(520)) {cout<<"Stu::有参构造"<<endl;}  //有参构造
    ~Stu(){
        delete ptr;             //释放堆区空间
        cout<<"Stu::析构函数"<<endl;
    }           //析构函数
    //自定义拷贝构造函数:深拷贝
    Stu(const Stu &other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::拷贝构造函数"<<endl;
    }

    //自定义移动构造函数
    Stu(Stu &&other):name(other.name),age(other.age),score(other.score),ptr(new int(*other.ptr))
    {
        cout<<"Stu::移动构造函数"<<endl;
    }

    //自定义拷贝赋值函数
    Stu & operator=(const Stu &other)
    {
        if(this != &other)         //防止自己给自己赋值
        {
            //完成成员的赋值工作
            this->name = other.name;
            this->age = other.age;
            this->score = other.score;
            //        delete this->ptr;               //释放自己之前的空间
            //        this->ptr = new int(*other.ptr);         //深拷贝
            *this->ptr = *other.ptr;               //深拷贝
        }
        cout<<"拷贝赋值函数"<<endl;
        return *this;                //返回自身的引用
    }


    //定义移动赋值函数
    Stu & operator=(Stu &&other)
    {
        if(this != &other)         //防止自己给自己赋值
        {
            //完成成员的赋值工作
            this->name = other.name;
            this->age = other.age;
            this->score = other.score;
            //        delete this->ptr;               //释放自己之前的空间
            //        this->ptr = new int(*other.ptr);         //深拷贝
            *this->ptr = *other.ptr;               //深拷贝
        }


        cout<<"移动赋值函数"<<endl;
        return *this;                //返回自身的引用
    }


    //自定义取地址运算符重载函数
    Stu * operator&()
    {
        cout<<"取地址运算符重载函数"<<endl;
        return this;
    }

    //定义展示函数
    void show()
    {
        cout<<"name = "<<name<<endl;
        cout<<"age = "<<age<<endl;
        cout<<"score = "<<score<<endl;
        cout<<"*ptr = "<<*ptr<<endl;
        cout<<"ptr = "<<ptr<<endl;
    }

};

class name
{
public:
    name() {}
};

int main()
{
    Stu s1("zhangpp", 18, 99);          //调用有参构造构造一个s1对象
    s1.show();
    cout<<"********************************************"<<endl;


    Stu s2 = s1;             //调用拷贝构造
    s2.show();
    cout<<"********************************************"<<endl;


    //调用移动构造函数
    Stu s3 = move(s1);
    s3.show();
    cout<<"********************************************"<<endl;


    //调用拷贝赋值函数
    Stu s4;                  //无参构造
    s4 = s1;                   //拷贝赋值函数  s4.operator=(s1)


    s4.show();
    cout<<"********************************************"<<endl;
    
    //调用移动赋值函数
    Stu s5;            //无参构造
    s5 = move(s1);     //移动赋值函数
    s5.show();
    cout<<"********************************************"<<endl;


    //取地址运算符重载函数
    &s1;
    cout<<"********************************************"<<endl;

    return 0;
}

模仿string 封装一个类

#include <iostream>
#include<cstring>

using namespace std;

class myString
{
    private:
        char *str;          //记录c风格的字符串
        int size;            //记录字符串的实际长度
    public:
        //无参构造
        myString():size(10)
        {
            str = new char[size];         //构造出一个长度为10的字符串                    
        }
        //有参构造
        myString(const char *s);              //有参构造     string  s("hello wirld");
        //判空函数
        bool empty();
        //size函数
        int my_size();
        //length
        int my_length();
        //c_str函数
        char* my_str();
        //at函数
        char& at(int index);        
        //二倍扩容
        bool expend();
};

int main()
{
    cout << "Hello World!" << endl;
    return 0;
}

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

bool myString::empty()
{
    return !size;
}

int myString::my_size()
{
    return size;
}

int myString::my_length()
{
    return strlen(str);
}

char* myString::my_str()
{
    return str;
}

char& myString::at(int index)
{
    return str[index];
}

bool myString::expend()
{
    size *= 2;
    char* temp;
    temp = new char[size +1];
    delete str;
    str = temp;
    temp = NULL;
    
    return true;
}

子座
关注
学习记录——day40 匿名对象 友元 常成员
weixin_64918301的博客
08-30 687
学习记录——day40 类中特殊的成员函数-CSDN博客class Stuprivate:int age;public:Stu(){}//无参构造Stu(string n ,int a):name(n),age(a){}//有参构造~Stu(){}//析构函数int main()s1.show();Stu();//定义匿名对象return 0;1）不到万不得已的情况下，不要使用友元，因为友元的出现使得封装称为虚谈，友元破坏了类的封装性。
学习记录——day44 类中的关键字 explicit delete default
weixin_64918301的博客
09-05 147
explicit delete default
学习记录——day41 C++ 类的静态成员 static
weixin_64918301的博客
09-02 517
C/C++中static总结。
学习记录——day41 继承
weixin_64918301的博客
09-02 790
面向对象三大特征：封装、继承、多态基于一个已有的类，来创建出一个新类的过程叫做继承，原类称为父类，新类称为自类/派生类。主要用于提高代码的复用性。
学习记录——day42 多态
weixin_64918301的博客
09-03 768
静态多态：函数重载、运算符重载动态多态：函数重写。
学习记录——day41 运算符重载
weixin_64918301的博客
09-02 980
cout
学习记录——day43 模板
weixin_64918301的博客
09-04 386
tamplate 类型 函数名(参数类型1 参数名1， 参数类型2，参数名2，。。。{函数体内容}同一个模板生命下，只能定义一个函数，如果要定义多个，需要声明多个模板。
C++学习笔记———类之常量成员函数
Gopuwe的博客
08-16 392
#include<iostream> using namespace std; class Date{ int d,m,y; public : Date(){ d=1; m=1; } void add_year(int n); void add_month(int n); void add_day(in...
C++——类静态成员和友元函数
weixin_50464560的博客
05-15 804
编程题 1.静态成员的使用 代码： #include<iostream> using namespace std; class Time { public: static int totalTime; Time(int a,int b,int c); void ShowTime() { cout<<"hour:"<<hour<<" minute:"<<minute<<" second:"<<second<&lt
JAVA学习笔记第八天——示例代码Day08
07-19
在JAVA学习的过程中，第八天的主题聚焦于几个关键概念：接口的使用、多态以及内部类。这些知识点都是Java编程中的核心部分，对于理解和编写复杂的Java应用程序至关重要。 首先，让我们深入探讨接口（Interface）。...
python学习笔记day4之set类型（csdn）————程序.pdf
12-03
在实际应用中，集合常用于去重、成员关系测试、数据过滤以及算法中涉及集合运算的场景。例如，它可以用于找出两个列表的共同元素、找出一个列表中不存在于另一个列表的元素，或者在处理图形算法时查找相邻节点等。 ...
java学习笔记——day3
weixin_54365839的博客
03-26 604
重点掌握1、构造器2、this关键字3、封装思想5、String 1、构造器 学习主要目标： 知道对象具体是通过调用什么代码得到的 掌握为对象赋值的其他简便写法 为以后学习面向对象编程的其他内容做支撑 构造器：定义在类中，可以用于初始化一个类的对象，并返回对象的地址 修饰符 类名（参数列表）{ …… } 无参数构造器：默认存在，初始化对象时，成员变量的数据均采用默认值 有参数构造器：初始化对象时可以接收参数为对象进行赋值 一旦定义了有参数构造器，那么无参数构造器就没有了，如果还想用无参数构造器，此时就需要自
Node.js学习笔记 [黑马程序员]——day2
weixin_45732235的博客
10-21 1365
day2
深度学习每周学习总结J1（ResNet-50算法实战与解析 - 鸟类识别）
最新发布
qq_33489955的博客
10-04 644
数据导入及处理部分：本次数据导入没有使用torchvision自带的数据集，需要将原始数据进行处理包括数据导入，查看数据分类情况，定义transforms，进行数据类型转换等操作。划分数据集：划定训练集测试集后，再使用torch.utils.data中的DataLoader()分别加载上一步处理好的训练及测试数据，查看批处理维度.模型构建部分：resnet-50。
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 888
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
10.2学习
2401_87363162的博客
10-02 1103
​ Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
从0学习React（3）
qq_54432917的博客
09-29 684
在第一篇文章中，我们对index.tsx文件的每一行代码都做了简单的分析。通过第一篇文章的总结，我也大致知道了index.tsx里的很多语法。而第二篇文章，我对index.tsx文件的框架做了一个大致的分析，通过第二篇文章，我对index.tsx有了进一步的认识。按理来讲，第三篇文章我还是解析index.tsx文件，但是我发现，对于前两篇文章，其实我对语法的细节有很多不明白的点。因此这篇文章，我就把React的一些最基础的知识给梳理一下，帮助我更好的理解index.tsx的代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值