c++——类和对象

类的引入

c语言中的结构体只能定义变量，在c++中，结构体内不仅可以定义变量，也可以定义函数。c++关注的是类型之间的关系。

typedef int DataType;
struct Stack//c++可以用struct定义类，但是c++更喜欢用class来定义类。
{
     void Init(size_t capacity)；//在c语言当中初始化函数要写在结构体外面，而且参数还要多加一个stack*。不需要写成StackInit,因为它定义在stack里面。
     void Push(const DataType& data)；
     DataType Top()；
     void Destroy();
     //······
     DataType* _array;
     size_t _capacity;
     size_t _size;
};//分号不要忘记了
int main()
{
     Stack s;
     s.Init(10);
     s.Push(1);
     s.Push(2);
     s.Push(3);
     cout << s.Top() << endl;
     s.Destroy();
     return 0;
}

类的定义

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名（推荐）

//声明放在stack.h文件当中
struct Stack
{
     void Init(size_t capacity)；
     void Push(const DataType& data)；
     DataType Top()；
     void Destroy();
     //······
     DataType* _array;
     size_t _capacity;
     size_t _size;
};
//成员函数放在实现文件当中stack.cpp
#include"stack.h"
void stack::Init(size_t capacity)
{
    //········
}

//错误写法
class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;//这种写法会导致d1.init(2023,9,11)并不会初始化d1这个对象的成员变量，因为局部优先的原则，这两个year编译器都会理解成Init（）函数的形参
		month = month;
		day = day;
	}

private:
	int year;
	int month;
	int day;
};
//正确写法
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;//这种写法会导致d1.init(2023,9,11)并不会初始化d1这个对象的成员变量，因为局部优先的原则，这两个year编译器都会理解成Init（）函数的形参
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

c++中struct和class的区别

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来 定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

类的实例化

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。而实例出来的对象，占用实际的物理空间，存储类的成员变量。

类实例化的每个对象中的成员变量是不同的，但调用的是同一份函数，所以类成员函数的代码只保存一份，放在了公共的代码区。所以成员变量在对象中，成员函数不在对象中。所以一个类的大小，实际上就是该类中成员变量之和（要注意内存对齐，并不是简单的成员变量相加）。

空类的大小比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

this指针

this指针的类型：类类型* const，这也说明了成员函数中无法给this指针赋值

this指针本质上是成员函数的形参，当对象调用成员函数的时候，将对象地址做为实参传递给this形参。所以对象中不存储形参。

this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

//实际代码如下
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;  
	int _month;
	int _day;
//};

//但是编译器会进行下述的隐式操作
class Date
{
public:
	void Init(Date* this, int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;//我们也可以通过cout<<this<<endl来显示调用
	}
private:
	int _year;  
	int _month;
	int _day;
};

 this指针存在于栈当中，因为它是隐含的形参。

为什么要有this指针？

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函 数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢。

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏 的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

class Date
{
public:
	void init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void func()
	{
		cout << "func()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date* p = nullptr;
	p->func();//正常运行，因为该函数未涉及堆成员变量进行操作，无需解引用
	p->init(2023, 5, 5);//运行崩溃，因为init函数需要对成员变量进行操作，所以要对p进行接近用操作
	(*p).func();//正常运行，因为func函数不在对象里面，编译器此时会很聪明，不会对p进行解引用操作，因为没有用，
	//而是去公共的代码段找该函数。是否有解引用操作不取决于是否采用了解引用符号，而取决于是否有必要。
	return 0;
}

c和c++实现栈结构的区别

在c中，每一个函数的第一个参数都是stack；函数都是通过stack*参数操作栈；函数调用时必须传递stack结构体变量的地址。结构体中只能定义存放数据的结构，操作方法不能放在结构体中，即数据和方法时分离的，所以在实际操作的过程中涉及到了大量指针的操作，稍不注意就会出错。而且由于struct的public权限导致数据访问是自由的，很危险。对于stack*参数需要自己维护。

c++通过类可以将数据和方法进行结合，通过访问权限可以控制那些方法在类外被调用，即封装。而且每个方法不需要传递stack*参数。对于stack*参数是编译器自己维护的。

c的结构体和c++的类在使用的时候的区别

默认成员函数

用户没有显式实现，编译器自动生成的成员函数称为默认成员函数

构造函数

构造函数是一个特殊的成员函数，可用来代替类似于Date类中void init(xxx)这种初始化函数。名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次。

构造函数的主要任务是初始化对象，并不是开空间创建对象。

构造函数和类名相同，无返回值（void都不需要），并且构造函数可以重载，也就是一个类可以有多个构造函数，说明有多种初始化方式。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {}
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1;//调用无参构造函数。如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明。
    Date(2023, 6, 6);//调用带参数的构造函数
}

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

class Date
{
public:
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(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()
{
        Date d1;//将Date类中显式构造函数 Date(int year, int month, int day)屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数。但是此时d1由于调用的是默认构造函数，会导致d1内置类型成员变量_year···都是随机值，但是对于自定义类型的成员变量会调用它的默认构造函数，也就是说编译器生成的默认构造函数用处不大。
        //将Date类中显式构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成。此时没有无参的构造函数，编译器会报错，没有合适的构造函数        
    return 0;
}

 c++11正对内置类型成员不初始化的缺陷打了一个补丁，也就是内置类型的成员变量在类中声明的时候可以给默认值。

无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。并且默认构造函数只能有一个。默认构造函数就属于不传参就可以调用的构造函数，一般建议，每一个类提供一个默认的构造函数，但是全缺省的构造函数和无参的构造函数时不能同时存在的，因为当你采用无参调用构造函数的时候会有歧义，编译器不知道要调用哪一个构造函数，所以一般建议保留全缺省的构造函数。

析构函数

析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成。而对象在销毁是会自动调用析构函数，完成对象中资源（比如一些动态开辟的空间）的清理工作。内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可。如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如date类。有资源申请时，一定要写，否则会造成内存泄漏，比如stack类。

析构函数实在类名前面加上字符~。无参数无返回值类型。析构函数是不存在函数重载的，也就是一个类只能有一个析构函数。

类的对象出了作用域调用析构函数，若有显示的析构就调用显示，否则调用默认的析构函数。对于日期类不用析构函数（因为它的成员变量年月日时三个整型变量，都是内置类型）。但是栈类型要写默认的析构函数，因为栈的有一个成员变量int* arr是动态开辟的空间。

拷贝构造函数

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

拷贝构造函数也属于构造函数重载

// 内置类型，编译器可以直接拷贝
// 自定义类型的拷贝，需要调用拷贝构造
//传值传参，而形参是实参的拷贝，自定义类型拷贝要调拷贝构造
void Func1(Date d)
{

}
// 传引用传参
void Func2(Date& d)
{

}
//传指针传参
void Func3(Date* d)
{

}

int main()
{
	Date d1;
	Func1(d1);//传值传参，传参的时候其实是一个拷贝，因为他是一个自定义类型，和内置类型不同，自定义类型不可以随便拷贝，因为编译器无法承担拷贝的行为，自定义类型的拷贝需要调用拷贝构造函数。而且对于有些自定义类型需要使用深拷贝的拷贝构造，编译器的拷贝一般都是浅拷贝，也就是字节拷贝。
    //代码走到此处Func1(d1)，按一下F11会跳到拷贝构造函数Date(Date& d),也应证了自定义类型拷贝需要调用拷贝构造
	Func2(d1);//传引用传参，因为是内置类型，所以不需要调用拷贝构造函数
	Func3(&d1);//传指针传参，因为是内置类型，所以不需要调用拷贝构造函数。引用和执都不用拷贝构造，二者功能实现一样，但是传引用更方便一些。
	return 0;
}

为什么拷贝构造的参数只有一个且必须是类类型对象的引用（最好用const修饰即const date&类型，这样是为了让传过来的参数只可读不可写），若使用传值方式也就是传类对象（date类型）会直接报错？

class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(Date d)
	{
		cout << "Date(Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2023, 6, 6);
	Date d2(d1);//此处的拷贝构造会造成无穷递归，因为Date d2(d1)该对象实例化调用的是拷贝构造函数，拷贝构造要先传参，参数不是引用不是指针，而是一个自定义类型，自定义类型传参又是一个拷贝搞糟，所以这里无线递归
	return 0;
}

Date d2(d1)是对象实例化，实例化要调用对应的构造函数，此处是采用拷贝构造，而拷贝构造要传参，传值传参又是一个拷贝构造，而拷贝构造又要传参，但传参又要调用拷贝构造。

//拷贝构造函数
Date(const Date& d)
	{
		cout << "Date(Date& d)" << endl;

		_year = d._year;
		_month = d._month;
		_day = d._day;
    }
//一个普通的构造函数，并非拷贝构造函数，但也能完成拷贝构造的功能，只是稍微麻烦一些
Date(const Date* d)
{
	cout << "Date(const Date* d)" << endl;
	_year = d->_year;
	_month = d->_month;
	_day = d->_day;
}

浅拷贝的危害

比如编译器对于自定义类型stack栈结构自行进行拷贝，像下面一样

int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2(s1);
 return 0;
}

上述代码的后果如下：

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

拷贝构造函数的调用场景：使用已存在的对象创建新对象、函数参数类型为类类型对象、函数返回值类型为类类型对象。

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;
}

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

  运算符重载

运算符重载是一种特殊的函数，函数名字是关键字operator后面接需要重载的运算符符号。

重载操作符必须有一个类类型参数，用于内置类型的运算符，其含义不能改变，例如内置的整型+。

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

.*  ::  sizeof   ?:   .   这三种操作符不可以重载

// 这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？
class Date
{
public:
    Date(int year = 2023, int month = 6, int day = 6)
    {
        _year = year;
        _month = month;
        _day = day;
    }
//private:
    int _year;
    int _month;
    int _day;
};
bool operator==(const Date& d1, const Date& d2)//形参的顺序涉及到了操作符的左右运算数，运算符重载定义在全局，但是想要得到类的成员变量有点问题。方法1：在列里面添加一个getmonth之类的函数；方法2：放到类里面；方法3：友元
{
    return d1._year == d2._year
        && d1._month == d2._month
        && d1._day == d2._day;//次处由于Date的成员变量设置成private，会造成return的这些成员变量都无法访问
}
int main()
{
    Date d1(2023, 9, 7);
    Date d2(2023, 9, 7);
    cout << (d1 == d2) << endl;//所以函数会报错，但是如果将Date的成员变量设置成public ，该函数就可以正常的运行。这种调用方法会转换成调用operator==(d1, d2)
    cout << operator==(d1, d2) << endl;//同上
    return 0;
}

//此处将运算符重载重载成成员函数
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    bool operator==(const Date& d2)
    {
        return _year == d2._year
            && _month == d2._month
            && _day == d2._day;
    }
    bool operator<(const Date& d)
	{
	    return _year < d._year
		|| (_year == d._year && _month < d._month)
		|| (_year == d._year && _month == d._month && _day < d._day);
	}
    bool operator<=(const Date& d)//运算符的复用
    {
	    return *this < d || *this == d;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2023, 9, 6);
    Date d2(2023, 9, 6);
    cout << d1.operator==(d2) << endl;//但是调用的时候可读性就没有那么强了
    cout << (d1 == d2) << endl;//这样写可读性更强一些，转换成去调用d1.operator==(d2)
    return 0;
}

赋值运算符重载

赋值运算符重载不写的话，编译器会默认生成，因为是天选之子。但是由于编译器的赋值重载是浅拷贝，所以对于stack类赋值运算符重载是需要自己写的，但是像Date类可以不用写，采用编译器默认生成的运算符重载就可以了。

//赋值运算符重载做为成员函数
void operator=(const Date& d)//可以实现赋值运算符重载的功能，但是不支持连续赋值
{
    _year = d._year;
    _month = d._month;
    _day = d._day;
}
//优化
Date& operator=(const Date& d)//参数类型const Date&是因为传递引用可以提高传参效率
{
    if (this != &d)//防止自己给自己赋值这种无效的操作
    {
        _year = d._year;
        _month = d._month;
        _day = d._day;
    }
    return *this;//出了作用域*this依旧存在，所以返回值写Date&是没有问题的。这里返回Date也是没有问题的，只是会浪费依次多余的拷贝。此处的返回值还有一个目的是为了支持连续赋值。
}

赋值运算符为什么只能重载成类的成员函数不能重载成全局函数？

因为赋值运算符如果不显示实现，编译器会生成一个默认的。此时用户在类外自己实现一个全局的运算符重载函数，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值运算符重载只能是类的成员函数。

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注 意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符 重载完成赋值。

 如果类中为涉及到资源管理，赋值运算符是否实现都可以，一旦涉及到资源管理则必须自己实现。

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;
	s2 = s1;
	return 0;
}

赋值运算符重载和拷贝构造的区别

赋值重载是已经实例化的两个对象去进行操作，如d2 = d1或者d1.operator=(d2)，这两种写法都是赋值运算符重载。而拷贝构造是用一个已经实例化的对象去初始化一个未实例话的对象，如 Date d2 = d1或者Date d2(d1)，这两种写法都是拷贝构造。

class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date& operator=(const Date& d)
    {
        if (this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }

        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
	Date d1(2023, 6, 6);
	Date d2(2024, 6, 6);
	Date d3(2025, 6, 6);
    d1.operator=(d2);//赋值运算符重载
	d3 = d1 = d2; // 赋值运算符重载
	Date d5 = d1; // 拷贝构造
	Date d6(d1); // 拷贝构造 
	return 0;
}

前置++和后置++重载

Date& operator++()//前置++运算符重载
{
	_day += 1;
	return *this;
}//调用方法：Date d2 = d1.operator++()或者Date d2 = ++d1
Date operator++(int)//后置++运算符重载，调用的时候传一个整型就可以了，不一定非得是1
{
	Date temp(*this);
	_day += 1;
	return temp;//这里由于是临时对象，除了栈就没有了，所以只能以传值返回，不能传引用返回
}//调用方法：Date d2 = d1.operator++(2)或者Date d2 = d1++

流插入运算符重载

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void operator << (ostream& out)
	{
		out << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1(2023, 1, 10);
	d1.operator<<(cout);//第一个参数是左操作数，第二个参数是右操作数
	d1 << cout;//此处运算符重载是做为Date的成员函数，这就造成了d1必须是第一个参数，但是运算符重载不一定要是成员函数，也可以做为全局函数.
	return 0;
}

//采用全局函数进行流插入运算符重载
void operator(ostream& out, const Date& d)//若写成了全局函数，则无法访问类中的私有变量，可以再类中加上getmonth、getday成员函数，或者采用友元
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
}
int main()
{
	Date d1(2023, 1, 10);
	operator<<(cout, d1);
	cout << d1;//虽然此时顺序对了，但是不支持连续输入
	return 0;
}
//再一次堆全局函数进行优化
ostream& operator(ostream& out, const Date& d)
{
	out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;//修改返回值就可以支持连续调用cout<<d1<<d2
}

const成员

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

class Date
{
public:
 Date(int year, int month, int day)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 void Print()
 {
 cout << "Print()" << endl;
 cout << "year:" << _year << endl;
 cout << "month:" << _month << endl;
 cout << "day:" << _day << endl << endl;
 }
 void Print() const
 {
 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();//调用的是Print()
 const Date d2(2022,1,13);
 d2.Print();//调用的是Print() const
}

class Array
{
public:
	int& operator[](int i)
	{
		assert(i < 10);
		return _a[i];
	}
	const int& operator[](int i) const//此处[]运算符重载有普通型和const型，可以只有const型不用普通型，但会导致Array类不可修改只可读
	{
		assert(i < 10);
		return _a[i];
	}
private:
	int _a[10];
	int _size;
};

取地址即const取地址操作符重载

class Date
{
public:
	Date* operator&()
	{
		return this;

	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year; 
	int _month; 
	int _day; 
};

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