零基础吃透 C++ 类默认成员函数：万字核心知识点汇总

#include<iostream>
using namespace std;
class Date
{
public:
	// 1.⽆参构造函数 
	Date()//这里显示定义构造函数，类名与函数名相同，没有返回值
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	// 2.带参构造函数 
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	// 3.全缺省构造函数 
	Date(int year = 1, 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 d1; // 调⽤默认构造函数 
 Date d2(2025, 1, 1); // 调⽤带参的构造函数 
 // 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 
 // 区分这⾥是函数声明还是实例化对象 
 // warning C4930: “Date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?) 
 Date d3();
 d1.Print();
 d2.Print();
 return 0;
}

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()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};


// 两个Stack实现队列 
class MyQueue
{
public:
	//编译器默认⽣成 MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源 
	// 就算在这里显⽰写析构，return时候也会⾃动调⽤Stack的析构 
 /*
 ~MyQueue()
 {}
 */
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}

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

void Copy(Date d) { // 重点：传值传参
        this->_year = d._year;
        this->_month = d._month;
        this->_day = d._day;
        cout << "void Copy(Date d)：普通拷贝函数调用（传值参数）" << endl;
    }//这会很正常的调用

//写法一
Date d3(d1);
d2.Print();
//写法二
Date d4 = d1;
d2.Print();

#include <iostream>
using namespace std;

// 1. 回调函数1：求和
int sum(const int arr[], int len) {
    int total = 0;
    for (int i = 0; i < len; ++i) {
        total += arr[i];
    }
    return total;
}

// 2. 回调函数2：找最大值
int maxVal(const int arr[], int len) {
    int m = arr[0];
    for (int i = 1; i < len; ++i) {
        m = (arr[i] > m) ? arr[i] : m;
    }
    return m;
}

// 3. 数组处理函数：参数直接写函数指针类型（无别名，冗长）
void processArray(const int arr[], int len, int (*callback)(const int[], int)) {
    int result = callback(arr, len);
    cout << "结果：" << result << endl;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int len = sizeof(arr) / sizeof(arr[0]);

    // 传递回调函数（函数名隐式转换为函数指针）
    processArray(arr, len, sum);    // 求和：25
    processArray(arr, len, maxVal); // 找最大值：9

    return 0;
}

#include <iostream>
using namespace std;

// 方式1：typedef 定义函数指针别名（兼容C）
// typedef int (*Callback)(const int[], int);

// 方式2：using 定义别名（C++11+推荐，语法更清晰）
using Callback = int (*)(const int[], int);

// 1. 回调函数1：求和（与无别名版一致）
int sum(const int arr[], int len) {
    int total = 0;
    for (int i = 0; i < len; ++i) {
        total += arr[i];
    }
    return total;
}

// 2. 回调函数2：找最大值（与无别名版一致）
int maxVal(const int arr[], int len) {
    int m = arr[0];
    for (int i = 1; i < len; ++i) {
        m = (arr[i] > m) ? arr[i] : m;
    }
    return m;
}

// 3. 数组处理函数：用别名替代冗长的函数指针类型
void processArray(const int arr[], int len, Callback callback) {
    int result = callback(arr, len);
    cout << "结果：" << result << endl;
}

int main() {
    int arr[] = {1, 3, 5, 7, 9};
    int len = sizeof(arr) / sizeof(arr[0]);

    // 传递回调函数（用法不变，可读性更高）
    processArray(arr, len, sum);    // 求和：25
    processArray(arr, len, maxVal); // 找最大值：9

    // 额外优势：用别名直接定义函数指针变量
    Callback funcPtr = sum;
    cout << "单独调用回调（sum）：" << funcPtr(arr, len) << endl; // 25

    funcPtr = maxVal;
    cout << "单独调用回调（maxVal）：" << funcPtr(arr, len) << endl; // 9

    return 0;
}

 Date d1(2024, 7, 5);
 Date d2(d1);
 //以上是拷贝构造
 //以下是赋值运算符重载
 Date d3(2024, 7, 6);
 d1 = d3;

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<iostream>
#include<cassert>

using namespace std;

class Date
{
	//友元函数声明
	friend ostream& operator<<(ostream&, const Date& d);
	friend istream& operator>>(istream& in, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1);
	void Print() const;
	
	//获取月份对应天数，同时声明放在函数内部，默认inline
	int getmonthday(int year, int month)
	{
		static int day_array[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;
		}
		return day_array[month];
	}

	bool CheckDate();

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

	// 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);

	Date& operator++();
	Date operator++(int);

	Date& operator--();
	Date operator--(int);
private:
	int _year;
	int _month;
	int _day;
};

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include"Date.h"


//打印函数
void Date::Print() const
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}


//检查日期
bool Date::CheckDate()
{
	if (_month < 1 || _month>12 || _day< 1 || _day>getmonthday(_year,_month))
	{
		return 0;
	}
	else
	{
		return 1;
	}
}


//重载 <
bool Date::operator<(const Date& d) const
{
	if(* this == d)
	{
		return false;
	}
	if (_year != d._year)
	{
		return _year < d._year;
	}
	if (_month != d._month)
	{
		return _month < d._month;
	}
	if (_day != d._day)
	{
		return _day < d._day;
	}
}


//重载 <=
bool Date::operator<=(const Date& d) const
{
	return *this == d || *this < d;
}


//重载 >
bool Date::operator>(const Date& d) const
{
	return !(*this <= d);
}


//重载 >= 
bool Date::operator>=(const Date& d) const
{
	return !(*this < d);
}


//重载 ==
bool Date::operator==(const Date& d) const
{
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}


//重载 !=
bool Date::operator!=(const Date& d) const
{
	return !(*this == d);
}


//构造函数
Date::Date(int year, int month, int day)
{
	_year = year;
	_month = month;		
	_day = day;
	if (!CheckDate())
	{
		cout << "输入非法" << endl;
	}
}



//重载 +=
Date& Date::operator+=(int day)
{
	if (day < 0)
	{
		return *this -= -day; // 负天数转成减正数
	}
	_day += day;
	while (_day > Date::getmonthday(_year, _month))
	{
		_day -= Date::getmonthday(_year, _month);
		_month++;
		if (_month == 13)
		{
			_year++;
			_month = 1;
		}
	}
	return *this;
}


//重载 +
//可以复用+=来实现+，也可以复用+来实现+=，但是用+实现+=多了三次拷贝构造
Date Date::operator+(int day)
{
	Date tmp = *this; //拷贝构造，将d1的日期拷贝到tmp上去
	tmp += day;
	return tmp;
}


//重载 -=
Date& Date::operator-=(int day)
{
	if (day > 0)
	{
		_day -= day;
		while (_day < 1)
		{
			_month--;
			if (_month == 0)
			{
				_month = 12;
				_year--;
			}
			_day += getmonthday(_year, _month);
		}
		return *this;
	}
	else
	{
		day = -day;
		*this += day;
		return *this;
	}
}


//重载 -
Date Date::operator-(int day)
{
	Date tmp = *this; //拷贝构造
	tmp -= day;
	return tmp;
}


// d1 - d2
//int Date::operator-(const Date& d)
//{
//	if (*this < d)
//	{
//		assert("用小日期减大日期无意义");
//		return -1;
//	}
//	int count = 0;//闰年个数
//	for (int year = d._year;year < _year;year++)
//	{
//		if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
//		{
//			count++;
//		}
//	}
//	int nums_day = 365*(_year - d._year) + count;//天数
//	int month = _month - 1;
//	int day = _day - 1;
//	for (int i = 1; i <= month; i++)
//	{
//		day += getmonthday(_year, i);
//	}
//	month = d._month - 1;
//	day -= (d._day - 1);
//	for (int i = 1; i <= month; i++)
//	{
//		day -= getmonthday(d._year, i);
//	}
//	return nums_day + day;
//}


//重载 d1 - d2
int Date::operator-(const Date& d)
{
	int flag = 1;
	Date max = *this;
	Date min = d;
	if (*this < d)
	{
		flag = -1;
		max = d;
		min = *this;
	}
	int n = 0;
	while (min != max)
	{
		++min;
		++n;
	}
	return n * flag;
}


//重载前置++
Date& Date::operator++()
{
	*this += 1;
	return *this;
}


//重载后置++
Date Date::operator++(int)
{
	Date tmp = *this;
	*this += 1;
	return tmp;
}


//重载前置--
Date& Date::operator--()
{
	*this -= 1;
	return *this;
}


//重载后置--
Date Date::operator--(int)
{
	Date tmp = *this;
	*this -= 1;
	return tmp;
}

//重载流插入
ostream& operator<<(ostream& out, const Date& d)
{
	cout << d._year << "年" << d._month << "月" << d._day << "日" << endl;
	return out;
}


//重载流提取
istream& operator>>(istream& in, Date& d)
{
	cout << "请输入年月日：";
	cin >> d._year >> d._month >> d._day;
	if (!d.CheckDate())
	{
		cout << "⽇期⾮法" << endl;
	}

	return in;
}