【C++高潮——类与对象】：类的定义，访问限定符，类域，实例化，this指针，默认成员函数，构造，析构，拷贝构造，运算符重载，类型转换，static成员，友元，内部类，匿名对象，对象拷贝编译器优化

class 类名 {
public:
    // 成员函数声明
    void 函数名();
private:
    // 成员变量声明
    int 变量名;
};

class Stack {
public:
    void Init(int n = 4) {
        array = (int*)malloc(sizeof(int) * n);
        if (nullptr == array) {
            perror("malloc申请空间失败");
            return;
        } // 成员函数
        capacity = n; // 成员变量
        top = 0;
    }
    void Push(int x) {
        // 扩容逻辑
        array[top++] = x;
    }
    int Top() {
        assert(top > 0);
        return array[top - 1];
    }
    void Destroy() {
        free(array);
        array = nullptr;
        top = capacity = 0;
    }
// public 到这都是公有的
private:
    int* array;
    size_t capacity;
    size_t top;
};

class Stack {
public:
    void Init(int n);
private:
    int* array;
    size_t capacity;
    size_t top;
};
void Stack::Init(int n) {
    array = (int*)malloc(sizeof(int) * n);
    if (nullptr == array) {
        perror("malloc申请空间失败");
        return;
    }
    capacity = n;
    top = 0;
}

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;
    int _month;
    int _day;
};
int main() {
    Date d1;
    Date d2;
    d1.Init(2024, 3, 31);
    d1.Print();
    d2.Init(2024, 7, 5);
    d2.Print();
    return 0;
}

class A {
public:
    void Print() {
        cout << _ch << endl;
    }
private:
    char _ch;
    int _i;
};
int main() {
    A a;
    cout << sizeof(a) << endl;
    return 0;
}

class Date {
public:
    void Init(int year, int month, int day) {
        this->_year = year;
        this->_month = month;
        this->_day = day;
    }
    void Print() {
        cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main() {
    Date d1;
    Date d2;
    d1.Init(2024, 3, 31);
    d1.Print();
    d2.Init(2024, 7, 5);
    d2.Print();
    return 0;
}

class stu_class {
public:
	// 1,无参数构造函数
	stu_class() {
		_grade = 3;
		_clas = 5;
	}
	// 2,全缺省构造函数
	stu_class(int grade = 3, int clas = 5) {
		_grade = grade; 
		_clas = clas;
	}
	// 3,带参数构造函数
	stu_class(int grade, int clas) 
	{
		_grade = grade;
		_clas = clas;
	}
private:
	int _grade;
	int _clas;
};

#include<iostream>
using namespace std;
class stu_class {
public:
	void stu_print() {
		cout << "grade " << _grade << " " << "class " << _clas << endl;
	}
	// 1,无参数构造函数
	stu_class() {
		_grade = 3;
		_clas = 5;
	}
	// 3,带参数构造函数
	stu_class(int grade, int clas) 
	{
		_grade = grade;
		_clas = clas;
	}
private:
	int _grade;
	int _clas;
};
int main() {
	stu_class stu1;
	stu_class stu2(6,3);
	stu1.stu_print();
	stu2.stu_print();
	return 0;
}

grade 3 class 5
grade 6 class 3

#include<iostream>
using namespace std;
class stu_class {
public:
	void stu_print() {
		cout << "grade " << _grade << " " << "class " << _clas << endl;
	}
	// 1,全缺省构造函数
	stu_class(int grade = 5, int clas = 3) {
		_grade = grade;
		_clas = clas;
	}

private:
	int _grade;
	int _clas;
};
int main() {
	stu_class stu1; // 调用全缺省
	stu_class stu2(6,3); // 给全缺省传参
	stu1.stu_print();
	stu2.stu_print();
	return 0;
}

grade 5 class 3
grade 6 class 3

#include<iostream>
using namespace std;

class stu_class {
public:
	void stu_print() {
		cout << "grade " << _grade << " " << "class " << _clas << endl;
	}
	stu_class(int grade = 5, int clas = 3) {
		_grade = grade;
		_clas = clas;
	}

private:
	int _grade;
	int _clas;
};

class two_stu {
public:
	void print() {
		stu1.stu_print();
		stu2.stu_print();
		cout << "neizhi: " << _neizhi << endl;
	}
	two_stu(int neizhi = 1) {
		_neizhi = neizhi;
	}

private:
	int _neizhi; // 内置变量
	stu_class stu1;
	stu_class stu2;
};

int main() {
	two_stu two;  
	two.print();
}

grade 5 class 3
grade 5 class 3
neizhi: 1

#include<iostream>
using namespace std;

class stu_class {
public:
	void stu_print() {
		cout << "grade " << _grade << " " << "class " << _clas << endl;
	}
	stu_class(int grade = 5, int clas = 3) {
		_grade = grade;
		_clas = clas;
	}

private:
	int _grade;
	int _clas;
};

class two_stu {
public:
	void print() {
		stu1.stu_print();
		stu2.stu_print();
		cout << "neizhi: " << _neizhi << endl;
	}

private:
	int _neizhi; // 内置变量
	stu_class stu1;
	stu_class stu2;
};

int main() {
	two_stu two;  
	two.print();
}

grade 5 class 3
grade 5 class 3
neizhi: -858993460

class Date {
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	// 上面这里是初始化列表，以 : 开头，用 , 分割变量
	// （）内是传入的用于初始化成员变量的参数
	{
		// 这是函数体
	}

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

#include<iostream>
using namespace std;
class Date {
public :
	Date(int year = 1900, int month = 9, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;
	}
//这里是声明：
private:
	int _year = 1945;
	int _month = 9;
	int _day = 2;
};

int main() {
	Date d1;
	d1.Print(); 
	Date d2(2025, 9, 3);
	d2.Print();
	return 0;
}

1900/9/1
2025/9/3

#include<iostream>
using namespace std;
class Date {
public :
	Date(int year, int month, int day = 1)
		:_month(month)
		,_day(day)
	{}

	void Print() {
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year = 1945;
	int _month = 9;
	int _day = 2;
};

int main() {
	Date d1(2000, 9, 10);
	d1.Print(); 
	Date d2(2025, 10);
	d2.Print();
	return 0;
}

class Time
{
public:
	Time(int x = 1)
	{
		_t = x;
	}
private:
	int _t;
};

class Date {
public :
	Date(int &x, int y)
		:_ref(x)  // 引用初始化，将 _ref 绑定到传入的参数 x，绑定后不能再修改
		,_t(3)   // 类类型初始化，调用 Time 类的构造函数，传入参数 y 来初始化对象 _t
		,_y(y)  // 初始化 const 类型的变量 _y，必须在初始化列表中完成，之后不能修改
	{}

private:
	int& _ref;
	Time _t;
	const int _y;
};

#include<iostream>
using namespace std;
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;
};
int main() {
    Stack s1;
    return 0;
}

#include<iostream>
using namespace std;
class Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(const 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;
};

class Stack // 假设数据都是整型
{
public:
    Stack(int n = 4)
    {
        _a = (int *)malloc(sizeof(int) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    Stack(const Stack& st) // 拷贝构造函数
    {
        _a = (int *)malloc(sizeof(int) * st._capacity); // 深拷贝
        if (nullptr == _a)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        memcpy(_a, st._a, sizeof(int) * (st._top+1));
        _top = st._top;
        _capacity = st._capacity;
    }
    ~Stack()
    {
        cout << "~Stack()" << endl;
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
    void Print() {
        cout << _capacity << endl;
    }
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};

int main() {
    Date d1(2025, 3, 8); // 构造函数初始化
    Date d2(d1);  // 拷贝构造函数初始化
    Date d3 = d2; // 这也是拷贝构造的写法
    Stack s1;
    Stack s2 = s1;
    d3.Print();
    cout << "s2的capacity: ";
    s2.Print();
    return 0;
}

2025-3-8
s2的capacity: 4
~Stack()
~Stack()

// 假如这个Print 是定义在Date类里面的
void Print() const
{
cout << _year << "-" << _month << "-" << _day << endl;
}

#include<iostream>
using namespace std;

class Date {
public:
	Date(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}
	// 定义一个运算符重载（类的成员函数可以访问私有变量）
	// 的访问控制权限是基于类本身，而非类的具体对象,所以可以访问d2
	bool operator==(Date d2){
		return _year == d2._year && _month == d2._month && _day == d2._day;
	}

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

int main() {
	Date d1(2025, 3, 8);
	Date d2(2025, 3, 9);
	cout << d1.operator==(d2) << endl;  // 输出 0
	return 0;
}

Dater& operator++()

Dater& operator++(int) // 在参数列表多加一个 int

#include<iostream>
using namespace std;

class Date {
	// 友元函数，文章后面会讲，先理解为，让这个函数可以使用private对象
	friend istream& operator>>(istream& in, Date& d); 
	friend ostream& operator<<(ostream& out, const Date& d);
public:
	Date(int year = 2025, int month = 3, int day = 1) {
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};
// 在全局重载 << 
ostream& operator<<(ostream& out, const Date&d) { // 不能修改引用对象内容
	out << d._year << "/" << d._month << "/" << d._day << endl;
	return out;
}


// 重载 >> 
istream& operator>>(istream& in, Date& d) { // 这里要插入数据，所以不能加const
	cout << "请依次输入年月日： " << endl; 
	cin >> d._year >> d._month >> d._day; 
	return in; // 返回istream类型的引用，可实现连续赋值
}

int main() {
	Date d1;
	cin >> d1;
	cout << d1;
}

请依次输入年月日：
2025 3 9
2025/3/9

#include<iostream>
using namespace std;
// 赋值运算符重载
class Stack // 假设数据都是整型
{
public:
    // 构造函数
    Stack(int capacity = 4)
    {
        _a = (int*)malloc(sizeof(int) * capacity);
        if (_a == nullptr)
        {
            perror("内存空间分配失败");
            return;
        }
        _capacity = capacity;
        _top = -1;
    }
    // 拷贝构造函数
    Stack(const Stack& st)
    {
        _a = (int*)malloc(sizeof(int) * st._capacity);
        if (_a == nullptr)
        {
            perror("内存空间分配失败");
            return;
        }
        memcpy(_a, st._a, sizeof(int) * (st._top + 1)); // 按字节一个个复制
        _capacity = st._capacity;
        _top = st._top;
    }
    // 赋值运算符重载
    Stack& operator=(const Stack& st)
    {
        free(_a); // 需要先释放之前的
        _a = (int*)malloc(sizeof(int) * st._capacity);
        if (_a == nullptr)
        {
            perror("内存空间分配失败");
            return *this;
        }
        memcpy(_a, st._a, sizeof(int) * (st._top + 1)); // 按字节一个个复制
        _capacity = st._capacity;
        _top = st._top;
        return *this; // 返回引用，支持连续赋值
    }
    ~Stack() {
        free(_a);
        _a = nullptr;
        _capacity = 0;
        _top = -1;
    }
    void Print()
    {
        cout << _capacity << endl;
    }
private:
    int* _a;
    size_t _capacity;
    size_t _top;
};
int main() {
    Stack st1(8);
    Stack st2;
    cout << "运用赋值重载之前，st2 capacity： ";
    st2.Print();
    Stack st3;
    st3 = st2 = st1;  // 赋值运算的结合率是从右往左，返回值是左操作数
    cout << "运用赋值重载之后，st2 capacity： ";
    st2.Print();
    cout << "st3 capacity： ";
    st3.Print();
    return 0;
}

运用赋值重载之前，st2 capacity： 4
运用赋值重载之后，st2 capacity： 8
st3 capacity： 8

int main() {
	Date d1;
	Date* d1_ptr = &d1;
	const Date* c_d1_ptr = &d1;
	printf("%p\n", d1_ptr);
	printf("%p", c_d1_ptr);
}

00000023F82FF5A8
00000023F82FF5A8

class A {
public:
    A(int a1) : _a1(a1) {}
    A(int a1, int a2)
        :_a1(a1)
        , _a2(a2)
    {}
private:
    int _a1 = 1;
    int _a2 = 2;
};
int main() {
    A aa1 = 1;
    A aa2 = { 2,2 };
    return 0;
}

class A {
public:
    A() { ++_scount; }
    static int GetACount() { return _scount; }
private:
    static int _scount; 
};
int A::_scount = 0; 
int main() {
    cout << A::GetACount() << endl; 
    A a1, a2;
    cout << A::GetACount() << endl; 
    return 0;
}

class A;
class B;
class A {
    friend void func(const A& aa, const B& bb);  // 友元声明，这样就可以访问A类的私有和保护成员
private:
    int _a1 = 1;
};
class B {
    friend void func(const A& aa, const B& bb);
private:
    int _b1 = 3;
};
void func(const A& aa, const B& bb) {
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

class A {
private:
    static int _k;
    int _h = 1;
public:
    class B { 
    public:
        void foo(const A& a) {
            cout << _k << endl; 
            cout << a._h << endl; 
        }
    };
};
int A::_k = 1;
int main() {
    A::B b;
    A aa;
    b.foo(aa);
    return 0;
}

class A {
public:
    A(int a = 0) : _a(a) { cout << "A(int a)" << endl; }
    ~A() { cout << "~A()" << endl; }
private:
    int _a;
};
int main() {
    A(1); 
    return 0;
}

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a1 = aa._a1;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};
void f1(A aa)
{
}
A f2()
{
	A aa;
	return aa;
}

int main()
{

	 隐式类型，连续构造+拷⻉构造->优化为直接构造
	A aa1 = 1;
	cout << endl;
	return 0;
}

A(int a)          // 1. 用 1 构造临时对象
A(const A& aa)    // 2. 用临时对象拷贝构造 aa1
~A()              // 3. 临时对象析构
                  // （此处输出换行）
~A()              // 4. main 结束时 aa1 析构

A(int a) // 只有一次构造，直接构造出aa1

~A()  // 这是打印endl之后的语句，所以是对aa1的析构