C++类和对象---------六个默认成员函数

类中有六个默认成员函数，这六个函数包括：构造函数、析构函数、拷贝构造函数、赋值运算符重载、普通对象取地址重载、const修饰对象的取地址重载。

所有的默认成员函数都是可以由编译器自己生成的，编译器会自己生成一个默认的函数。同时我们也可以自己定义这些函数，那么编译器就会直接使用我们定义好的函数而不会自己再生成了。

一 构造函数 --- 默认成员函数一

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。数据结构中伴随着大量的初始化，（树的，栈的，链表的初始化）如果我们使用C++类创建对象时,编辑器可以调用构造函数帮助我们进行初始化，在创建变量后这个变量就直接被初始化完成了。

#include<iostream>
using namespace std;
class Date
{
public:

	void print()
	{
		cout << _year << endl;
		cout << _month << endl;
		cout << _date << endl;
	}
private:
	int _year;
	int _month;
	int _date;
};
int main()
{

	Date a;//在定义完变量后，也初始化完毕了
	a.print();
	return 0;
}
//结果：-858993460 -858993460 -858993460

特性

• 负责类的变量的初始化
• 函数名与类名相同
• 无返回值
• 对象实例化时编译器自动调用对应的构造函数
• 构造函数可以重载

C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，编译器生成默认的构造函数会对自定类型成员调用的它的默认构造函数。

//我们在类中定义，无参的，全缺省的构造函数
Date ()//无参数
{
    _year = 2023;
    _month = 1;
    _date = 1;
}
Date (int year = 2023, int _month = 1, int _date = 1)//全缺省
{
    _year = year;
    _month = month;
    _date = date;
}
//可以在一个类中定义,调用时编辑器依赖我们是否给予参数来调用函数
无参便调用第一个函数
有参数但不够，三个参数都有，便会调用第二个参数

C++11中针对内置类型成员不初始化的缺陷，内置类型成员变量在类中声明时可以给缺省值。

#include<iostream>
using namespace std;
class Date
{
public:  
    void print()
    {
        cout << _year << ' ';
        cout << _month << ' ';
        cout << _date << endl;
    }
private:
    int _year = 2023;//缺省值
    int _month = 1;//缺省值
    int _date = 1;//缺省值
};
int main()
{
 
    Date a;
    a.print();
    return 0;
}
//结果：2023 1 1
在变量声明时给予缺省值

二 析构函数 --- 默认成员函数二

数据结构有只要有"XXX"init()初始化，必然就有destroy(),不然就会造成内存泄漏,C++中引入了析构函数负责变量清理。

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

特性

• 析构函数名是在类名前加上字符~。
• 无参数无返回值类型。
• 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
• 析构函数不能重载。
• 对象生命周期结束时，C++编译系统系统自动调用析构函数。//对象脱离生成作用域

#include<iostream>
using namespace std;
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类的对象，Date类型中有三个内置类型_year, _month,_day和一个自定义类型Date d，对于内置类型直接回收就可以了，但是自定义类型就需要调用对应类的析构函数。Date类型的d就需要调用~Date销毁，创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数。
 

拷贝构造函数 --- 默认成员函数三

我们在创建对象时，一定会有需要创建另一个一模一样的变量。

那在创建对象时，怎么创建一个与已存在对象一某一样的新对象呢？

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

特性 

• 拷贝构造函数是构造函数的一个重载形式。
• 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。
• 一般传递常引用，//因为拷贝我构造你，并不希望改变我(复印别人的东西，不要改变原件)
• 若未显式定义（你没有自己定义这个函数），编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝（类似于memcpy函数，一个字节一个字节拷贝），这种拷贝叫做浅拷贝，或者值拷贝。
• 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，就不需要自己显式实现了。
• 如果一个类中，你需要定义非空的析构函数，那么，通常情况下你也需要自己定义拷贝构造函数。
   

#include<iostream>
using namespace std;
class Date
{
public:
    Date(int year = 2022, int month = 1, int day = 1)//构造函数
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void print()//内部成员函数，打印
    {
        printf("%d ", _year);
        printf("%d ", _month);
        printf("%d\n", _day);
    }
private:
    int _year = 2022;
    int _month = 1;
    int _day = 1;
};
 
 
int main()
{
    Date d1(2023, 1, 1);
    Date d2(d1);//d2是新创建的变量，d2相当于d1的赋值粘贴
    d1.print();
    d2.print();
    return 0;
}
//结果：
//2023 1 1
//2023 1 1

深拷贝与浅拷贝

浅拷贝是指，只拷贝对象的具体内容，完全复制粘贴。

深拷贝是指，拷贝对象的具体内容，深拷贝在计算机中开辟一块新的内存地址用于存放复制的对象。源数据改变不会影响复制的数据。

赋值运算符重载 --- 默认成员函数四

 运算符重载

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

函数名字为：关键字operator后面接需要重载的运算符符号。函数原型：返回值类型 operator操作符(参数列表)

• 不能通过连接其他符号来创建新的操作符：比如operator@
• 重载操作符必须有一个类类型参数
• 用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义
• 作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this
• 注意括号内的5个运算符不能重载。（ .* :: sizeof ?: . ）不需要明确地知道这些运算符都是怎么使用的，记住就好

前置++和--   后置++和--    的重载

前置++(--)和后置++(--)在符号上是一样的，我们通常在后置++(--)的函数加上一个int参数，这个参数只是用于辨别，甚至不用起名，真正的函数也不会接收这个参数。

// 前置++
Date& operator++()
{
    *this += 1;
    return *this;
}
 
// 后置++
Date& operator++(int)
{
    Date a(*this);
    *this += 1;
    return a;
}
 
// 后置--
Date& operator--(int)
{
    Date a(*this);
    *this -= 1;
    return a;
}
 
// 前置--
Date& operator--()
{
    *this -= 1;
    return *this;
}

运算符“ = ” 的重载实现了对象与对象间更多的操作    编译器默认生成赋值运算符重载的函数可以做到类似memcpy的逐字节拷贝。

在实现这个函数时需要注意下面四点

• 参数类型为const T&，传递引用可以提高传参效率
• 返回值类型T&，返回引用可以提高返回的效率有返回值目的是为了支持连续赋值
• 检测是否自己给自己赋值
• 返回*this ：要复合连续赋值的含义

这个运算符的重载函数非常像拷贝构造，但是还是有所不同。

一般而言，拷贝构造函数用于一个新建的类变量的初始化，而赋值运算符重载函数用于两个已经创建的变量的赋值。

int main()
{
    Date a(2022,1,1);//调用拷贝构造函数
    Date b = a;//调用拷贝构造函数，b的初始化
    Date c;
    c = a;//调用赋值运算符重载
    return 0;
}

我们当然也可以自己实现这个函数，最简单的实现方式就是每一个变量都各自赋值

Date& operator=(const Date& d)
{
    if(&d != this)//避免自己赋值自己
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;            
    }    
 
    return *this;//一般返回的都是表达式左侧的内容，也对应*this
}

如果我们有两个Date类型的a和b变量，对于a = b;这个表达式，左侧的a一般为this指针指向的内容，右侧的d为参数。

到这里我们都是在自己实现进行值拷贝的赋值运算符重载，但是我们在最开始就已经知道了，C++编译器自己生成的赋值运算符重载就已经可以做到每一个字节的精确拷贝，所以这样的值拷贝我们也没有必要去自己实现这个函数，用编译器自己生成的就好了。对于值拷贝就可以达到赋值的类确实没什么问题，但是一旦涉及到动态内存就会出现问题，比如下面的栈（只实现了部分功能）：
 

#include<iostream>
using namespace std;
#define int TYPE;
class Stack
{
public:
    //构造函数
    Stack(size_t capacity = 4)
    {
        _arr = (TYPE*)malloc(sizeof(TYPE)* capacity);
        if (NULL == _arr)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = capacity;
        _size = 0;
    }
    //拷贝构造函数
    Stack(const Stack& s)
    {
        _arr = (TYPE*)malloc(sizeof(TYPE)* _capacity);
        if (NULL == _arr)
        {
            perror("malloc fail");
            return;
        }
        _capacity = s._capacity;
        _size = s._size;
    }
    //析构函数
    ~Stack()
    {
        if (_arr)
        {
            free(_arr);
            _arr = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
    //压栈
    void Push(TYPE data)
    {
        _arr[_size] = data;
        _size++;
    }
    //赋值运算符重载
    Stack& operator=(const Stack& s2)
    {
        _arr = s2._arr;
        _capacity = s2._capacity;
        _size = s2._size;
        return *this;
    }
private:
    TYPE* _arr;
    int _capacity;
    int _size;
};
 
 
int main()
{
    Stack s1;
    s1.Push(1);
    s1.Push(2);
    s1.Push(3);
    s1.Push(4);
    Stack s2(s1);
    s2.Push(1);
    s2.Push(2);
    s2 = s1;            
    return 0;
}

Stack& operator=(const Stack& s)
{
    free(this->arr);
    _arr = (TYPE*)malloc(_capacity*sizeof(TYPE));
    _capacity = s._capacity;
    _size = s._size;
    return *this;
}

const成员函数

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

#include<iostream>
#include<stdio.h>
#include <time.h>
using namespace std;


class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
	 _year = 10;
 cout << "Print()" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
 void Print() const  //const Date* this
 {
	// _year = 10;//常方法不允许修改,this指针已经被锁定
 cout << "Print()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(2022, 1, 13);
	d1.Print();
	const Date d2(2023, 2, 14);
	d2.Print();
}

void main()
{
	Test();
}

 

去掉了const成员函数

非const对象是可以调用常方法的

const 对象不能调动非const方法

//从权限角度考虑 常方法不能修改this指针,非const方法可以修改this指针

取地址重载&&const修饰对象的取地址重载 --- 默认成员函数五&&六

取地址重载分为：普通对象取地址重载、const修饰对象的取地址重载。

class Date{
public:
    Date* operator&()  //普通对象取地址重载
    {
        return this;
    }
    const Date* operator&() const  //const修饰对象的取地址重载
    {
        return this;
    }
private:
    int _year;
    int _month;
    int _day;
};