C++【类和对象】【二】

桜キャンドル淵

已于 2022-07-25 14:53:12 修改

阅读量197

点赞数 1

分类专栏：数据结构(C/C++) 文章标签： c++ 开发语言

于 2022-07-17 12:35:36 首次发布

本文链接：https://blog.csdn.net/weixin_62684026/article/details/125830065

版权

数据结构(C/C++) 专栏收录该内容

55 篇文章 19 订阅

订阅专栏

1.类的6个默认成员函数

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

初始化和清理	构造函数主要完成初始化工作
初始化和清理	析构函数主要完成清理工作
拷贝赋值	拷贝构造是使用同类对象初始化创建对象
拷贝赋值	赋值重载主要是把一个对象赋给另一个对象
取消地址重载	主要是普通对象和const对象取地址，这两个很少会自己实现

2. 构造函数

对象实例化一定要调用构造函数。C++中构造函数和Java中的构造器相类似。便于方便理解的话，我们也可以将构造函数称为初始化函数，用于我们函数的基本数据的默认值的赋值。

1.大部分的类都需要自己写构造函数

2.只有像Myqueque这样的类不需要写构造函数

3.每个类都最好提供默认的构造函数。

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

在下面的代码中我们定义了Date这个构造函数。

class Date{
public:
void Init(int year, int month, int day)
{
    _year = year;
    _month = month;
    _day = day;
}
Date()
{
    _year = 2024;
    _month = 2;
    _day = 29;
}
void Print()
{
    cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};

#include "Person.h"
int main()
{
    Date d1;
    d1.Init(2022, 7, 12);
    d1.Print();
    Date d2;
    d2.Init(2022, 7, 14);
    d2.Print();
    Date d3;
    d3.Print();
    return 0;
}

特性

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

其特征如下：
1. 函数名与类名相同。
2. 无返回值。
3. 对象实例化时编译器自动调用对应的构造函数。
4. 构造函数可以重载。

我们也可以构造带参的构造函数，与上面无参的构造函数形成函数重载。

Date(int year,int month,int day)
{
    this->_year= year;
    this->_month=month;
    this->_day=day;
}

#include "Person.h"
int main()
{
    Date d3(2028,7,20);
    d3.Print();
    return 0;
}

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

C++类型分类：

内置类型（语言自身携带的，也称为基本类型）：int/double/char/指针等等

自动类型：struct/class

int main()
{

    Date d3;
    return 0;
}

默认生成的构造函数，a:内置类型成员不做处理 b:自定义类型成员会去调用他的默认构造函数。这是是C++早期的一个缺陷，默认生成构造函数，本应该将内置类型也一并处理。
C++11打了一个补丁，允许使用缺省值。

class Date{
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=1;//这里不是初始化，而是给缺省值
int _month=1;
int _day=1;
};

int main()
{
    Date d3;
    d3.Print();
    return 0;
}

默认构造函数-》特点：不传参数，就可以调用。

1.我们不写，编译器自动生成

2.我们自己写的，全缺省的构造函数。

3.我们自己写的，无参的构造函数。

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

class Date
{
public:
    Date()
    {
        _year = 1900;
        _month = 1;
        _day = 1;
    }
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
    Date d1;
}

总结：

1.一般的类都不会让编译器默认生成构造函数，都会自己写。显示一个全缺省，非常好用。

2.特殊情况下才会默认生成。

3.析构函数

概念

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

1.一些类需要显式写析构函数。比如Stack、queue

2.一些类不需要显式写析构函数

a.比如Date这样的类，没有资源需要清理

b.比如MyQueue也可以不写，默认生成的就可以（MyQueue是指用两个栈实现队列的，因为栈本身定义了析构函数，所以MyQueue就不用写析构函数了）。

特征

析构函数是特殊的成员函数，其特征如下：
1. 析构函数名是在类名前加上字符 ~。
2. 无参数无返回值类型。
3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。

注意：析构函数不能重载
4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

5.栈帧和在栈里面的变量、对象都符合后进先出，也就是先定义的后析构，后定义的先析构

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 3)
    {
        _array = (DataType*)malloc(sizeof(DataType) * capacity);
        if (NULL == _array)
        {perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    void Push(DataType data)
    {
// CheckCapacity();
        _array[_size] = data;
        _size++;
    }
// 其他方法...
    ~Stack()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
void TestStack()
{
    Stack s;
    s.Push(1);
    s.Push(2);
}

int main()
{
    Stack s1;
}

在上面的代码中，我们的~Stack就是一个析构函数，就是在我们的栈被销毁的时候会调用析构函数，即将我们栈空间释放，指针置空之类的操作。

默认生成的析构函数的特点：

跟构造函数类似，内置类型不处理。

a.内置类型不处理。

b.自定义类型按照该类所对应的析构函数。

class Time
{
public:
    ~Time()
    {
        cout << "~Time()" << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
// 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
// 自定义类型
    Time _t;
};
int main()
{
    Date d;
    return 0;
}

 程序运行结束后输出：~Time()
 在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？
 因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是
 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在
 d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数
 中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函
 数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time
 类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁
 main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

谁先创建销毁问题

全局对象优先创建，然后再按照从前向后的顺序创建。如果多次调用，静态的对象不再重新构造，非静态的对象按照从上到下的顺序重新构造。

在销毁的时候，按照先进后出的原则，先析构堆空间上的对象，再析构静态区的对象，最后析构全局对象。

class A
{
public:
    A(int i){
        printf("A()%d\n",i);
        this->num=i;
    }
    ~A(){
        printf("~A()%d\n",this->num);
    }

private:
    int num=0;
};
A aa3(3);
int main()
{
    static A aa0(0);
    A aa1(1);
    A aa2(2);
    static A aa4(4);
    return 0;

}

4.拷贝构造函数

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

特征

拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。
2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

下面代码中的const Date& d建议就是加上const，防止赋值和被赋值的参数写反等一系列情况。（权限缩小是允许的，很多情况下都是不需要改变的。如果真的需要改变再把const给去掉）

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
// Date(const Date& d) // 正确写法
    Date(const Date d) // 错误写法：编译报错，会引发无穷递归
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;
    Date d2(d1);
    return 0;
}

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

class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }
    Time(const Time& t)
    {
        _hour = t._hour;
        _minute = t._minute;
        _second = t._second;
        cout << "Time::Time(const Time&)" << endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 1970;
    int _month = 1;
    int _day = 1;
// 自定义类型
    Time _t;
};
int main()
{
    Date d1;
// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
    Date d2(d1);
    return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

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

typedef int DataType;
class Stack
{
public:
    Stack(size_t capacity = 10)
    {
        _array = (DataType*)malloc(capacity * sizeof(DataType));
        if (nullptr == _array)
        {
            perror("malloc申请空间失败");
            return;
        }
        _size = 0;
        _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;
}

1.s1对象调用构造函数创建，在构造函数中，默认申请了10个元素的空间，然后里面存了4个元素1 2 3 4

2.s2对象使用s1拷贝构造，而Stack类没有显式定义拷贝构造函数，则编译器会给Stack类生成一份默认的拷贝构造函数，默认拷贝构造函数是按照值拷贝的，即将s1中内容原封不动的拷贝到s2中。因此s1和s2指向了同一块内存空间。

3.当程序退出时，s2和s1要销毁。s2先销毁，s2销毁时调用析构函数，已经将0x11223344的空间释放了，但是s1并不知道，到s1销毁时，会将0x11223344的空间再释放一次，一块内存空间多次释放，肯定会造成程序崩溃。

构造函数需要自己实现深拷贝。

5.赋值运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)

注意：
1.不能通过连接其他符号来创建新的操作符：比如operator@
2.重载操作符必须有一个类类型参数
3.用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
4.作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
5..* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

内置类型可以直接使用运算符运算，编辑器知道要如何运算

自定义类型无法直接使用运算法，编译器也不知道要如何运算。想支持，自己实现运算符重载即可。

// 全局的operator==
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
//private:
    int _year;
    int _month;
    int _day;
};
// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
// 这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。
bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
           && d1._month == d2._month
           && d1._day == d2._day;
}
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 27);
    cout<<(d1 == d2)<<endl;
}

int main(){
    Test();
    return 0;
}

上面的代码中，我们是将类内部的私有属性给公开了，但是如果我们加上私有属性，编译器会提示传入的参数过多了。这是因为我们当前还有一个this指针来代替我们的其中一个参数。

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
// bool operator==(Date* this, const Date& d2)
//第一个参数是左操作数，第二个参数为右操作数
// 这里需要注意的是，左操作数是this，指向调用函数的对象(
    bool operator==(const Date& d2)
    {
        return _year == d2._year
        && _month == d2._month
           && _day == d2._day;
    }
private:
    int _year;
    int _month;
    int _day;
};
void Test ()
{
    Date d1(2018, 9, 26);
    Date d2(2018, 9, 26);
    cout<<(d1 == d2)<<endl;
}

int main()
{
    Test();
}

6.日期类的实现

赋值运算符重载的练习，参考博文

C++【面向对象】【如何手动实现日期类】_桜キャンドル淵的博客-CSDN博客

7.const成员

将const修饰的类成员函数称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

class Date
{

public :

        //用于构造我们的对象。
        Date(int year = 1900, int month = 1, int day = 1)
        {
            _year = year;
            _month = month;
            _day = day;
        }

        //用于打印我们的对象的日期，方便我们下面代码的验证
        void Print()
        {
            cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
        }

    void Display ()
    {
        cout<<"Display ()" <<endl;
        cout<<"year:" <<_year<< endl;
        cout<<"month:" <<_month<< endl;
        cout<<"day:" <<_day<< endl<<endl ;
    }
    void Display () const
    {
        cout<<"Display () const" <<endl;
        cout<<"year:" <<_year<< endl;
        cout<<"month:" <<_month<< endl;
        cout<<"day:" <<_day<< endl<<endl;
    }
private :
    int _year ; // 年
    int _month ; // 月
    int _day ; // 日
};
void Test ()
{
    Date d1 ;
    d1.Print();
    const Date d2;
    d2.Print();
}

可见在我们将d2声明为const的时候，我们的d2是一个具有const属性的指针，但是当构造我们的函数的时候，我们的this指针的属性并不是const所以会报错，相当于将权限给放大了。

如果我们想要修饰我们的this指针为const属性的话，我们可以这样写

    void Print() const
    {
        //_year = 1;
        cout << _year << "/" << _month << "/" << _day << endl;
    }

8.取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义，编译器默认会生成。

如果普通对象和const修饰的对象需要区别处理就进行函数的重定义。

const修饰的会调用const的方法。

普通对象会调用普通对象的方法。

如果不需要就不用写两个重载了。

class Date
    {
    public :
        Date* operator&()
        {
            return this ;
        }
        const Date* operator&()const
        {
            return this ;
        }
    private :
        int _year ; // 年
        int _month ; // 月
        int _day ; // 日
    };