【C++】类和对象1

1. 类和对象上

1.1 类的定义

1.1.1 类的定义格式

// 数据和方法封装放到了一起，都在类里面
// 封装的本质体现了更严格的规范管理
class Stack
{
public:
	// 成员函数
	void Init(int capacity = 4)
	{
		_a = nullptr;  // malloc
		_top = 0;
		_capacity = capacity;
	}

	void Push(int x)
	{}

private:
	// 成员变量
	int* _a;
	int _top;
	int _capacity;

	//int capacity_;
	////member
	//int m_capacity;
	//int mCapacity;
};

面向对象三大特性：封装，继承，多态

1.1.2 访问限定符

1.1.3 类域

• 类定义了一个新的作用域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。
• 类域影响的是编译的查找规则，下面程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪里，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

1.2 实例化

1.2.1 实例化概念

1.2.2 对象大小

类的成员函数，成员函数的指针是不需要存储的，函数指针是一个地址，调用函数被编译成汇编指令【call地址】，其实编译器在编译链接时，就要找到函数的地址，不是在运行时找，只有动态多态是在运行时找，就需要存储函数地址。

类实例化的对象也要符合内存对齐的规则

class Stack
{
public:
	// 成员函数
	void Init(int n = 4)
	{

	}

//private:
	// 成员变量，声明
	int* array; // 4 8 4
	size_t capacity;  // 8  8  
	size_t top;  // 8 8 8
};

int main()
{
	// 定义，类实例化对象
	Stack s1;
	s1.top = 0;
	s1.Init();

	Stack s2;
	s1.top = 1;
	s2.Init(100);

	cout << sizeof(s1) << endl;  //24
	cout << sizeof(Stack) << endl;  //24

	return 0;
}

class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};

class B
{
public:
	void Print()
	{
		//...
	}
};

class C
{};

int main()
{
	cout << sizeof(A) << endl;  //4
	// 开1byte为了占位，不存储实际数据，表示对象存在过
	cout << sizeof(B) << endl;  //1
	cout << sizeof(C) << endl;  //1

	B b1;
	B b2;
	cout << &b1 << endl;  //00000037F8EFF6D4
	cout << &b2 << endl;  //00000037F8EFF6D4

	return 0;
}

1.2.3 this指针

class Date
{
public:
	//void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day)
	{
		cout << this << endl;

		//const保护this不能修改
		//this = nullptr;

		//this->_year = year;
		this->_year = year;
		this->_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这里只是声明，没有开空间
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	Date d2;
	// d1.Init(&d1, 2025, 7, 31);
	d1.Init(2025, 7, 31);

	//d2.Init(&d2, 2025, 7, 31);
	d2.Init(2025, 9, 1);

	d1.Print();
	d2.Print();

	return 0;
}

2. 类和对象中

2.1 类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

• 第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。
• 第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

2.2 构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型，如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

class Date 
{
public:
	//1. 无参构造函数
	//Date() 
	//{
	//	_year = 2000;
	//	_month = 1;
	//	_day = 1;
	//}
	// 2. 带参构造函数，不是默认构造函数
	//Date(int year, int month, int day) 
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	// 3. 全缺省构造函数
	Date(int year = 2000, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() 
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	
	}
private:
	int _year;
	int _month;
	int _day;

};

int main() {
	//函数声明
	/*Date func();*/

	Date d1;  //2000/1/1
	Date d2 = Date(2025, 9, 9);  //2025/9/9
	d1.Print();
	d2.Print();
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象

对于第七点，编译器默认生成的构造，对于内置变量的初始化没有要求：

class Date {
public:
	void Print() {
		cout << _year << "/" << _month << "/"  << _day;

	}
private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

int main() {
	Date d1;
	d1.Print();

	return 0;
}

对于自定义类型的成员变量，要求调用这个自定义成员变量的默认构造函数，如果这个自定义成员变量没有默认构造函数，则会报错，否则用初始化列表解决（后续讲到）

自定义成员变量有默认构造函数：

class Stack {
public:
	Stack()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

// 两个栈实现一个队列
class MyQueue
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;

};

int main() {


	MyQueue q;


	return 0;
}

如果自定义类型没有默认构造函数，则会报错：

class Date {
public:
	void Print() {
		cout << _year << "/" << _month << "/"  << _day;

	}
private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

class Stack {
public:
	Stack(int n)
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

// 两个栈实现一个队列
class MyQueue
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;

};

int main() {
	Date d1;
	d1.Print();

	MyQueue q;


	return 0;
}

自定义成员的默认构造函数中如果有内置类型：

class Date {
public:
	void Print() {
		cout << _year << "/" << _month << "/"  << _day;

	}
private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

class Stack {
public:
	Stack()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

// 两个栈实现一个队列
class MyQueue
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;
	int _size;

};

int main() {
	Date d1;
	d1.Print();

	MyQueue q;


	return 0;
}

内置函数初始化的变量：

2.3 析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。析构函数的功能类比我们之前Stack实现的Destroy功能，而像Date没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

后定义的先析构

//析构函数
class Date {
public:
	Date(int year=2000, int month=1, int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;

	}

	//日期类的析构函数可以不写，因为没有资源释放的需求
	~Date()
	{
		cout << "~Date()" << _day;
	}

private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

class Stack {
public:
	Stack()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main() {
	Date d1;
	Date d2;

	return 0;
}

对于第五点：

//析构函数
class Date {
public:
	Date(int year=2000, int month=1, int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}
	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;

	}

	//日期类的析构函数可以不写，因为没有资源释放的需求
	~Date()
	{
		cout << "~Date()" << _day;
	}

private:
	//内置类型
	int _year;
	int _month;
	int _day;
};

class Stack {
public:
	Stack(int n = 4)
	{
		_a = (int*)malloc(sizeof(int)*n);
		//检查a是否开辟成功
		_top = 0;
		_capacity = n;
	}
	// 有资源申请，自己写析构
	~Stack() {
		if (_a) 
		{
			cout << "~Stack()" << endl;
			free(_a);
			_a = nullptr;
			_top = 0;
			_capacity = 0;
		}
	}


private:
	int* _a;
	int _top;
	int _capacity;
};

// 两个栈实现一个队列
class MyQueue
{
private:
	// 自定义类型
	Stack _pushst;
	Stack _popst;
	int _size;

};

int main() {
	Date d1;
	Date d2;

	Stack s1;
	Stack s2(10);

	MyQueue q;

	return 0;
}

对于第六点，对于自定义类型成员，显示写析构和不显示写析构，默认生成都会去调用自定义类型成员的析构，就是为了保证资源不会泄露

对于括号匹配问题，C和C++的区别

2.4 拷贝构造

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造是一个特殊的构造函数。

拷贝构造的特点：

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_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;
	}
private:
	int _year;
	int _month;
	int _day;
};

// 自定义类型传值传参要调用拷贝构造
void Func(Date d) 
{

}
//void Func(Date& d)
//{
//
//}

int main()
{
	Date d1(2025, 8, 1);
	// 拷贝构造，拷贝同类型的对象完成初始化
	Date d2(d1);

	Func(d1);
}

传值传参需要调用拷贝构造

这个Func(d1),d1传给Func里的d，需要先调用拷贝构造，再进去Func函数（先完成传参这个动作）

如果是引用传参，就不需要调用拷贝构造，直接进来就调用函数

如果拷贝构造是传值传参，则会出现无穷递归的情况

如果使用引用传参，就不会出现这个问题，建议引用传参都要加const，加const方便传参，权限可以平移，也可以缩小，但不能放大

如果不加，就会出现权限放大的问题:

栈Stack的拷贝构造（出错情况）：

typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

	// Stack st2(st1);
	//Stack(const Stack& s)
	//{
	//	_a = s._a;
	//	_capacity = s._capacity;
	//	_top = s._top;
	//}

	Stack(const Stack& s)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * s._capacity);
		if (_a == NULL)
		{
			perror("realloc fail");
			return;
		}

		memcpy(_a, s._a, s._top * sizeof(STDataType));

		_capacity = s._capacity;
		_top = s._top;
	}

	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

class MyQueue
{
private:
	Stack _pushst;
	Stack _popst;
};


void Func( const Date& d) 
{

}
// 自定义类型传值传参要调用拷贝构造
//void Func(Date d)
//{
//
//}

int main()
{
	Date d1(2025, 8, 1);
	// 拷贝构造，拷贝同类型的对象完成初始化
	Date d2(d1);

	Func(d1);

	const Date d3(2025, 8, 1);
	Date d4(d3);

	Stack st1;
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);

	Stack st2(st1);

	MyQueue q1;
	MyQueue q2(q1);

}

发生如下报错（程序出现内存相关的问题）：

出了作用域调析构

第二次free挂了

上面的情况是浅拷贝/值拷贝，只把对象的值拷贝过去，一个对象的修改会影响另一个对象，浅拷贝的时候， 指向的是同一块空间

如果是内置类型，可以用浅拷贝，但如果是自定义的类型，尤其是有指向的资源，就得用深拷贝，深拷贝指向的是不同的空间

对于第四点，Date类可以调用默认的拷贝构造，因为都是内置类型，但是Stack必须自己写一个拷贝构造，原因如上，MyQueue类也可以调用默认的拷贝构造，因为对自定义类型成员变量会调用他的拷贝构造，也就是说会调用Stack的拷贝构造。一个类的析构和拷贝构造通常是绑定在一起的

栈的传引用返回（会出现野指针的现象）：

如果是传值返回，会调用拷贝构造

以下两种形式都是拷贝构造

第二行这样写就有点怪

2.5 赋值运算符重载

2.5.1 运算符重载

如果运算符重载函数在类外，而类内的成员变量为private修饰，那么成员变量就会不可访问，所以一般运算符重载函数写在类内

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

	//其实还有个形参this
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}

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

int main()
{

	Date d1(2025, 8, 1);
	Date d2(2025, 10, 1);

	cout << (d1 == d2) << endl;
	d1.operator==(d2);

	return 0;
}

成员函数的指针要指明域

void func1()
{
	cout << "void func()" << endl;
}

class A
{
public:
	void func2()
	{
		cout << "A::func()" << endl;
	}
};

int main()
{
	// 普通函数指针
	void(*pf1)() = func1;
	(*pf1)();

	// A类型成员函数的指针
	void(A::*pf2)() = &A::func2;
	A aa;
	(aa.*pf2)();

	return 0;
}

void(A::*pf2)() = &A::func2;

A前面加&相当于是一种C++规定

2.5.2 赋值运算符重载

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

请牢牢记住赋值重载完成两个已经存在的对象直接的拷贝赋值

而拷贝构造用于一个对象拷贝初始化给另一个要创建的对象

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	// Date d4(d3);
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}


	// d1 = d3 = d5
	// d1 = d1
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}

		return *this;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2025, 8, 1);
	Date d2(d1);
	// 一定注意，这个是拷贝构造
	Date d4 = d1;

	Date d3(2025, 10, 1);
	d1 = d3;
	Date d5(2025, 9, 1);

	d1 = d3 = d5;

	d1 = d1;

	return 0;
}

2.6 日期类的实现

要实现日期类的加减法，加法思路如下，向月份进位（30/31天，二月份另算），减法思路类似，向月份借位（30/31天，二月份另算）

拷贝次数如下图所示：

代码：

Date.h

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;

class Date
{
public:
	//全缺省参数在只函数声明或者函数定义
	Date(int year = 2000, int month = 1, int day = 1);
	void Print();

	int GetMonthDay(int year, int month)
	{
		assert(month > 0 && month < 13);
		
		int MonthDayArray[13] = { -1, 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 29;
		}
		else
		{
			return MonthDayArray[month];
		}
	}

	bool operator<(const Date& d);
	bool operator<=(const Date& d);
	bool operator>(const Date& d);
	bool operator>=(const Date& d);
	bool operator==(const Date& d);
	bool operator!=(const Date& d);

	// d1 += 天数
	Date& operator+=(int day);
	Date operator+(int day);

	// d1 -= 天数
	Date& operator-=(int day);
	Date operator-(int day);

	// d1 - d2
	int operator-(const Date& d);

	// ++d1 -> d1.operator++()
	Date& operator++();

	// d1++ -> d1.operator++(0)
	// 为了区分，构成重载，给后置++，强行增加了一个int形参
	// 这里不需要写形参名，因为接收值是多少不重要，也不需要用
	// 这个参数仅仅是为了跟前置++构成重载区分
	Date operator++(int);

	Date& operator--();
	Date operator--(int);



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

Date.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"Date.h"

Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;
	_day = day;
};

void Date::Print()
{
	cout << _year << "-" << _month << "-" << _day << endl;
}

//原始写法，完整的
// d1 += 100
//Date& Date::operator+=(int day)
//{
//	_day += day;
//	while (_day > GetMonthDay(_year, _month))
//	{
//		_day -= GetMonthDay(_year, _month);
//		++_month;
//		if (_month == 13) {
//			++_year;
//			_month = 1;
//		}
//	}
//	return *this;
//}
//
//// d1+100
//Date& Date::operator+(int day) 
//{
//	Date& tmp(*this);
//
//	tmp._day += day;
//
//	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
//	{
//		tmp._day -= GetMonthDay(tmp._year, tmp._month);
//		++tmp._month;
//		if (tmp._month == 13) {
//			++tmp._year;
//			tmp._month = 1;
//		}
//	}
//	return tmp;
//
//}


//另外一种写法一
Date& Date::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		++_month;
		if (_month == 13)
		{
			++_year;
			_month = 1;
		}
	}

	return *this;
}

// d1 + 100
Date Date::operator+(int day)
{
	Date tmp(*this);
	tmp += day;
	return tmp;
}


//// 另一种写法二
//// d1 += 100
//Date& Date::operator+=(int day)
//{
//	*this = *this + day;
//	return *this;
//}
//
//Date& Date::operator+(int day)
//{
//	Date& tmp(*this);
//	tmp._day += day;
//	while (tmp._day > GetMonthDay(tmp._year, tmp._month))
//	{
//		tmp._day -= GetMonthDay(tmp._year, tmp._month);
//		++tmp._month;
//		if (tmp._month == 13) {
//			++tmp._year;
//			tmp._month = 1;
//		}
//	}
//	return tmp;
//}

// 前置++ 和后置++
// 前置++ 
Date& Date::operator++()
{
	*this += 1;
	return *this;
}
// 后置++, 为了和前置++进行区分达到重载，形参中添加int, 但这个int不起作用
Date Date::operator++(int)
{
	Date tmp(*this);
	*this += 1;
	return tmp;
}

// 日期类的减法
Date& Date::operator-=(int day)
{
	//if (day < 0)  //减法变加法
	//{
	//	return *this += _day;
	//}
	_day -= day;
	while (_day <= 0)
	{
		--_month;
		_day += GetMonthDay(_year, _month); //借上个月的天数
		if (_month == 0) {
			--_year;
			_month = 12;
		}
	}
	return *this;
}

Date Date::operator-(int day)
{
	Date tmp(*this);
	tmp -= day;
	return tmp;
}

Test.cpp

///////////////////////////////////////////////////////
// 日期类的实现
#include"Date.h"

int main()
{
	// 日期加法
	//Date d1(2025, 8, 1);
	//Date d2 = d1 += 100;
	//d1.Print();  //2025-11-9
	//d2.Print();   //2025-11-9

	//Date d3(2025, 8, 1);
	//Date d4 = d3 + 100;
	//d3.Print();  //2025-8-1
	//d4.Print();  //2025-11-9

	//前置++和后置++
	//Date d1(2025, 8, 1);
	////Date ret1 = d1.operator++(10); // 显示调用，实参只要是整形就可以
	//Date ret1 = d1++;
	//ret1.Print();   //2025-8-1
	//d1.Print();     //2025-8-2
	//
	//Date d2(2025, 8, 1);
	//Date ret2 = ++d2;
	////Date ret2 = d2.operator++();
	//ret2.Print();  //2025-8-2
	//d2.Print();    //2025-8-2

	// 日期类的减法

	Date d1(2025, 11, 9);
	Date d2 = d1 -= 100;
	d1.Print();  //2025 - 8 - 1
	d2.Print();  //2025 - 8 - 1

	Date d3(2025, 11, 9);
	Date d4 = d3 - 100;
	d3.Print();  //2025-11-9
	d4.Print();  //2025 - 8 - 1


	return 0;

}