C++——类的默认成员函数

已于 2023-03-02 10:36:58 修改
阅读量593 收藏 4
点赞数 11
分类专栏： C++ 文章标签： c++ 开发语言 Powered by 金山文档
于 2023-03-02 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcxmjw/article/details/129199699
版权

一，类的六个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

二，构造函数

2.1 概念

class Data
{
public:
    void Init(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data A;
    A.Init(2023, 2, 24);
    A.print();
    return 0;
}
观察以上程序，我们发现每次创造类我们都需要对其进行初始化设置日期，但每次这样是否有点麻烦，有没有什么更简单的方法呢？答案自然是有的，那就是 构造函数。

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

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务 并不是开空间创建对象，而是初始化对象。

其特征如下：

  1. 函数名与类名相同。

  1. 无返回值。

  1. 对象实例化时编译器自动调用对应的构造函数。

  1. 构造函数可以重载

class Data
{
public:
    //无参构造函数
    Data()
    {
        cout << "Data()" << endl;
    }
    //有参构造函数
    Data(int year, int month, int day)
    {
        cout << "Data(int year, int month, int day)" << endl;
        _year = year;
        _month = month;
        _day = day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    //1.无参构造函数
    Data A;//注意：不能用Data A();
    //不然会和函数声明出现冲突，导致编译器无法辨别，导致出错
    //“Data A(void)”: 未调用原型函数(是否是有意用变量定义的 ? )
    
    //2.有参构造函数
    Data B(2023, 2, 24);

}

5.  如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Data
{
public:

    如果已经有构造函数，编译器将不在生成
    //Data(int year, int month, int day)
    //{
    //    cout << "Data(int year, int month, int day)" << endl;
    //    _year = year;
    //    _month = month;
    //    _day = day;
    //}

    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data A;
    A.print();
    return 0;
}
如上程序，当我们将自己写的构造函数屏蔽后，代码可以通过
但是当放开屏蔽的代码后，程序报错，由此可见默认的构造函数确实存在，并且一旦用户定义编译器就不在生成默认构造函数

但是细心的老铁想必已经发现，默认的构造函数并没有成功的将程序初始化，而是变成一对乱码，那么这是为什么呢？

这是因为C++数据类型分为两种，一个是内置类型(如int,long,double等)，一个自定义类型如(class，struct定义的)，而 默认构造函数只会对自定义的类型成员调用它的默认构造函数。 
class Data
{
public:
    Data(int year=2023, int month=2, int day=24)
    {
        cout << "Data(int year, int month, int day)" << endl;
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
class fun1
{
public:
    void print()
    {
        cout <<"基本类型: "<< _val << endl;
        cout << "自定义类型: ";
        _A.print();
        cout << endl;
    }
private:
    int _val;
    Data _A;
};
int main()
{
    fun1 S;
    S.print();
    return 0;
}
ps:C++11中针对内置类型成员不初始化的缺陷，又打了补丁，即： 内置类型成员变量在类中声明时可以给默认值。 
class Data
{
public:
    Data(int year=2023, int month=2, int day=24)
    {
        cout << "Data(int year, int month, int day)" << endl;
        _year = year;
        _month = month;
        _day = day;
    }

    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
class fun1
{
public:
    void print()
    {
        cout <<"基本类型: "<< _val << endl;
        cout << "自定义类型: ";
        _A.print();
        cout << endl;
    }
private:
    int _val=5;
    Data _A;
};
int main()
{
    fun1 S;
    S.print();
    return 0;
}

6.无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

class Data
{
public:
    //无参构造函数
    Data()
    {
        cout << "Data()" << endl;
    }
    //有参构造函数
    Data(int year=2023, int month=2, int day=24)
    {
        cout << "Data(int year, int month, int day)" << endl;
        _year = year;
        _month = month;
        _day = day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
//下面程序可以通过编译吗
int main()
{

    Data A;
    return 0;
}

三，析构函数

3.1 概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而 对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2 特性

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int STDataType;
class Stack
{
public:
    // 构造函数
    Stack(STDataType x=4)
    {
        STDataType* ptr = (STDataType*)malloc(x * sizeof(STDataType));
        if (ptr == NULL)//检查开辟是否成功
        {
            perror("malloc");
            exit(-1);
        }
        _a = ptr;
        _top = 0;
        _capacity = x;
    }
    // 入栈 
    void Push(STDataType data)
    {
        if (_top == _capacity)
        {
            STDataType* ptr = (STDataType*)realloc(_a, _capacity * 2 * sizeof(STDataType));
            if (ptr == NULL)//检查开辟是否成功
            {
                perror("malloc");
                exit(-1);
            }
            _a = ptr;
            _capacity = _capacity * 2;
        }
        _a[_top++] = data;
    }
    // 获取栈顶元素 
    STDataType Top()
    {
        if (_top > 0)
            return _a[_top - 1];
        else
        {
            perror("Top");
            exit(-1);
        }
    }
    //销毁空间
    //1.调用函数销毁(但是需要自己手动调用，一旦忘记，就会导致内存泄露)
    /*void Destory()
    {
        if (_a)
        {
            free(_a);
            _a = nullptr;
            _top = 0;
            _capacity = 0;
        }
    }*/
    //2.析构函数(自动调用，内存泄露风险小)
    ~Stack()
    {
        if (_a)
        {
            free(_a);
            _a = nullptr;
            _top = 0;
            _capacity = 0;
        }
    }


private:
    STDataType* _a;
    int _top;        // 栈顶
    int _capacity;  // 容量 
};
int main()
{
    Stack A;
    A.Push(2);
    A.Push(3);

    return 0;
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Data
{
public:
    ~Data()
    {
        cout << "~Data" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
class fun1
{
private:
    int _val=5;
    Data _A;
};
int main()
{
    fun1 S;
    return 0;
}
在main函数中并未直接创建Data类的对象，为什么最后会调用Data类的析构函数？
在main中，创建了fun1的对象S，而S中包含两个成员变量，一个是_val为内置类型成员，销毁时无需资源清理，最后系统会直接回收，而_A则是自定义类型成员，所以在销毁时 ，为了对_A内部的变量成员进行正确的销毁，随意需要调用_A的析构函数，而main无法直接调用， 所以就通过fun1进行调用，保证_A中的成员变量可以正确销毁，进而保证了fun1中的所有变量可以正确销毁。
因此，我们得知: 创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

四，拷贝构造函数

4.1 概念

class Data
{
public:
    //构造函数
    Data(int year, int month, int day)
    {
        cout << "Data(int year, int month, int day)" << endl;
        _year = year;
        _month = month;
        _day = day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data d1(2023,2,28);
    return 0;
}
如上所示我们创建出一个日期类d1，此时我们想以d1为原型在创建出一个d2，在C++中有什么办法可以实现吗？
答案自然是有，那就是 拷贝构造函数
拷贝构造函数：只有 单个形参，该形参是 对本类类型对象的引用( 一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器 自动调用。

4.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

 1. 拷贝构造函数是构造函数的一个重载形式。

 2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

class Data
{
public:
    //构造函数
    Data(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //拷贝构造函数
    //Data(const Data d)：不用引用的话会造成无限递归
    Data(const Data& d)//用const限定是因为，d是用来拷贝的，防止出现改变d的情况
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data d1(2023,2,28);
    Data d2(d1);
    d1.print();
    d2.print();

    return 0;
}

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Data
{
public:
    //构造函数
    Data(int year=2023, int month=2, int day=28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //拷贝构造函数
    //Data(const Data d)：不用引用的话会造成无限递归
    //Data(const Data& d)//用const限定是因为，d是用来拷贝的，防止出现改变d的情况
    //{
    //    _year = d._year;
    //    _month = d._month;
    //    _day = d._day;
    //}
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
class fun1
{
public:
    void print()
    {
        cout << a << endl;
        A.print();
    }
private:
    //内置类型
    int a = 10;
    //自定义类型
    Data A;
};
int main()
{
    fun1 d1;
    //fun1 d2(d1);
    fun1 d2 = d1;
    d1.print();
    d2.print();
    return 0;
}

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

typedef int STDataType;
class Stack
{
public:
    //构造函数
    Stack(STDataType x=4)
    {
        STDataType* ptr = (STDataType*)malloc(x * sizeof(STDataType));
        if (ptr == NULL)//检查开辟是否成功
        {
            perror("malloc");
            exit(-1);
        }
        _a = ptr;
        _top = 0;
        _capacity = x;
    }
    //入栈 
    void Push(STDataType data)
    {
        if (_top == _capacity)
        {
            STDataType* ptr = (STDataType*)realloc(_a, _capacity * 2 * sizeof(STDataType));
            if (ptr == NULL)//检查开辟是否成功
            {
                perror("malloc");
                exit(-1);
            }
            _a = ptr;
            _capacity = _capacity * 2;
        }
        _a[_top++] = data;
    }
    //获取栈顶元素 
    STDataType Top()
    {
        if (_top > 0)
            return _a[_top - 1];
        else
        {
            perror("Top");
            exit(-1);
        }
    }
    
    //析构函数(自动调用，内存泄露风险小)
    ~Stack()
    {
        if (_a)
        {
            free(_a);
            _a = nullptr;
            _top = 0;
            _capacity = 0;
        }
    }


private:
    STDataType* _a;
    int _top;        // 栈顶
    int _capacity;  // 容量 
};
int main()
{
    Stack fun1;
    fun1.Push(1);
    fun1.Push(2);
    fun1.Push(3);
//默认拷贝构造函数，浅拷贝
    Stack fun2(fun1);

    return 0;
}
上面的程序为什么会报错呢？
这就要牵扯到深浅拷贝的问题了.
因此，类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

上面例子正确的拷贝构造函数应该是：

//拷贝构造函数
    Stack(const Stack& d)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * d._capacity);
        if (_a == nullptr)//检查开辟是否成功
        {
            perror("malloc");
            exit(-1);
        }
        memcpy(_a, d._a, sizeof(d._top));
        _top = d._top;
        _capacity = d._capacity;
    }

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

  • 使用已存在对象创建新对象

  • 函数参数类型为类类型对象

  • 函数返回值类型为类类型对象

class Data
{
public:
    //构造函数
    Data(int year=2023, int month=2, int day=28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //拷贝构造函数
    //Data(const Data d)：不用引用的话会造成无限递归
    Data(const Data& d)//用const限定是因为，d是用来拷贝的，防止出现改变d的情况
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
Data test(Data d)
{
    Data tmp(d);
    return tmp;
}
int main()
{
    //使用已存在对象创建新对象
    Data d1(2023, 2, 28);
    Data d2(d1);
    //函数参数类型为类类型对象
    //函数返回值类型为类类型对象
    test(d1);
    return 0;
}
ps：
为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

五，赋值运算符重载

5.1 运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator后面接需要重载的运算符符号。

函数原型： 返回值类型 operator操作符(参数列表)

注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@

  • 重载操作符必须有一个类类型参数

  • 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不 能改变其含义

  • 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

  • .* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。 

class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
//private:
    int _year;
    int _month;
    int _day;
};
//当采用全局时我们发现，类中的变量时私人的，域外函数无法访问
//如果我们想让函数正确运行可以将类中变量的权限调整成公共的
//也可以直接将operator写到类里面，以后我们采用的就是这种方法
bool operator==(const Data& d1, const Data& d2)
{
    return d1._year == d2._year
        && d1._month == d2._month
        && d1._day == d2._day;
}
int main()
{
    Data d1(2023, 2, 28);
    Data d2(2023, 2, 28);
    cout << (d1 == d2) << endl;
    //d1==d2和operator==(d1,d2)的调用命令是一样的

    return 0;
}
我们通常将operator写入到类中去 
class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    bool operator==(const Data& d)
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};

5.2 赋值运算符重载

(1) 赋值运算符重载格式

  • 参数类型：const Data&，传递引用可以提高传参效率

  • 返回值类型：Data&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

  • 检测是否自己给自己赋值

  • 返回*this ：要复合连续赋值的含义

class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //拷贝构造函数
    Data(const Data& d)//用const限定是因为，d是用来拷贝的，防止出现改变d的情况
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    //=
    Data& operator=(const Data& d)
    {
        //防止自己给自己赋值
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }
    //==
    bool operator==(const Data& d)
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data d1(2023, 2, 28);
    Data d2(2024, 2, 28);
    Data d3(2025, 2, 28);
    d3 = d2 = d1;
    d2.print();
    d3.print();
    return 0;
}

(2) 赋值运算符只能重载成类的成员函数不能重载成全局函数

class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    int _year;
    int _month;
    int _day;
};
Data& operator=(Data& d1, const Data& d2)
{
    //防止自己给自己赋值
    if (&d1 != &d2)
    {
        d1._year = d2._year;
        d1._month = d2._month;
        d1._day = d2._day;
    }
    return d1;
}
int main()
{
    Data d1(2023, 2, 28);
    Data d2(2024, 2, 28);
    d1 = d2;
    return 0;
}
原因：赋值运算符如果不在类中显示出现，编译器会生成一个默认的赋值运算符，此时默认的赋值运算符会和全局的赋值运算符冲突，所以赋值运算符只能是类的成员函数

(3) 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。 
class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //拷贝构造函数
    Data(const Data& d)//用const限定是因为，d是用来拷贝的，防止出现改变d的情况
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    //=
    Data& operator=(const Data& d)
    {
        //防止自己给自己赋值
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }
    //==
    bool operator==(const Data& d)
    {
        return _year == d._year
            && _month == d._month
            && _day == d._day;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
class fun
{
private:
    void print()
    {
        cout << a << endl;
        A.print();
    }
public:
    //基本类型
    int a = 10;
    //自定义类型
    Data A;
};
int main()
{
    fun d1;
    fun d2;
    d1 = d2;
    return 0;
}
同样的由于编译器生成的默认赋值运算符重载属于是根据字节拷贝的浅拷贝，所以和拷贝构造函数一样，需要注意：
如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

5.3 前置++和后置++重载

class Data
{
public:
    //构造函数
    Data(int year = 2023, int month = 2, int day = 28)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    //前置++,返回的是已经++后的值
    //引用返回是因为，this指向的对象不会销毁，引用返回效率高
    Data& operator++()
    {
        _day += 1;
        return *this;
    }
    //后置++，返回的是++前的值，所以需要先吧++前的值保存起来
    //C++规定，后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
    //自动传递
    //由于tmp在返回后就销毁了，所以不能用引用返回
    Data operator++(int)
    {
        Data tmp(*this);
        _day += 1;
        return tmp;
    }
    void print()
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Data d1(2023, 2, 5);
    Data d2=d1++;
    Data d3=++d1;
    d1.print();
    d2.print();
    d3.print();

    return 0;
}

六，const成员

将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际 修饰该成员函数隐含的this指针，表明 在该成员函数中不能对类的任何成员进行修改。
应用场景如下 
class Date
{
public:
    Date(int year=2023, int month=3, int day=1)
    {
        _year = year;
        _month = month;
        _day = day;
    }

    void print() const
    {
        cout << _year << "年" << _month << "月" << _day << "日" << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
void fun1(const Date A)
{
    A.print();
}
int main()
{
    Date A;
    fun1(A);
    return 0;
}
如上所示，在fun1中A被const修饰，只可读，22行代码调用A.print()函数，此时如果函数没有被const修饰，那么*this的权限就变成了可读可写，但此时A的权限只可读，这属于是权限放大，会出错。
ps：在后面写类和对象时， 建议类中的成员函数，如果对*this不修改，那么都加上const修饰，避免出错

七，取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容！

总结

本篇文章主要是深入了解类的默认成员函数的各个特性，方便在日后更加灵活的使用类。
爱吃鱼的修猫
关注
  • 11
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
编译器警告：未调用原型函数(是否是有意用变量定义的?)
weixin_34000916的博客
06-19 1381
开发环境：VS2017 出错的代码如下： #include "pch.h" #include "MyArr.hpp" #include <iostream> #include <string> using namespace std; int main() { MyArray<int, 5> arr(); std::cout <<...
c++中类的默认成员函数
weixin_43405004的博客
04-27 121
在C++中，类的默认构造函数有六个，他们分别是构造函数，拷贝构造函数，析构函数，赋值操作符重载，取地址操作符重载和const修饰的取地址操作符重载。 类的默认成员函数 1、负责初始化和清理工作的，构造函数负责初始化，析构函数负责清理 2、拷贝复制，拷贝构造函数是使用同类对象初始化创建对象，赋值运算符重载主要是把一个对象赋值给另一个对象。 3、取地址运算符重载，包含取地址运算符重载和const取地址运算符重载。 1 构造函数 构造函数概念 构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器
【C++】类和对象
holle_world_ldx的博客
07-21 373
类和对象
【C++】类的6个默认成员函数（超详细）
qq_63231615的博客
08-10 2725
1. 类的6个默认成员函数 2. 构造函数 3. 析构函数 4. 拷贝构造函数 5. 赋值运算符重载 6. const成员函数 7. 取地址及const取地址操作符重载
C++入门3——类与对象2（类的6个默认成员函数）
最新发布
weixin_73629886的博客
05-27 1390
类的6个默认成员函数（构造、析构、拷贝构造，赋值重载、取地址重载、const取地址重载）编译器都会自己生成，如果编译器生成的默认成员函数能够满足我们的需求，我们就无需再自己实现； 相反，如果编译器生成的默认成员函数不能满足我们的需求，我们就必须要自己实现了。 本篇博客正是介绍类的这6个默认成员函数都有哪些特性，讲述什么情况下只需使用默认成员函数，什么情况下需要自己实现以及要怎样实现的问题！
c++ 类默认构造函数
行走的漂流瓶的博客
01-12 1907
在c++工程中，当用户新设计一个类的时候，编译器会给类生成默认的一些函数和运算操作符，以满足大部分使用过程中的操作，今天总结一下，以免忘记。下面用测试用例来说明每个函数的被调用情况。下面用代码进行展示如果重写的格式。
C++_类中的6个默认成员函数
weixin_43853178的博客
10-13 2037
C++类中有6个默认函数，分别是：构造函数、析构函数、拷贝构造函数、赋值运算符重载、取地址及const取地址运算符重载。这六个函数是很特殊的函数，如果我们不自己实现，编译器就会自己实现。这篇博客中将一一介绍这六个默认函数。
C++继承 ——派生类的默认成员函数
XHumble的博客
06-30 169
在学习类的时候，我们了解到类中有6个默认成员函数，默认函数是我们在没有显式给出这个函数时，编译器会自动生成一个，那么在派生类中是否会自动生成时如何生成？ 1.派生类的构造函数必须调用基类的构造函数用来初始化基类的那一部分，如果基类没有默认构造函数，则必须在派生构造函数的初始化列表阶段显式调用。 2.派生类的拷贝构造函数必须调用基类的拷贝构造函数完成基类的拷贝初始化。 3. 派生类的operator=必须要调用积累的operator=完成基类的复制。 4.派生类的析构函数会在调用完成后...
多态——纯虚函数与抽象类.zip
12-19
virtual ~Base() {} // 如果没有其他成员函数，析构函数默认为虚的 virtual void func() = 0; // 纯虚函数声明 }; ``` 这里的`Base`类就是一个抽象类，不能实例化，但可以作为其他类的基类。子类继承抽象类时，...
cpp代码-c++学习笔记——类与对象
07-16
类可以看作是一个蓝图或模板，定义了具有特定属性（数据成员）和行为（成员函数）的对象。创建类的语法如下： ```cpp class ClassName { // 数据成员 data_type member1; data_type member2; // 成员函数 ...
C++课件——构造函数 友元
05-07
在C++中，每个类都可以有一个默认构造函数（无参数的），但根据需求，我们也可以自定义构造函数来满足特定的初始化需求。例如： ```cpp class MyClass { public: MyClass(int value) { this->value = value; } ...
c++程序圆类设计.zip
09-15
在这个`Circle`类中，`radius`是私有成员变量，只能通过公共成员函数（getters和setters）访问。`Circle`类有两个构造函数：一个是默认构造函数，另一个接受半径作为参数。`getArea()`和`getCircumference()`函数...
【C++】类的6个默认成员函数详解
阿润菜菜的博客
02-06 4399
必须懂的C++类和对象中的默认成员函数
【C++】类的六大默认成员函数
学了就忘是正常现象
10-14 2909
C++类的六大默认成员函数。
c++ 类的默认八种函数
JMW1407的博客
10-05 8969
类的默认八种函数类的默认八种函数参考 类的默认八种函数 参考 1、https://www.cnblogs.com/lsgxeva/p/7668200.html
C++ 类的成员函数
墨上烟雨
04-07 4070
C++ 类的成员函数一、普通成员函数二、构造函数三、析构函数四、拷贝构造函数 一、普通成员函数 1、普通成员函数的声明 普通成员函数必须在类中声明，声明方式与声明普通成员函数的方式一样 class People { public: void getWeight(); void getHeight(); //成员函数 }; 2、普通成员函数的定义 成员函数的定义有两种方式： ...
C++中类的八个默认函数
zhenghe12365的博客
12-12 536
C++中类的八个默认函数
C++中的六个默认成员函数
ASDASDSD523123的博客
09-20 104
而当我们去实现一个栈时，我们使用默认拷贝构造函数时程序会崩溃，究其原因，是我们实现栈的时候会malloc一块空间，并且返回这块空间的地址，但我们拷贝时会拷贝两个一模一样的地址的类，这就导致两个指针都指向这块区域，从而造成了两次析构。所以这里就引出了拷贝构造的第二个用法，深拷贝，具体该如何实现呢，我们需要为拷贝的函数单独开辟一块空间，使两块空间只有数据一样，但是是完全独立的两个整体，
C++——类的六大默认成员构造函数
勇气是明知不可为而为之
07-15 2523
在面向对象编程中，构造函数是一种特殊的方法，用于在创建对象时初始化对象的属性或数据成员。它通常与类一起使用，并且在实例化对象时自动调用。public:MyClass()cout
c++默认构造函数——深入理解
09-02
C++ 默认构造函数是在没有显式定义构造函数的情况下自动生成的特殊成员函数。它通常用于在创建对象时进行初始化操作。默认构造函数无参数，不接受任何实参。当我们通过调用类的构造函数来创建对象时，如果没有提供...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值