C++默认成员函数（一）

最新推荐文章于 2024-06-22 21:53:36 发布
最新推荐文章于 2024-06-22 21:53:36 发布
阅读量1.4k 收藏 16
点赞数 31
分类专栏： C++基础知识 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/136897524
版权

目录

默认成员函数

构造函数

构造函数介绍

构造函数使用

构造函数细节知识

析构函数

析构函数使用

拷贝构造函数

拷贝构造函数使用

拷贝构造函数使用实例

默认成员函数

在C++中，每一个类都会默认生成6个成员函数

  1. 默认构造函数
  2. 默认析构函数
  3. 默认拷贝构造函数
  4. 赋值重载
  5. 普通对象取地址
  6. const对象取地址

默认成员函数，指用户没有显式地定义，编译器会自动生成的成员函数

构造函数

构造函数介绍

在C语言中，如果要给一个整体初始化时，需要使用一个函数，并且需要自行调用

#include <stdio.h>
typedef struct Date
{
    int year;
    int month;
    int day;
}Date;

//初始化函数
void InitDate(Date* d)
{
    d->day = 20;
    d->month = 3;
    d->year = 2024;
}


int main()
{
    Date d = {0};
    InitDate(&d);
    printf("%d/%d/%d", d.year, d.month, d.day);
    return 0;
}
输出结果：
2024/3/20

在C++中也可以像C语言一样将初始化函数封装到类中

#include <iostream>
using namespace std;

class Date
{
private:
    int _day;
    int _year;
    int _month;
public:
    void Init(int year = 2024, int month = 3, int day = 20)
    {
        _day = day;
        _year = year;
        _month = month;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;
    d.Init();//全缺省不给实参默认为缺省值
    d.print();

    return 0;
}
输出结果：
2024-3-20

但是，这种方法每次对成员变量进行初始化都需要调用Init()函数，难写不说还容易忘记，所以在C++中支持在对象实例化的同时调用的一种函数，该函数即为构造函数，此时上面的代码可以改成

#include <iostream>
using namespace std;

class Date
{
private:
    int _year;
    int _month;
    int _day;
public:
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;//对象实例化时自动调用构造函数，不给任何参数时使用全缺省值
    d.print();

    return 0;
}
输出结果：
2024-3-20

构造函数使用

在C++中，构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。构造函数的主要任务并不是开空间创建对象，而是初始化对象

C++中的构造函数有下面的特点：

  1. 构造函数与类名相同
  2. 构造函数无返回值（没有也不能写void）
  3. 对象实例化时会自动调用对应的默认构造函数
  4. 构造函数可以重载
  5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成
  6. 默认构造函数不会对内置类型做任何改变，但是对于自定义类型来说，会调用自定义类型的构造函数。但是在，C++11 中针对内置类型成员不初始化的缺陷，内置类型成员变量在类中声明时可以给默认值

📌

无参构造函数、全缺省构造函数以及编译器默认生成的构造函数，都可以认为是默认构造函数，并且默认构造函数只能有一个。

#include <iostream>
using namespace std;

class Date
{
private:
    int _day;
    int _month;
    int _year;
public:
    Date()
    {
        //无任何参数的也称为默认构造函数
        cout << "无参构造函数调用" << endl;
    }
    
    //有参但不是缺省参数的构造函数重载
    Date(int year, int day, int month)
    {
        _year = year;
        _month = month;
        _day = day;
        cout << "有参构造函数调用" << endl;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;//不写参数时调用无参构造，不给参数时不用写括号，否则编译器将无法辨认是函数声明是对象实例化
    Date d1(2024, 3, 20);
    d.print();
    d1.print();
    return 0;
}
输出结果：
无参构造函数调用
有参构造函数调用
-858993460--858993460--858993460
2024-3-20

在上面的代码中，默认构造函数并没有对成员变量做出改变，在实例化后，成员变量中的值为随机值，该现象也同样使用编译器默认生成的构造函数

#include <iostream>
using namespace std;

class Date
{
private:
    int _day;
    int _month;
    int _year;
public:
    //编译器自动生成构造函数

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;//不写参数时调用编译器自动生成的构造
    d.print();
    return 0;
}
输出结果：
-858993460--858993460--858993460

📌

需要注意的是，因为默认构造函数一个类中只能有一个，所以全缺省构造函数和无参构造函数不能同时被运行调用，因为编译器无法区分调用哪一个默认构造函数

#include <iostream>
using namespace std;

class Date
{
private:
    int _day;
    int _month;
    int _year;
public:
    Date()
    {
        //无任何参数的也称为默认构造函数
        cout << "无参构造函数调用" << endl;
    }

    //全缺省默认构造函数
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;//不写参数时调用无参构造以及编译器自动生成的构造
    d.print();
    return 0;
}
报错信息：
类 "Date" 包含多个默认构造函数

构造函数细节知识

  • 对于调用无参或者全缺省的默认构造函数的理解
#include <iostream>
using namespace std;

class Date
{
private:
    int _year;
    int _month;
    int _day;
public:
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;
    //不可以理解为d.Date();
    d.print();
    return 0;
}
输出结果：

在上面的代码中，因为实例化的对象并没有传递参数，所以使用构造函数的缺省值，但是注意对比下面的print函数，print函数时对象在显式调用，但是不建议理解为构造函数也是对象显式调用，即d.Date();理解是不准确的，因为Date d;本身就是在创建对象，此时对象还没出现，如果直接理解为显式调用，那么和前面显式使用init()初始化对象没有区别

  • 成员变量给初始值的理解
#include <iostream>
using namespace std;

class Date
{
private:
    int _year = 0;
    int _month = 0;
    int _day = 0;
public:
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;
    d.print();
    return 0;
}
输出结果：
2024-3-20

在上面的代码中，成员变量都给了初始值0，但是这里并不是初始化，而是类似全缺省函数一样给的缺省值，因为前面的知识已经说明类中的成员变量只有在实例化之后才有实际空间。如果此处理解为初始化，因为类还没有被实例化没有实际的地址空间，这个变量将没有空间存放，而初始化则是将初始化的值存入变量对应的地址空间，则与初始化的含义相违背

析构函数

在使用C语言实现一些需要动态内存管理开辟的空间时，都需要写一个Destroy函数，再最后程序结束之前调用该函数来释放对应的空间，如果没有释放空间可能会因为程序长时间运行导致出现内存泄漏。但是在一些需要大量调用销毁函数的时候容易忘记调用Destroy函数最后导致内存泄漏。

在C++中，为了解决上面的问题，出现了析构函数，析构函数的作用是销毁对象中资源的清理工作

📌

注意，此处是对象中的资源清理工作，并不是直接销毁对象，因为对象是在当前函数栈帧空间销毁时才销毁

析构函数使用

析构函数：与构造函数功能相反，对象在销毁时会自动调用析构函数，完成对象中资源的清理工作

析构函数的特点：

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。
#include <iostream>
using namespace std;

//顺序表类
class SeqList
{
private:
    int* data;
    int _size;//有效数据个数
    int _capacity;//顺序表容量大小
public:
    //构造函数初始化
    SeqList(int capacity = 4)
    {
        int* tmp = (int*)malloc(sizeof(int) * capacity);    
        if (!tmp)
        {
            perror("malloc fail");
        }
        else
        {
            data = tmp;
        }
        _size = 0;
        _capacity = capacity;
    }

    //析构函数释放空间
    ~SeqList()
    {
        free(data);
        _size = 0;
        _capacity = 0;
    }
};

int main()
{
    SeqList s;//对象实例化时会调用构造函数

    //对象准备销毁时会调用析构函数
    return 0;
}
  • 对于编译器生成的默认析构函数，不处理内置类型，对自定义类型成员调用它的析构函数
#include <iostream>
using namespace std;

class Time
{
private:
    int _time;
public:
    Time()
    {
        _time = 0;
    }
    ~Time()
    {

    }
};

class Date
{
private:
    int _day;
    int _month;
    int _year;
    Time _t;
public:
    Date(int day = 20, int month = 3, int year = 2024)
    {
        _day = day;
        _month = month;
        _year = year;
    }

};

int main()
{
    Date d;

//因为d对象实例化时会创建对象_t，所以在对象d销毁之前，需要销毁d对象的资源和_t对象中的资源，而因为d对象没有显式的析构函数，此时编译器会默认生成析构函数，在销毁自定义类型对象_t时d对象的默认析构函数会调用_t对象的析构函数销毁其中的资源
    return 0;
}

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数；有资源申请时，一定要写，否则会造成内存泄漏

拷贝构造函数

拷贝构造函数使用

在对象实例化时，有时可能需要创建出两个一模一样的对象，如果多次实例化，那么每一次传参就会变得很麻烦，为了解决这个问题，C++的默认构造函数中提供一个构造函数为拷贝构造函数

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用

📌

使用const关键字进行修饰可以防止被拷贝对象被修改

拷贝构造函数的特点：

  • 拷贝构造函数是构造函数的一个重载形式
#include <iostream>
using namespace std;
class Date
{
private:
    int _day;
    int _month;
    int _year;
public:
    //初始化构造函数
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    //拷贝对象
    Date(const Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    //第一个Date对象
    Date d1(2024, 3, 21);
    Date d2(d1);//拷贝d1对象的值
    //也可以写成下面的形式
    Date d3 = d2;
    d1.print();
    d2.print();
    d3.print();
    return 0;
}
输出结果：
2024-3-21
2024-3-21
2024-3-21
  • 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用
#include <iostream>
using namespace std;
class Date
{
private:
    int _day;
    int _month;
    int _year;
public:
    //初始化构造函数
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    //拷贝对象
    Date(Date d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    //第一个Date对象
    Date d1(2024, 3, 21);
    Date d2(d1);//拷贝d1对象的值
    d1.print();
    d2.print();
    return 0;
}
报错信息：
类 "Date" 的复制构造函数不能带有 "Date" 类型的参数

在上面的代码中，拷贝构造函数的形参为Date类型的对象，Date类型的对象需要拷贝时将再次调用Date类型的拷贝构造，此时因为Date类型的拷贝构造形参依旧是Date类型的对象，故继续调用Date类型的拷贝构造，如此往复无穷进行，如下图所示

  1. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝，而深拷贝是指具体的拷贝方式需要自行实现，例如栈、链表等的拷贝

📌

注意，拷贝构造函数中的形参不可以使用指针类型，虽然实现的结果相同，但是此时编译器不认为是拷贝构造函数，而只是一个普通的成员函数

  1. 因为编译器会默认生成拷贝构造函数，而默认的拷贝构造与前面的析构和构造不同，拷贝构造会对内置类型按照字节方式直接拷贝，而对自定义类型来说，与前面的析构和构造相同，都会调用对应类型的拷贝构造函数，但是如果自定义类型没有实现拷贝构造，那么将直接按照字节序进行拷贝

在日期类中，可以直接使用默认的拷贝构造函数而不需要自己去实现，但是对于下面的情况则需要自己实现拷贝构造

#include <iostream>
using namespace std;

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (DataType*)malloc(capacity * sizeof(DataType));
        if (nullptr == _array)
        {
            perror("malloc申请空间失败");
            return;
        }

        _capacity = capacity;
    }
    void Push(const DataType& data)
    {
        // CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = nullptr;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    DataType* _array;
    size_t _size;
    size_t _capacity;
};
int main()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2(s1);
    return 0;
}

在上面的代码中，定义了一个栈类，而栈类中的成员变量有一个指针类型和两个内置类型，当Stack s2(s1)需要调用拷贝构造函数时，因为Stack类中并未实现拷贝构造，编译器会默认生成拷贝构造，此时将按照字节方式进行浅拷贝，此时对于内置类型的_size和_capacity的拷贝不会有任何问题，但是对于*_array来说，因为进行字节方式的浅拷贝，所以s2对象中的*_array和s1对象中的*_array都指向同一块空间，而因为_size和_capacity是各自独有的空间，s1对象中的改变不影响s2对象，现在插入了4个数据，s1中的_size = 4，s2对象中的_size依旧为0，如果s2需要插入数据，那么将从栈底开始插入，此时会覆盖掉原来s1中的数据。

另外，因为s1和s2对象都出现了资源申请，所以最后在程序即将销毁两个对象时会调用析构函数进行对象资源的释放，因为s2对象后实例化，所以在资源清理时先进行清理，此时会释放掉s2中*_array指向的空间，此时s1对象中的*_array指向的空间也同时被销毁，但是s2的*_array置为了空指针，而s1的*_array并不是空指针（依旧指向原来空间的位置），当释放完s2的资源时将释放s1的资源，此时释放s1的资源时将出现非法访问，因为s1对象的*_array指向的空间已经归还给操作系统了，从而会出现程序运行崩溃

综上所述，在对象有资源申请时，需要自行实现拷贝构造，否则直接使用编译器自动生成的拷贝构造函数即可

拷贝构造函数使用实例

#include <iostream>
using namespace std;

//生成指定天数后的某一天
class Date
{
private:
    int _year;
    int _month;
    int _day;
public:
    Date(int year = 2024, int month = 3, int day = 20)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    Date(Date& d)
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }

    int GetMonthDays(int year, int month)
    {
        int monthDay[13] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
        if (month == 2 && ((year % 4 == 0) && (year % 100 == 0) || (year % 400 == 0)))
        {
            return monthDay[month] + 1;
        }
        return monthDay[month];
    }

    //获取指定天数后的某一天
    //返回引用
    Date& GetAfterXDate_pe(int days)
    {
        _day += days;
        while (_day > GetMonthDays(_year, _month))
        {
            _day -= GetMonthDays(_year, _month);
            _month++;
            if (_month == 13)
            {
                _year++;
                _month = 1;
            }
        }
        return *this;//返回调用本函数的对象的引用
    }

    //返回自定义类型值
    Date GetAfterXDate_p(int days)
    {
        Date tmp(*this);//使用本类的拷贝构造复制对象中的内容
        tmp._day += days;
        while (tmp._day > GetMonthDays(tmp._year, tmp._month))
        {
            tmp._day -= GetMonthDays(tmp._year, tmp._month);
            tmp._month++;
            if (tmp._month == 13)
            {
                tmp._year++;
                tmp._month = 1;
            }
        }
        return tmp;//返回自定义类型的值
    }

    void print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
};

int main()
{
    Date d;//当天的日期
    d.print();
    d.GetAfterXDate_p(100).print();//获取一百天以后的当天，将返回值作为对象调用print函数，但是不改变初始的日期
    d.print();

    cout << endl;

    Date d1;
    d1.print();
    d1.GetAfterXDate_pe(100).print();//获取一百天后的当天，但会改变初始的日期
    d1.print();

    return 0;
}
输出结果：
2024-3-20
2024-6-28
2024-3-20

2024-3-20
2024-6-28
2024-6-28

在上面的代码中，对于返回对象的引用操作并不是非法引用，尽管this指针的作用域只在成员函数中，但是因为this指向的是实例化的对象，而实例化的对象只有在其所在空间被销毁才会销毁，所以可以理解为this指针并未被销毁，所以可以返回this的引用操作

拷贝构造函数典型调用场景：

  1. 使用已存在对象创建新对象
  2. 函数参数类型为类类型对象
  3. 函数返回值类型为类类型对象
class Date
{
public:
    Date(int year, int minute, int day)
    {
        cout << "Date(int,int,int):" << this << endl;
    }
    Date(const Date& d)
    {
        cout << "Date(const Date& d):" << this << endl;
    }
    ~Date()
    {
        cout << "~Date():" << this << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

Date Test(Date d)
{
    Date temp(d);
    return temp;
}

int main()
{
    Date d1(2022,1,13);
    Test(d1);
    return 0;
}
输出结果：
Date(int,int,int):000000B51D1DFC58
Date(const Date& d):000000B51D1DFD48
Date(const Date& d):000000B51D1DFD94
~Date():000000B51D1DFD48
~Date():000000B51D1DFD94
~Date():000000B51D1DFC58

在上面的代码中，首先创建了一个d1对象，此时会调用Date类中的构造函数，接下来Test函数传入实参为自定义类型对象d1，因为Test函数的形参是自定义类型，并且是值传递，所以此时形参d需要拷贝传入的实参对象d1的内容，故会调用Date的拷贝构造函数进行对象拷贝，在Test函数体中出现了temp对象的创建和拷贝，故此时依旧会调用拷贝构造函数拷贝d对象中的内容给temp对象，所以总共调用了两次拷贝构造函数，而因为temp对象出了Test函数将进行销毁，故会调用Date类中的析构函数，而因为形参d也需要被销毁，故也会调用Date类的析构函数，最后就是d1对象的销毁，该对象销毁也需要调用析构函数，故总共有三次析构函数的调用

如果将上面的代码中Test函数中的值形参改成引用形参时，在实参传入时将不会调用拷贝函数

#include <iostream>
using namespace std;

class Date
{
public:
    Date(int year, int minute, int day)
    {
        cout << "Date(int,int,int):" << this << endl;
    }
    Date(const Date& d)
    {
        cout << "Date(const Date& d):" << this << endl;
    }
    ~Date()
    {
        cout << "~Date():" << this << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

Date Test(Date& d)
{
    Date temp(d);
    return temp;
}

int main()
{
    Date d1(2022, 1, 13);
    Test(d1);
    return 0;
}
输出结果：
Date(int,int,int):0000002DC037F748
Date(const Date& d):0000002DC037F834
~Date():0000002DC037F834
~Date():0000002DC037F748

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用

怡晗★
关注
  • 31
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++中的四个默认成员函数与运算符重载详解
08-29
C++中的四个默认成员函数与运算符重载详解 C++中的四个默认成员函数与运算符重载详解是面向对象程序设计中非常重要的概念。四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载函数，这些函数是...
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
⚡【C++要笑着学】(7) 默认成员函数：构造函数 | 析构函数 | 拷贝构造函数
热门推荐
有道无术, 术尚可求。有术无道, 止于术。
03-15 3万+
朋友们好啊，今天终于更新了。我是柠檬叶子C，本章将继续讲解C++中的面向对象的知识点，本篇主要讲解默认成员函数中的构造函数、析构函数和拷贝构造函数。还是和以前一样，我们将由浅入深地去讲解，以 "初学者" 的角度去探索式地学习。会一步步地推进讲解，而不是直接把枯燥的知识点倒出来，应该会有不错的阅读体验。如果觉得不错，可以 "一键三连" 支持一下博主！
【C++】类的六大默认成员函数
学了就忘是正常现象
10-14 2871
C++类的六大默认成员函数。
c++成员函数默认参数
阅微草堂
06-16 1791
C++默认参数
c++类的默认成员函数
Sock的博客
05-14 4851
6个默认成员函数 这些默认的类成员函数, 在类创建的时候, 编译器会自动调用, 但是自动调用并不意味着他们能完成用户所期待的所有任务, 像构造函数, 析构函数, 拷贝构造函数, 赋值重载会在某些情况下需要用户根据程序的需要自定义实现. 构造函数 构造函数的主要工作是在对象创建的时候就完成初始化工作. 特性 函数名与类名相同。 无返回值。 对象实例化时编译器自动调用对应的构造函数。 构造函数可以...
【C++】类的6个默认成员函数详解
阿润菜菜的博客
02-06 4382
必须懂的C++类和对象中的默认成员函数
c++类的6个默认成员函数
qq_61939403的博客
04-22 3424
文章目录：类的6个默认成员函数构造函数 类的6个默认成员函数 ✈️类的6个默认成员函数包括：构造函数、析构函数、拷贝构造函数、赋值运算符重载函数、取地址操作符重载、const修饰的取地址操作符重载。 class Date {};//空类 如果一个类什么成员变量以及函数都没有，那么这就是一个空类。但是空类中并不是什么都没有，任何一个类在我们不写的情况下，都会自动生6个默认成员函数。 构造函数 在c++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创
C++ 静态成员函数
LC的专栏
05-21 1万+
成员函数也可以定义为静态的，在类中声明函数的前面加static就成了静态成员函数，例如： //定义静态成员函数; static long long get_number(){ return number; } 和静态成员变量一样，静态成员函数是类的一部分，而不是对象的一部分。如果要在类外调用公用的静态成员函数，要用类名和域运算符“：：”，例如： student::get_number(); 静态成员变量和静态成员函数，是属于类。那么，当用类...
C++_类中的6个默认成员函数
weixin_43853178的博客
10-13 2021
C++类中有6个默认函数，分别是：构造函数、析构函数、拷贝构造函数、赋值运算符重载、取地址及const取地址运算符重载。这六个函数是很特殊的函数，如果我们不自己实现，编译器就会自己实现。这篇博客中将一一介绍这六个默认函数。
【C++】类的6个默认成员函数（超详细）
qq_63231615的博客
08-10 2668
1. 类的6个默认成员函数 2. 构造函数 3. 析构函数 4. 拷贝构造函数 5. 赋值运算符重载 6. const成员函数 7. 取地址及const取地址操作符重载
C++默认构造函数
qq_39998031的博客
02-22 1915
默认构造函数 默认的构造函数是指为所有参数都提供了默认值的构造函数，通常是指无参的构造函数。比如下面的类Test，它的默认构造函数就是Test()。 class Test { public: Test(){} // default constructor } ; 如果你没有为你的类提供任何构造函数，那么编译器将自动为你生成一个默认的无参构造函数。一旦你为你的类定义了构造函数，哪怕只是一个...
对C++默认构造函数的一点重要说明
12-31
大多数C++书籍都说在我们没有自己定义构造函数的时候，编译器会自动生成默认构造函数。其实这句话我一直也是 深信不疑。但是最近看了一些资料让我有了一点新的认识。 其实我觉得大多数C++书籍之所以这样描述其实是玩...
C++静态成员函数访问非静态成员的几种方法
12-22
大家都知道C++中类的成员函数默认都提供了this指针，在非静态成员函数中当你调用函数的时候，编译器都会“自动”帮你把这个this指针加到函数形参里去。当然在C++灵活性下面，类还具备了静态成员和静态函数，即 ...
C++空类默认函数详细解析
09-04
当我们声明一个空类时，C++编译器会自动为这个类提供一组默认的成员函数，以确保类实例的正确操作。这些默认函数包括： 1. **默认构造函数**： 默认构造函数是一个无参数的构造函数，它的作用是初始化对象。对于空...
C++ day3
2301_81402136的博客
06-17 262
【代码】C++ day3。
C的I/O操作
weidl001的博客
06-17 734
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C/C++ 提取DNS请求/响应数据包之中的 Quesion 内容
liulilittle的博客
06-20 203
它主要是提取DNS数据包之中查询问题的信息，如：问题类型、问题类别、问题内容（域/IP），我们如果想要对于某个DNS数据包需要进行遥测的时，或者进行NS缓存生命周期管理，那么就需要类似这样的函数实现了。
LeetCode 算法：排序链表 c++
最新发布
小金牛来了
06-22 530
LeetCode 算法：排序链表 c++
c++类的默认成员函数是什么
05-13
这些默认成员函数的行为是： 1. 默认构造函数：如果你没有定义任何构造函数，编译器会生成一个默认构造函数。这个默认构造函数不接受任何参数，它会初始化对象的所有成员变量为默认值（例如：数值类型为0，指针类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值