c++中的常用知识点总结
命名空间
使用命名空间之后，调用代码时可以省去也可以不省去相关的前缀。
#include 自定义命名空间
// 命名空间
#include 类
- 头文件：Student.h
//
// Created by sunteng on 2023/9/5.
//
#ifndef TEST_STUDENT_H
#define TEST_STUDENT_H
#endif //TEST_STUDENT_H
class Student{
private:
//下面的成员和函数，都是私有
char * name;
int age;
public:
//下面的成员和函数，都是公有
void setAge(int age);
void setName(char *name);
int getAge();
char * getName();
};
- 类文件：Student.cpp
//
// Created by sunteng on 2023/9/5.
//
#include "Student.h"
// 根据 Student.h 头文件 ，写实现
// 和实现头文件那个函数，没有任何关系，相当于另外一个函数
/*void setAge(int age) {
}*/
void Student::setAge(int age) {
//this是一个Student类型的指针
this->age = age;
}
void Student::setName(char *name) {
this->name = name;
}
int Student::getAge() {
return this->age;
}
char * Student::getName() {
return this->name;
}
- main
#include - 构造函数和析构函数
#include - 拷贝构造函数与构造函数
// 4.拷贝构造函数。
#include - 深拷贝与浅拷贝
#define _CRT_SECURE_NO_WARNINGS // strcpy运行会报错，支持
#include指针常量 常量指针 常量指针常量
// 指针常量 常量指针 常量指针常量
#include 运算符重载
// 2.类里运算符重载。
#include 二义性与虚基类
// 多继承 二义性2：
// 在真实开发过程中，严格避免出现 二义性
#include - 虚基类
在C++中，虚基类是用于解决多继承中的菱形继承问题的一种机制。菱形继承指的是一个派生类同时继承自两个或多个基类，而这些基类又共同继承自同一个基类，形成了一个菱形的继承结构。
虚基类的作用是解决菱形继承带来的二义性和冗余的问题。当一个派生类通过多条路径继承自同一个基类时，如果不使用虚基类，那么在派生类中就会存在多个基类子对象的实例，这样就会导致同名成员在派生类中出现冗余，访问这些成员时会产生二义性。
通过使用虚基类，可以确保在派生类中只有一个基类子对象的实例，从而避免了冗余和二义性。虚基类的成员在派生类中只有一份拷贝，这样就可以确保派生类对基类成员的访问是唯一的。
使用虚基类的语法是在派生类的基类列表中，将虚基类声明为虚基类。例如：
class Base {
public:
// Base类的成员
};
class Derived1 : virtual public Base {
public:
// Derived1类的成员
};
class Derived2 : virtual public Base {
public:
// Derived2类的成员
};
class Derived3 : public Derived1, public Derived2 {
public:
// Derived3类的成员
};
在上面的例子中，Base是虚基类，Derived1和Derived2都通过虚继承方式继承自Base。Derived3通过多继承同时继承自Derived1和Derived2，这样就避免了菱形继承带来的问题。
总结来说，虚基类的作用是解决多继承中的菱形继承问题，避免冗余和二义性，确保派生类对基类成员的访问是唯一的。
公有继承与私有继承
#include 静态类
// 2.C++static关键字。 正确的写法
/**
* 静态的总结：
* 1.可以直接通过类名::静态成员（字段/函数）
* 2.静态的属性必须要初始化，然后再实现（规则）
* 3.静态的函数只能取操作静态的属性和方法
*/
#include 友元类和友元函数
在C++中，友元类和友元函数是一种特殊的访问权限控制机制，允许一个类或函数访问另一个类的私有成员。
友元类（Friend Class）是指在一个类中声明另一个类为友元，从而使得被声明的类可以访问声明它为友元的类的私有成员。友元类的声明通常出现在类的定义中，例如：
class A {
friend class B; // B是A的友元类
private:
int privateData;
};
class B {
public:
void accessPrivateData(A& obj) {
int data = obj.privateData; // 可以访问A类的私有成员
}
};
在上面的例子中，类B被声明为类A的友元类，因此类B可以访问类A的私有成员privateData。
友元函数（Friend Function）是指在一个类中声明一个函数为友元，从而使得被声明的函数可以访问声明它为友元的类的私有成员。友元函数的声明通常出现在类的定义中，例如：
class A {
friend void printPrivateData(A& obj); // printPrivateData是A的友元函数
private:
int privateData;
};
void printPrivateData(A& obj) {
int data = obj.privateData; // 可以访问A类的私有成员
}
在上面的例子中，函数printPrivateData被声明为类A的友元函数，因此函数printPrivateData可以访问类A的私有成员privateData。
需要注意的是，友元类和友元函数破坏了封装性，因此应该谨慎使用。过度使用友元可能会导致代码的可维护性和可读性下降。在设计类的时候，应该优先考虑使用成员函数和访问修饰符（如public、private、protected）来实现对类成员的访问控制。只有在确实需要访问私有成员的特殊情况下，才考虑使用友元类或友元函数。
// 友元函数
// 老外：你是它的好朋友，那就可以拿私有成员给好朋友
#include 可变参数
#include this是什么——指针常量
class Worker {
public:
char * name;
int age = NULL; // C++中不像Java，Java有默认值， 如果你不给默认值，那么就是系统值 -64664
// int * const 指针常量 指针常量【地址对应的值能改，地址不可以修改】
// const int * 常量指针 常量指针【地址可以修改，地址对应的值不能改】
// 纠结：原理：为什么可以修改age
// 默认持有隐士的this【类型 * const this】
// 类型 * const 指针常量：代表指针地址不能被修改，但是指针地址的值是可以修改的
void change1() {
// 代表指针地址不能被修改
// this = 0x6546; // 编译不通过，地址不能被修改，因为是指针常量
// 地址不可以修改
// this = 0x43563;
// 隐士的this
// 但是指针地址的值是可以修改的
// 地址对应的值能改
this->age = 100;
this->name = "JJJ";
}
// 默认现在：this 等价于 const Student * const 常量指针常量（地址不能改，地址对应的值不能改）
void changeAction() const {
// 地址不能改
// this = 0x43563;
// 地址对应的值不能改
// this->age = 100;
}
// 原理：修改隐士代码 const 类型 * const 常量指针常量
void showInfo() const {
// this->name = "";
// this->age = 88;
// 只读的
cout << "age:" << age << endl;
}
};
多线程
C++ 11 之后添加了新的标准线程库 std::thread，std::thread 在 头文件中声明，因此使用 std::thread 时需要包含 在 头文件。
// 演示多线程的CPP程序
// 使用三个不同的可调用对象
#include