C++ 进阶

int func(int a, int b = 10, int c = 10) {
	return a + b + c;
}

//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
	return a + b;
}

int main() {
	cout << "ret = " << func(20, 20) << endl;
	cout << "ret = " << func(100) << endl;

	return 0;
}

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
	cout << "this is func" << endl;
}

int main() {
	func(10,10); //占位参数必须填补

	return 0;
}

//函数重载需要函数都在同一个作用域下
void func()
{
	cout << "func 的调用！" << endl;
}
void func(int a)
{
	cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
	cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
	cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}
//函数返回值不可以作为函数重载条件
/*
int func(double a, int b)
{
	cout << "func (double a ,int b)的调用！" << endl;
}
*/
int main() {
	func();
	func(10);
	func(3.14);
	func(10,3.14);
	func(3.14 , 10);

	return 0;
}

//圆周率
const double PI = 3.14;

//1、封装的意义
//将属性和行为作为一个整体，用来表现生活中的事物

//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名

class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main() {

	//通过圆类，创建具体的圆（对象）
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作

	//2 * pi * 10 = = 62.8
	cout << "圆的周长为： " << c1.calculateZC() << endl;

	system("pause");

	return 0;
}

class Person
{
	//姓名  公共权限
public:
	string m_Name;
	//汽车  保护权限
protected:
	string m_Car;
	//银行卡密码  私有权限
private:
	int m_Password;
public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main() {
	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	return 0;
}

class Person {
public:

	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}


	//获取年龄 
	int getAge() {
		return m_Age;
	}
	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//情人设置为只写
	void setLover(string lover) {
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	int m_Age; //只读  年龄
	string m_Lover; //只写  情人
};


int main() {

	Person p;
	//姓名设置
	p.setName("张三");
	cout << "姓名： " << p.getName() << endl;

	//年龄设置
	p.setAge(50);
	cout << "年龄： " << p.getAge() << endl;
    
	//情人设置
	p.setLover("苍井");
	//cout << "情人： " << p.m_Lover << endl;  //只写属性，不可以读取

	return 0;
}

class Person
{
public:
	//构造函数
	Person()
	{
		cout << "Person的构造函数调用" << endl;
	}
	//析构函数
	~Person()
	{
		cout << "Person的析构函数调用" << endl;
	}

};

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造
class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p); 
}

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}


int main() {

	//test01();
	//test02();
	test03();

	return 0;
}

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);
	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;
	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {
	test01();

	return 0;
}

class Person {
public:

	////传统方式初始化
	//Person(int a, int b, int c) {
	//	m_A = a;
	//	m_B = b;
	//	m_C = c;
	//}

	//初始化列表方式初始化
	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
	void PrintPerson() {
		cout << "mA:" << m_A << endl;
		cout << "mB:" << m_B << endl;
		cout << "mC:" << m_C << endl;
	}
private:
	int m_A;
	int m_B;
	int m_C;
};

int main() {
	Person p(1, 2, 3);
	p.PrintPerson();

	return 0;
}

class A {}
class B
{
    A a；
}

class Person
{
	
public:

	static int m_A; //静态成员变量

	//静态成员变量特点：
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;
	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {
	test01();

	return 0;
}

class Person {
public:
    Person(int age) {
        // 用this指针区分成员变量和形参
        this->age = age;
    }
private:
    int age;
};

class Calculator {
private:
    int num;
public:
    Calculator(int n) : num(n) {}
    
    Calculator& add(int n) {
        num += n;
        return *this;	//返回自己，给链式调用提供条件
    }
    
    Calculator& subtract(int n) {
        num -= n;
        return *this;
    }
    
    int getResult() {
        return num;
    }
};

// 使用示例
int main() {
    Calculator calc(10);
    // 链式调用
    int result = calc.add(5).subtract(3).add(2).getResult();
    // result = 14
    return 0;
}

class Person {
public:
    void compare(Person& p) {
        if (this == &p) {
            cout << "相同对象" << endl;
            return;
        }
        // 其他比较逻辑
    }
};

class MyClass {
public:
    // const成员函数中，this是指向const对象的指针
    void printData() const {
        // this的类型是const MyClass* const
        cout << "Data: " << this->data << endl;
    }
private:
    int data;
};

class MyClass {
public:
    void func1() {
        // 这里可以使用this
    }
    
    static void func2() {
        // 这里不能使用this
    }
    
    void func3() {
        auto lambda = [this]() {
            // 在lambda表达式中捕获this
            this->func1();
        };
    }
};

class MyClass {
public:
    // 返回引用，支持链式调用
    MyClass& func1() {
        return *this;
    }
    
    // 返回值，会创建新对象
    MyClass func2() {
        return *this;
    }
};

//空指针访问成员函数
class Person {
public:

	void ShowClassName() {
		cout << "我是Person类!" << endl;
	}

	void ShowPerson() {
		if (this == NULL) {
			return;
		}	//防止读取这个导致程序崩溃
		cout << mAge << endl;
	}

public:
	int mAge;
};

void test01()
{
	Person * p = NULL;
	p->ShowClassName(); //空指针，可以调用成员函数
	p->ShowPerson();  //但是如果成员函数中用到了this指针，就不可以了
}

class Person {
public:
	Person() {
		m_A = 0;
		m_B = 0;
	}

	//this指针的本质是一个指针常量，指针的指向不可修改
	//如果想让指针指向的值也不可以修改，需要声明常函数
	void ShowPerson() const {
		//const Type* const pointer;
		//this = NULL; //不能修改指针的指向 Person* const this;
		//this->mA = 100; //但是this指针指向的对象的数据是可以修改的

		//const修饰成员函数，表示指针指向的内存空间的数据不能修改，除了mutable修饰的变量
		this->m_B = 100;
	}

	void MyFunc() const {
		//mA = 10000;
	}

public:
	int m_A;
	mutable int m_B; //可修改 可变的
};


//const修饰对象  常对象
void test01() {

	const Person person; //常量对象  
	cout << person.m_A << endl;
	//person.mA = 100; //常对象不能修改成员变量的值,但是可以访问
	person.m_B = 100; //但是常对象可以修改mutable修饰成员变量

	//常对象访问成员函数
	person.MyFunc(); //常对象不能调用const的函数

}

class Building
{
	//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building * building);

public:

	Building()
	{
		this->m_SittingRoom = "客厅";
		this->m_BedRoom = "卧室";
	}


public:
	string m_SittingRoom; //客厅

private:
	string m_BedRoom; //卧室
};

class Building;
class goodGay
{
public:
	goodGay();
	void visit();
private:
	Building *building;
};

class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;

public:
	Building();
public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
	building = new Building;
}
void goodGay::visit()
{
	cout << "好基友正在访问" << building->m_SittingRoom << endl;
	cout << "好基友正在访问" << building->m_BedRoom << endl;
}
void test01()
{
	goodGay gg;
	gg.visit();
}

class Building;
class goodGay
{
public:

	goodGay();
	void visit(); //只让visit函数作为Building的好朋友，可以发访问Building中私有内容
	void visit2(); 

private:
	Building *building;
};


class Building
{
	//告诉编译器  goodGay类中的visit成员函数 是Building好朋友，可以访问私有内容
	friend void goodGay::visit();

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

// 定义 Point 类
class Point {
private:
    int x; // x 坐标
    int y; // y 坐标

public:
    // 构造函数
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 重载 + 运算符
    Point operator+(const Point& other) const {
        // 返回新的 Point 对象，其坐标为两点坐标之和
        return Point(x + other.x, y + other.y);
    }

// 定义 Point 类
class Point {
private:
    int x; // x 坐标
    int y; // y 坐标

public:
    // 构造函数
    Point(int x = 0, int y = 0) : x(x), y(y) {}

    // 友元函数：重载 << 运算符
    friend ostream& operator<<(ostream& os, const Point& point);
};

// 左移运算符重载
ostream& operator<<(ostream& os, const Point& point) {
    // 格式化输出 Point 对象
    os << "(" << point.x << ", " << point.y << ")";
    return os; // 返回流对象以支持链式操作
}

// 定义 Counter 类
class Counter {
private:
    int value; // 当前计数值

public:
    // 构造函数
    Counter(int v = 0) : value(v) {}

    // 前置递增 ++
    Counter& operator++() {
        ++value;           // 自增计数值
        return *this;      // 返回当前对象引用
    }

    // 后置递增 ++
    Counter operator++(int) {
        Counter temp = *this; // 保存当前对象状态
        ++value;              // 自增计数值
        return temp;          // 返回旧的对象
    }

};

class Person
{
public:
	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}
	//重载赋值运算符 
	Person& operator=(Person &p)
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);
		//返回自身
		return *this;
	}

	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	//年龄的指针
	int *m_Age;
};

class Point {
private:
    int x, y; // 点的坐标
public:
    // 构造函数
    Point(int x = 0, int y = 0) : x(x), y(y) {}
    // 计算平方和
    int magnitudeSquared() const {
        return x * x + y * y;
    }
    // 重载 == 运算符
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
    // 重载 != 运算符
    bool operator!=(const Point& other) const {
        return !(*this == other); // 基于 == 的实现
    }
    // 重载 < 运算符
    bool operator<(const Point& other) const {
        return magnitudeSquared() < other.magnitudeSquared();
    }
    // 重载 > 运算符
    bool operator>(const Point& other) const {
        return magnitudeSquared() > other.magnitudeSquared();
    }
};

class MyPrint
{
public:
	void operator()(string text)
	{
		cout << text << endl;
	}
};
void test01()
{
	//重载的（）操作符 也称为仿函数
	MyPrint myFunc;
	myFunc("hello world");
}

class 子类名 : 继承方式 父类名 {
    // 子类的新成员
};

class Parent {
public:
    int pub = 1;      // 公有成员
protected:
    int prot = 2;     // 保护成员
private:
    int priv = 3;     // 私有成员
};

// 公有继承 (public inheritance)
class PublicChild : public Parent {
    // 父类的public成员 -> 在子类中仍是public
    // 父类的protected成员 -> 在子类中仍是protected
    // 父类的private成员 -> 在子类中不可访问
};

// 保护继承 (protected inheritance)
class ProtectedChild : protected Parent {
    // 父类的public成员 -> 在子类中变成protected
    // 父类的protected成员 -> 在子类中仍是protected
    // 父类的private成员 -> 在子类中不可访问
};

// 私有继承 (private inheritance)
class PrivateChild : private Parent {
    // 父类的public成员 -> 在子类中变成private
    // 父类的protected成员 -> 在子类中变成private
    // 父类的private成员 -> 在子类中不可访问
};

//父类：Base，子类：Son，都有 int m_A;
cout << "Son下的m_A = " << s.m_A << endl;
cout << "Base下的m_A = " << s.Base::m_A << endl;

//父类：Base，子类：Son，有同名成员函数func()
//通过对象访问
cout << "通过对象访问： " << endl;
Son s;
s.func();
s.Base::func();
//通过类名访问
cout << "通过类名访问： " << endl;
Son::func();
Son::Base::func();
//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
Son::Base::func(100);

class Animal
{
public:
	int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

class Animal {
public:
    // 虚函数，允许在派生类中重写
    virtual void makeSound() {
        cout << "动物发出声音" << endl;
    }
    // 虚析构函数，确保正确释放内存
    virtual ~Animal() {}
};

// 派生类 Dog
class Dog : public Animal {
public:
    // 重写基类的虚函数
    void makeSound() override {
        cout << "汪汪汪！" << endl;
    }
};

// 派生类 Cat
class Cat : public Animal {
public:
    // 重写基类的虚函数
    void makeSound() override {
        cout << "喵喵喵！" << endl;
    }
};

//或者
void DoSpeak(Animal & animal)
{
	animal.makesound();
}

int main() {
    // 使用基类指针指向不同的派生类对象
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();
    
    animal1->makeSound(); // 输出：汪汪汪！
    animal2->makeSound(); // 输出：喵喵喵！
    
    //或者
    DoSpeak(dog);
    
    delete animal1;
    delete animal2;
    return 0;
}

class Base
{
public:
	virtual void func() = 0;
};

class Son :public Base
{
public:
	virtual void func() 
	{
		cout << "func调用" << endl;
	};
};

int main() {
	Base * base = NULL;
	//base = new Base; // 错误，抽象类无法实例化对象
	base = new Son;
	base->func();
	delete base;//记得销毁
    
	return 0;
}

class Animal {
public:
	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;
	virtual ~Animal() = 0;
};

Animal::~Animal()
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name <<  "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}
public:
	string *m_Name;
};

int main() {
	Animal *animal = new Cat("Tom");
	animal->Speak();
	delete animal;
	//通过父类指针去释放，会导致子类对象可能清理不干净，造成内存泄漏
	//怎么解决？给基类增加一个虚析构函数
	//虚析构函数就是用来解决通过父类指针释放子类对象
    
	return 0;
}