int array[5] = {1, 2, 3, 4, 5};
int value = array[-1];  // 未定义的行为

// 输出未定义的值
std::cout << value << std::endl;

#include <iostream>
using namespace std;
int main(){
    int a[5] = {1,3,4,5,6};
    cout << "a[0]" << a[0] << endl;
    cout << "a[4]" << a[4] << endl;
    cout << "a[5]" << a[5] << endl;
    cout << "a[-1]" << a[-1] << endl;
    cout << "a[-2]" << a[-2] << endl;
    return 0;
}

a[0]1
a[4]6
a[5]0
a[-1]0
a[-2]4199705

#include <iostream>
using namespace std;

int main(){
    int* a = new int[3];
    a[0] = 1;
    a[1] = 2;
    a[2] = 3;
    a[3] = 4;
    a[4] = 5;
    cout << a[100] << endl;     //不报错但是是危险用法；会造成不可预知的后果。
    cout << typeid(a).name() << endl;  //Pi；point
    cout << typeid(a[0]).name() << endl; //int
    cout << typeid(a[4]).name() << endl;
    cout << typeid(a[100]).name() << endl;  //int
    cout << endl;

    int b[5];
    cout << b[0] << endl;    //随机的值
    cout << b[4] << endl;    //随机的值
    cout << b[5] << endl;    //随机的值；不属于数组b
    cout << b[100] << endl;    //随机的值；不属于数组b
    cout << typeid(b).name() << endl;  //A5_i
    cout << typeid(b[0]).name() << endl; //int
    cout << typeid(b[4]).name() << endl; //int
    cout << typeid(b[100]).name() << endl;  //int
    cout << endl;

    //int c[5] = {1,2,3,4,5,6};  /越界，语法错误
    int c[5] = {1,2,3,4};
    cout << c[0] << endl;    // 1：指定的值
    cout << c[4] << endl;    // 未指定部分随机的值
    cout << c[5] << endl;    // 随机的值；不属于数组c
    cout << c[100] << endl;    // 随机的值；不属于数组c
    cout << typeid(c).name() << endl;  //A5_i
    cout << typeid(c[0]).name() << endl; //int
    cout << typeid(c[4]).name() << endl; //int
    cout << typeid(c[100]).name() << endl;  //int
    cout << endl;

    int d[] = {1,2,3,4,5,6};
    //int d[];   //错误写法，不完整的定义。
    cout << d[0] << endl;    // 1
    cout << d[5] << endl;    // 6
    cout << d[6] << endl;    // 随机的值；不属于数组d
    cout << d[100] << endl;    // 随机的值；不属于数组d
    cout << typeid(d).name() << endl;    // A6_i
    cout << typeid(d[0]).name() << endl;    //i
    cout << typeid(d[6]).name() << endl;    //i
    cout << typeid(d[100]).name() << endl;    //i

    return 0;
}

-17891602
Pi
i
i
i

8
14424176
0
0
A5_i
i
i
i

1
0
0
0
A5_i
i
i
i

1
6
24
0
A6_i
i
i
i

#include <iostream>
using namespace std;

int main(){
    //int c[5] = {1,2,3,4,5,6};  /越界，语法错误
    int c[5] = {1,2,3,4};
    int len1 = sizeof(c)/sizeof(c[0]);
    cout << len1 << endl;  //5
    cout << endl;

    int d[5] = {1,2,3,4,5};
    int len2 = sizeof(d)/sizeof(d[0]);
    cout << len2 << endl;  //5
    cout << endl;

    int a[6] = {1,2,3,4,5};
    int len3 = sizeof(a)/sizeof(a[0]);
    cout << len3 << endl;  //6
    cout << endl;

    return 0;
}

<返回值类型> 函数名(<参数类型> <参数名>,<参数类型> <参数名>,...){

	函数主体；
	return <变量/值>   //当有<返回值类型>的时候则必须有return进行返回；若无<返回值类型>的时候，则不应该有return语句。无返回值的情况只能出现在main()函数（C++特性）

}

#include <iostream>

//using namespace std;

void test(int a,int b=2,int c=3);  //若函数的定义时在被调用的地方之后；则必须在调用前组函数的前置申明（否则编译时就会报错，因为编译按顺序执行）；若有参数默认值，也应在前置申明中定义。函数的返回值与后文的函数定义中的返回值必须一致。

main(){     //我们的这个主函数即没有返回值类型，也没有参数；没有返回值类型代表函数主体中不应该出现return语句。
    test(10);
}

void test(int a,int b,int c){    //若有参数默认值，也应在前置申明中定义。不应再此处定义。
    std::cout << "test output something(a):" << a << std::endl;    //当前面的using namespace std;语句没被注释时可以省略此处的std::;若无则必须加上std::.

}

void test(int a,int b,int c){
    std::cout << "test output something(a):" << a << std::endl;
    return;   //注意此处因为返回值类型时void，所以要么此处删除return语句；要么直接些return;。即使return NULL;都不行。return NULL代表返回一个空指针。
}

#include <iostream>

void printInfo(std::string name, int age, std::string country) {
    std::cout << "Name: " << name << std::endl;
    std::cout << "Age: " << age << std::endl;
    std::cout << "Country: " << country << std::endl;
}

int main() {
    std::string name = "Alice";
    int age = 25;
    std::string country = "China";

    // 使用参数名=赋值的形式调用函数
    printInfo(name, age, country);

    //printInfo(age=30, country="USA", name="Bob");
    //这种写法在C++中错误的；

    return 0;
}

class MyClass {
public:
    int getValue() const {
        return value;
    }

    void setValue(int newValue) {
        value = newValue;
    }

private:
    int value;
};

int main() {
    const MyClass obj;  // 创建一个常量对象

    int result = obj.getValue();  // 调用常量成员函数

    // obj.setValue(10);  // 错误：常量对象无法调用非常量成员函数

    return 0;
}

class MyClass {
public:
    static void staticFunction() {
        // 执行静态函数的操作
    }

    static int staticVariable;  // 静态成员变量声明

private:
    int nonStaticVariable;
};

int MyClass::staticVariable = 0;  // 静态成员变量定义

int main() {
    MyClass::staticFunction();  // 直接通过类名调用静态函数

    MyClass::staticVariable = 10;  // 访问和修改静态成员变量

    return 0;
}

const int constantValue = 10;

int variableValue = 20;

// 修改变量的值
variableValue = 30;

#include <iostream>

int main() {
    int x = 10;
    const int& ref = x; // 常量引用
    int y = ref;

    std::cout << "x: " << x << std::endl;         // 输出：x: 10
    std::cout << "ref: " << ref << std::endl;     // 输出：ref: 10
    std::cout << "y: " << y << std::endl;     // 输出：y: 10

    x = 20; // 修改变量的值

    std::cout << "x (after modification): " << x << std::endl;         // 输出：x (after modification): 20
    std::cout << "ref (after modification): " << ref << std::endl;     // 输出：ref (after modification): 20
    std::cout << "y: " << y << std::endl;     // 输出：y: 10 <--

    // ref = 30; // 错误！无法通过常量引用修改变量的值 <--

    y = 40; // 修改变量的值

    std::cout << "x (after modification): " << x << std::endl;         // 输出：x (after modification): 20  <--
    std::cout << "ref (after modification): " << ref << std::endl;     // 输出：ref (after modification): 20  <--
    std::cout << "y: " << y << std::endl;     // 输出：y: 40 <--

    return 0;
}

#include <iostream>

// 函数定义，带有两个形参(a,b)
void addNumbers(int a, int b) {
    int sum = a + b;
    std::cout << "Sum = " << sum << std::endl;
}

int main() {
    int x = 5;
    int y = 3;

    // 函数调用，使用实参(x,y)传递给形参(a,b)
    addNumbers(x, y);

    return 0;
}

#include <iostream>

// 函数通过引用交换两个整数的值
void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5;
    int y = 10;

    std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;

    // 通过函数引用交换变量的值
    swap(x, y);

    std::cout << "After swap: x = " << x << ", y = " << y << std::endl;

    return 0;
}

int x = 42;
int* ptr = &x;  // 指针的声明和初始化
int& ref = x;   // 引用的声明和初始化

int x = 42;
int y = 10;
int* ptr = &x;
int& ref = x;

ptr = &y;  // 更改指针的指向，现在ptr指向y
ref = y;   // 修改ref所引用的变量x的值为y

void modifyByPointer(int* ptr) {
    // 通过指针修改传入的变量
    *ptr = 10;
}

void modifyByReference(int& ref) {
    // 通过引用修改传入的变量
    ref = 10;
}

int x = 42;
modifyByPointer(&x);    // 通过指针修改x的值
modifyByReference(x);   // 通过引用修改x的值

#include <iostream>
#include <typeinfo>

using namespace std;

int main(){
    int a = 5;
    int b = 10;
    char x = 'x';
    cout<<"a's vaule:"<< a << endl;
    cout<<"a's address:"<< &a << endl;
    cout<<"a's type name:"<< typeid(a).name()<<endl;
    cout<<"b's vaule:"<< b << endl;
    cout<<"b's address:"<< &b << endl;
    cout<<"b's type name:"<< typeid(b).name()<<endl;
    cout<<"x's vaule:"<< x << endl;
    cout<<"x's address:"<< &x << endl;
    cout<<"x's type name:"<< typeid(x).name()<<endl;
    cout<<"----------"<< endl;

    // int* c = a;   //错误，指针只能被赋予地址
    int* c = &a;
    cout<<"c's vaule:"<< c << endl;
    cout<<"c's address:"<< &c << endl;
    cout<<"c's type name:"<< typeid(c).name()<<endl;
    cout<<"pointer c's pointing vaule:"<< *c << endl;
    cout<<"----------"<< endl;

    c = &b;   //可以将指针c重新赋值哦；不同于ref。
    cout<<"c's vaule:"<< c << endl;
    cout<<"c's address:"<< &c << endl;
    cout<<"c's type name:"<< typeid(c).name()<<endl;
    cout<<"pointer c's vaule:"<< *c << endl;
    cout<<"----------"<< endl;

    // c = &x;    //错误写法，以为变量c被声明为整型指针，但x是char类型。error: cannot convert 'char*' to 'int*' in assignment

    int* d;
    cout<<"d's vaule:"<< d << endl;
    cout<<"d's address:"<< &d << endl;
    cout<<"d's type name:"<< typeid(d).name()<<endl;
    // cout<<"pointer d's vaule:"<< *d << endl;     //对于空指针，在这里会出错。
    cout<<"----------"<< endl;

    d = &a;
    cout<<"d's vaule:"<< d << endl;
    cout<<"d's address:"<< &d << endl;
    cout<<"d's type name:"<< typeid(d).name()<<endl;
    cout<<"pointer d's vaule:"<< *d << endl;
    cout<<"----------"<< endl;

    const int* e = &b;
    cout<<"e's vaule:"<< e << endl;
    cout<<"e's address:"<< &e << endl;
    cout<<"e's type name:"<< typeid(e).name()<<endl;
    cout<<"pointer e's vaule:"<< *e << endl;
    cout<<"----------"<< endl;

    e= &a;
    cout<<"e's vaule:"<< e << endl;
    cout<<"e's address:"<< &e << endl;
    cout<<"e's type name:"<< typeid(e).name()<<endl;
    cout<<"pointer e's vaule:"<< *e << endl;
    cout<<"----------"<< endl;

    // *e = 100;    //这种写法是错误的；因为const int* e = &b;限定了指针变量e是一个指向常量整型数据的指针；既然是指向了一个常量(本例中指向的变量a实际上不是常量，但申明指针式加上了常量的限定)，那么就不能通过任何任何性质包括*e来修改这个常量的值。



    int* const f = &b;
    cout<<"f's vaule:"<< f << endl;
    cout<<"f's address:"<< &f << endl;
    cout<<"f's type name:"<< typeid(f).name()<<endl;
    cout<<"pointer f's vaule:"<< *f << endl;
    cout<<"----------"<< endl;
    
    /*
    错误写法；因为int* const f = &b;代表变量f是常量，类型是指针；因为是常量所以不能被重新赋值。
    f = &a;
    cout<<"f's vaule:"<< f << endl;
    cout<<"f's address:"<< &f << endl;
    cout<<"f's type name:"<< typeid(f).name()<<endl;
    cout<<"pointer f's vaule:"<< *f << endl;
    cout<<"----------"<< endl;
    */

    *f = 100;
    cout<<"f's vaule:"<< f << endl;
    cout<<"f's address:"<< &f << endl;
    cout<<"f's type name:"<< typeid(f).name()<<endl;
    cout<<"pointer f's vaule:"<< *f << endl;
    cout<<"----------"<< endl;
    cout<<"b's vaule:"<< b << endl;
    cout<<"b's address:"<< &b << endl;
    cout<<"b's type name:"<< typeid(b).name()<<endl;
    cout<<"----------"<< endl;


    const int* const g = &b;
    cout<<"g's vaule:"<< g << endl;
    cout<<"g's address:"<< &g << endl;
    cout<<"g's type name:"<< typeid(g).name()<<endl;
    cout<<"pointer g's vaule:"<< *g << endl;
    cout<<"----------"<< endl;
    
    /*
    错误写法；因为const int* const g = &b;;代表变量g是常量（后一个const），类型是指针；因为是常量所以不能被重新赋值。
    g = &a;
    cout<<"g's vaule:"<< g << endl;
    cout<<"g's address:"<< &g << endl;
    cout<<"g's type name:"<< typeid(g).name()<<endl;
    cout<<"pointer g's vaule:"<< *g << endl;
    cout<<"----------"<< endl;
    */

   // *g = 200;       //这种写法是错误的；因为const int* const g = &b;的前一个const限定了指针变量g是一个指向常量整型数据的指针；既然是指向了一个常量(本例中指向的变量a实际上不是常量，但申明指针式加上了常量的限定)，那么就不能通过任何任何性质包括*e来修改这个常量的值。


}

#include <iostream>

void increment(int& num) {
    std::cout << "The value of num: " << num << std::endl;
    std::cout << "The address of num: " << &num << std::endl;
    num++;  // 对传入的num进行递增操作
}

int main() {
    int a = 10;
    std::cout << "The address of a: " << &a << std::endl;
    std::cout << "Before increment: " << a << std::endl;
    increment(a);  // 传递a的引用给increment函数
    std::cout << "After increment: " << a << std::endl;

    return 0;
}

The address of a: 0x61fe1c
Before increment: 10
The value of num: 10
The address of num: 0x61fe1c
After increment: 11

#include <iostream>
using namespace std;
int main() {
    int x = 42;
    int y = 10;
    int* ptr = &x;
    int& ref = x;
    cout << "ptr中存放的地址（这里是指x变量的内存地址）：" << ptr << endl;
    cout << "ptr存放的地址所对应的值：" << *ptr << endl;
    cout << "ref对应的地址：" << &ref << endl;
    cout << "ref代表的值：" << ref << endl;

    ptr = &y;  // 更改指针的指向，现在ptr指向y
    ref = y;   // 修改ref所引用的变量x的值为y

    return 0;
}

ptr中存放的地址（这里是指x变量的内存地址）：0x61fe0c
ptr存放的地址所对应的值：42
ref对应的地址：0x61fe0c
ref代表的值：42

int num = 10;
double result = num;   // 将整数类型隐式转换为浮点数类型

double d = 3.14;
int i = static_cast<int>(d);     // 使用静态转换将浮点数转换为整数

class Base {
    virtual void foo() {}
};
class Derived : public Base {};

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);   // 使用动态转换将基类指针转换为派生类指针

const int* constPtr = new int(42);
int* nonConstPtr = const_cast<int*>(constPtr);   // 使用常量转换去除常量性质

int value = 65;
char ch = reinterpret_cast<char>(value);   // 使用重新解释转换，将整数类型的值重新解释为字符类型

#include <iostream>
#include <string>

using namespace std;

int main(){
    int a = 10;
    double b = 3.14;
    //string c = "hello";    // "abc"、"hello"等string不能被转化为int；需要使用"123"/"oxabc"/"0b10110101"
    string c = "232";
    const int d = 20;

    //强制类型转化
    cout << "---转换前---" << endl;
    cout << "变量a的类型是：" << typeid(a).name() << ";值为：" << a << endl;
    cout << "变量b的类型是：" << typeid(b).name() << ";值为：" << b << endl;
    cout << "变量c的类型是：" << typeid(c).name() << ";值为：" << c << endl;
    cout << "变量d的类型是：" << typeid(d).name() << ";值为：" << d << endl;

    cout << endl;
    cout << "---开始转换---" << endl;
    double aa = a;    //隐式转化 implicit type conversion；  int -> double
    int bb = static_cast<int>(b);       //显式转换  explicit type conversion； double -> int
    int cc = std::stoi(c);              //显式转换; string -> int;注意这里如果c是不能转换为int的字符串是程序会闪退。
    string dd = std::to_string(d);      //显式转换; int -> string



    cout << endl;
    cout << "---转换后---" << endl;
    cout << "变量aa的类型是：" << typeid(aa).name() << ";值为：" << aa << endl;
    cout << "变量bb的类型是：" << typeid(bb).name() << ";值为：" << bb << endl;
    cout << "变量cc的类型是：" << typeid(cc).name() << ";值为：" << cc << endl;
    cout << "变量dd的类型是：" << typeid(dd).name() << ";值为：" << dd << endl;
    return 0;
}

---转换前---
变量a的类型是：i;值为：10
变量b的类型是：d;值为：3.14
变量c的类型是：NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;值为：232
变量d的类型是：i;值为：20

---开始转换---

---转换后---
变量aa的类型是：d;值为：10
变量bb的类型是：i;值为：3
变量cc的类型是：i;值为：232
变量dd的类型是：NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE;值为：20

const int* e;  // e是指向常量整型数据的指针

int num = 10;
e = #      // 允许将指向非常量的地址赋给指针
int value = *e;  // 允许读取被指向的整型数据

// 不允许通过指针修改被指向的数据
*e = 20;        // 错误，尝试修改常量数据会导致编译错误

int* const e;  // e是一个常量指针，它的值在初始化后就不能再改变

int num1 = 10;
int num2 = 20;
e = &num1;     // 初始化指针，使其指向num1
*e = 30;       // 修改被指向的整型数据

// 不允许修改指针本身的值
e = &num2;     // 错误，尝试修改常量指针的值会导致编译错误

condition ? expression1 : expression2

#include <iostream>
using namespace std;

int main() {
    int num = 10;
    string message;

    // 使用条件运算符根据条件赋值
    message = (num > 0) ? "Positive number" : "Negative number or zero";

    cout << message << endl;  // 输出: Positive number

    return 0;
}

if (条件表达式) {
    // 如果条件为真，执行的代码
} else {
    // 如果条件为假，执行的代码
}

int num = 10;
if (num > 0) {
    cout << "num是正数" << endl;
} else {
    cout << "num是负数或零" << endl;
}

switch (表达式) {
    case 值1:
        // 执行的代码
        break;
    case 值2:
        // 执行的代码
        break;
    default:
        // 执行的代码（可选）
}

int dayOfWeek = 1;
switch (dayOfWeek) {
    case 1:
        cout << "星期一" << endl;
        break;
    case 2:
        cout << "星期二" << endl;
        break;
    case 3:
        cout << "星期三" << endl;
        break;
    default:
        cout << "其他星期几" << endl;
}

#include <iostream>
using namespace std;

int main() {
    int x = 2;

    switch (x) {
        case 1:
            cout << "x 等于 1" << endl;
        case 2:
            cout << "x 等于 2" << endl;
        case 3:
            cout << "x 等于 3" << endl;
        default:
            cout << "默认情况" << endl;
    }
    
    return 0;

}

x 等于 2
x 等于 3
默认情况

for (初始化表达式; 条件表达式; 更新表达式) {
    // 循环体代码
}

for (int i = 0; i < 5; i++) {
    cout << i << endl;
}

while (条件表达式) {
    // 循环体代码
}

int i = 0;
while (i < 5) {
    cout << i << endl;
    i++;
}

do {
    // 循环体代码
} while (条件表达式);

int i = 0;
do {
    cout << i << endl;
    i++;
} while (i < 5);

#include <iostream>

using namespace std;

void test(int a, int b){
    cout<<"i'm test001 function"<<endl;

}

/*
仅仅参数名的不同不能构成与test001构成重载；编译时会报错。
void test(int c, int d){
    cout<<"i'm test002 function"<<endl;

}
*/


/*
多出来的参数因为有指定默认值，导致砸调用时程序无法确定使用的是哪个test函数；因此这种写法也不能正确构成与test001的重载。
在函数调用时会产生二义性。
void test(int a, int b, int c=100){
    cout<<"i'm test003 function"<<endl;

}
*/


void test(int a, int b, int c){
    cout<<"i'm test004 function"<<endl;

}

void test(int a, char b, int c){
    cout<<"i'm test005 function"<<endl;

}


int main(){
    int x = 10;
    int y = 20;
    test(x, y);
    test(x, y, 50);
    test(x, 'b', 50);

    return 0;
}

#include <iostream>
using namespace std;

void print(int num) {
    cout << "Printing an integer: " << num << endl;
}

void print(double num) {
    cout << "Printing a double: " << num << endl;
}

int main() {
    int a = 5;
    double b = 3.14;

    print(a); // 调用print(int)
    print(b); // 调用print(double)

    return 0;
}

Printing an integer: 5
Printing a double: 3.14

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() {
        cout << "Drawing a shape." << endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a rectangle." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle." << endl;
    }
};

int main() {
    Shape* shapePtr = nullptr;

    Rectangle rectangle;
    Circle circle;

    // 使用基类指针调用派生类对象的覆盖函数;特别注意，这是实现多态的基础之一。
    shapePtr = &rectangle;
    shapePtr->draw();  // 输出: Drawing a rectangle.

    shapePtr = &circle;
    shapePtr->draw();  // 输出: Drawing a circle.

    return 0;
}

Drawing a rectangle.
Drawing a circle.

#include <iostream>
using namespace std;

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

class Derived : public Base {
public:
    void func() {
        cout << "Derived::func()" << endl;
    }
};

int main() {
    Base base;
    Derived derived;

    Base* ptr = &base;
    ptr->func(); // 输出: Base::func()

    ptr = &derived;
    ptr->func(); // 输出: Base::func()

    derived.func(); //输出：Derived::func()
    return 0;
}

// 类的声明
class MyClass {
private:
    int myData;

public:
    // 函数的声明
    void setData(int data);   //函数主体虽然在类的外部定义；但是在类体中必须要有改函数的原型申明。
    int getData();
};

// 在类体外定义函数
// 注意格式：<返回类型> <类名>::<函数名>(参数类型 参数名){ 函数定义；}
void MyClass::setData(int data) {   
    myData = data;
}

int MyClass::getData() {
    return myData;
}

// 主函数
int main() {
    MyClass obj;
    obj.setData(42);
    int value = obj.getData();
    // 输出结果
    cout << "Value: " << value << endl;
    
    return 0;
}

// 内联函数的定义与声明
inline int add(int a, int b) {
    return a + b;
}

int main() {
    // 调用内联函数
    int result = add(3, 4);
    return 0;
}

// 外联函数的声明
int multiply(int a, int b);

// 外联函数的定义
int multiply(int a, int b) {
    return a * b;
}

int main() {
    // 调用外联函数
    int result = multiply(3, 4);
    return 0;
}

// 使用点号访问成员的示例
MyClass obj;
obj.memberVar = 42;      // 设置对象的成员变量
int value = obj.memberVar;     // 获取对象的成员变量的值

obj.memberFunc();        // 调用对象的成员函数

// 使用指针访问成员的示例
MyClass* ptr = new MyClass();   // 创建指向对象的指针

ptr->memberVar = 42;     // 设置指针指向的对象的成员变量
int value = ptr->memberVar;    // 获取指针指向的对象的成员变量的值

ptr->memberFunc();      // 调用指针指向的对象的成员函数

delete ptr;     // 释放之前动态分配的对象内存

class MyClass {
public:
    int publicVar;     // 公有成员变量
    void publicFunc()  // 公有成员函数
    {
        // 访问公有、私有和受保护成员
        publicVar = 1;
        privateVar = 2;
        protectedVar = 3;
    }

private:
    int privateVar;    // 私有成员变量

protected:
    int protectedVar;  // 受保护成员变量
};

int main() {
    MyClass obj;
    obj.publicVar = 1;     // 可以直接访问公有成员
    obj.publicFunc();      // 可以调用公有成员函数

    // 下面的代码将无法编译，因为私有成员无法在类外部直接访问
    // obj.privateVar = 2;
    // obj.protectedVar = 3;

    return 0;
}

class MyClass {
private:
    int privateVar;

public:
    MyClass(int value) : privateVar(value) {}

    // 友元函数声明
    friend void friendFunc(MyClass& obj);
};

// 友元函数的定义
void friendFunc(MyClass& obj) {
    // 可以直接访问私有成员
    obj.privateVar = 10;
}

int main() {
    MyClass obj(5);

    // 调用友元函数来修改私有成员的值
    friendFunc(obj);

    return 0;
}

#include <iostream>

class MyClass {
private:
    int privateData;

public:
    // 构造函数
    MyClass(int data) : privateData(data) {};

    // 友元函数的声明
    friend void FriendFunction(MyClass obj);
    friend void test(int a);
    friend void test1(int a, MyClass obj);
};

// 友元函数的定义
void FriendFunction(MyClass obj) {
    std::cout << "访问私有成员 privateData: " << obj.privateData << std::endl;
}

// 友元函数的定义
void test(int a){
    std::cout << "输出参数a: " << a << std::endl;
}

// 友元函数的定义
void test1(int a, MyClass obj){
    std::cout << "输出参数a: " << a << std::endl;
    std::cout << "[修改前]访问私有成员 privateData: " << obj.privateData << std::endl;
    std::cout << "修改私有成员 privateData"  << std::endl;
    obj.privateData = a;
    std::cout << "[修改后]访问私有成员 privateData: " << obj.privateData << std::endl;
}

int main() {
    MyClass obj(42);
    FriendFunction(obj);

    test(1);
    test1(100, obj);

    return 0;
}

访问私有成员 privateData: 42
输出参数a: 1
输出参数a: 100
[修改前]访问私有成员 privateData: 42
修改私有成员 privateData
[修改后]访问私有成员 privateData: 100

#include <iostream>

using namespace std;

class A{
private:
    int A_data;

public:
    //狗杂函数
    A(int a):A_data(100){};

    friend class B;      //申明class B为本类的友元类


    void show(){
        std::cout << "私有成员 A_data: " << A_data << std::endl;
    }


};


class B{
public:
    void test01(A obj){
        std::cout << "[修改前]访问私有成员 A_data: " << obj.A_data << std::endl;
        std::cout << "修改私有成员 A_data"  << std::endl;
        obj.A_data = 200;
        std::cout << "[修改后]访问私有成员 privateData: " << obj.A_data << std::endl;
    }


    void test02(A obj){
        std::cout << "[修改前]访问私有成员 A_data: " << obj.A_data << std::endl;
        std::cout << "修改私有成员 A_data"  << std::endl;
        obj.A_data = 300;
        std::cout << "[修改后]访问私有成员 privateData: " << obj.A_data << std::endl;
    }

};




int main(){
    A myobj(10);
    B f_myobj;

    f_myobj.test01(myobj);
    std::cout << "\n \n"  << std::endl;
    f_myobj.test01(myobj);
    std::cout << "\n \n"  << std::endl;

    myobj.show();
    std::cout << "\n \n"  << std::endl;

    return 0;
}

[修改前]访问私有成员 A_data: 100
修改私有成员 A_data
[修改后]访问私有成员 privateData: 200



[修改前]访问私有成员 A_data: 100
修改私有成员 A_data
[修改后]访问私有成员 privateData: 200



私有成员 A_data: 100

#include <iostream>

using namespace std;

class A;
//class B;  //类B的前向申明；为了规避在A中使用到B时，B还没有被申明的报错问题。（若将class B定义在Class A前就不需要了）

class B{  //****将B的申明或定义放在类A之前；为了防止在类A中申明类B的成员函数作为自己的友元时找不懂类B或类B的成员函数
public:
    void test(int data, A obj);   //***成员函数的申明；为什么定义不放在这里呢？    //这里用到A；需要是事先申明A。
    /*
    ****错误写法；因为此时，编译器还不知道test()成为了B的友元函数；本函数体重用到的B的私有变量都将时非法的。
    void B::test(int data, A obj){
        std::cout << "[修改前]访问私有成员 a: " << obj.a << std::endl;
        std::cout << "修改私有成员 a"  << std::endl;
        obj.a = data;
        std::cout << "[修改后]访问私有成员 a: " << obj.a << std::endl;
    }
    */

};

class A{
private:
    int a = 10;
    friend void B::test(int data, A obj);    //在A中申明B类中的test()函数时本类(A)的友元函数

};


//在此处定义类B的成员函数test();此时，编译器已经知道了类A的存在并且，也知道了类A中定义了在自己作为其友元。
void B::test(int data, A obj){
    std::cout << "[修改前]访问私有成员 a: " << obj.a << std::endl;
    std::cout << "修改私有成员 a"  << std::endl;
    obj.a = data;
    std::cout << "[修改后]访问私有成员 a: " << obj.a << std::endl;
}


int main() {
    A objA;
    B objB;
    
    objB.test(20, objA); // 调用B的test函数来修改A的私有成员
    
    return 0;
}

[修改前]访问私有成员 a: 10
修改私有成员 a
[修改后]访问私有成员 a: 20

#include <iostream>
#include <string>

using namespace std;

class myclass{
private:
    string name = "xiamingliang";
    int age = 18;
    string location = "China";
    myclass(){  //构造函数不能有返回值类型；否则编译会报错。
        string name = "xiaml";
    };

public:
    void showinfo(){
        cout<<"My name is:"<< name <<endl;
        cout<<"My age is:"<< age <<endl;
    }
};


int main(){
    myclass me;    //这里会在编译时报错；因为构造函数被定义为private，那么在myclass类的外部无法访问构造函数myclass()。

    return 0;
}

#include <iostream>
#include <string>

using namespace std;

class myclass{
private:
    string name = "xiamingliang";
    int age = 18;
    string location = "China";


public:
    myclass(){  //构造函数不能有返回值类型；否则编译会报错。
        string name = "xiaml";
        cout<<"构造函数执行，设定变量name为："<< name <<endl;
    };

    void showinfo(){
        cout<<"My name is:"<< name <<endl;
        cout<<"My age is:"<< age <<endl;
    }
};


int main(){
    myclass me;
    me.showinfo();    
    /*输出
    构造函数执行，设定变量name为：xiaml
    My name is:xiamingliang
    My age is:18
    
    似乎构造函数对name的初始化没有生效。
     */

    return 0;
}

class MyClass {
public:
    // 公共构造函数
    MyClass() {
        // 构造函数的实现
    }

    // 公共成员函数
    void PublicFunction() {
        // 执行操作
    }

    // 静态方法，提供访问私有构造函数的途径
    static MyClass* CreateInstance() {
        return new MyClass();
    }

private:
    // 私有构造函数
    MyClass(int arg) {
        // 构造函数的实现
    }

    // 友元函数，提供访问私有构造函数的途径
    friend MyClass* CreateInstanceWithArg(int arg);
};

// 友元函数定义，用于创建对象
MyClass* CreateInstanceWithArg(int arg) {
    return new MyClass(arg);
}

ConstructorName() : member1(value1), member2(value2), ... {
    // 构造函数体
}

#include <iostream>
#include <string>

using namespace std;

class myclass{
private:
    string name = "xiamingliang";
    int age = 18;
    string location = "China";


public:
    myclass(){  //构造函数不能有返回值类型；否则编译会报错。
        name = "xiaml";
        cout<<"构造函数A执行，设定变量name为："<< name <<endl;
    };

    myclass(string nnn){  //构造函数不能有返回值类型；否则编译会报错。
        name = nnn;
        cout<<"构造函数B执行，设定变量name为："<< name <<endl;
    };

    myclass(int aaa):name("arthur"),age(100){  //构造函数不能有返回值类型；否则编译会报错。
        age = aaa;
        cout<<"构造函数C执行，设定变量name为："<< name <<endl;
    };
    
    myclass(string* aaa,int* bbb){  //构造函数不能有返回值类型；否则编译会报错。
        name = *aaa;
        age = *bbb;
        cout<<"构造函数D执行，设定变量name为："<< name <<endl;
    };

    void showinfo(){
        cout<<"My name is:"<< name <<endl;
        cout<<"My age is:"<< age <<endl;
    }
};


int main(){
    myclass me1;
    me1.showinfo();
    /*
    构造函数A执行，设定变量name为：xiaml
	My name is:xiaml
	My age is:18
	*/

    myclass me2("xml");
    me2.showinfo();
    /*
    构造函数B执行，设定变量name为：xml
	My name is:xml
	My age is:99
	*/
    
    myclass me3(99);
    me3.showinfo();
    /*
    构造函数B执行，设定变量name为：arthur
	My name is:arthur
	My age is:99
	*/

    string n = "xxx";
    int a = 99;
    myclass me4(&n, &a);
    me4.showinfo();
    /*
    构造函数C执行，设定变量name为：xxx
	My name is:xxx
	My age is:99
	*/


    return 0;
}

ClassName(const ClassName& other)

class Person {
public:
    std::string name;
    int age;

    // 构造函数
    Person(const std::string& name, int age) : name(name), age(age) {}

    // 复制构造函数
    Person(const Person& other) : name(other.name), age(other.age) {}
};

Person person1("Alice", 25);
Person person2 = person1;  // 调用复制构造函数创建person2作为person1的副本

std::cout << "Name: " << person2.name << ", Age: " << person2.age << std::endl;

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass obj;   // 创建对象

    std::cout << "you can do anything here." << std::endl;   //到这里都不会销毁obj也不会执行MyClass的析构函数
    
    //delete obj;  //这样写时错误的；因为obj不是通过new语句创建的，因此不能手动删除;词条语句在编译时会报错
    return 0;   // 如果没有delete语句删除obj对象的情况下，程序执行到此处时，对象obj将自动被销毁，析构函数自动调用；
}

Constructor called
you can do anything here.
Destructor called

#include <iostream>
#include <typeinfo>
#include <string>

class MyClass {
public:
    std::string myname = "xiamingliang";
    MyClass() {
        std::cout << "Constructor called" << std::endl;
    }

    void test() {
        std::cout << "i'm still alive." << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass* obj = new MyClass();   // 创建对象或者MyClass* obj = new MyClass
    std::cout << "obj's mem address:"<< &obj << std::endl; 
    std::cout << "obj's type:"<< typeid(obj).name() << std::endl; 
    std::cout << "obj's size:"<< sizeof(obj) << std::endl; 

    std::cout << "you can do anything here." << std::endl;   //到这里都不会销毁obj也不会执行MyClass的析构函数
    obj->test();
    //obj.test();   //使用new创建的对象，调用其成员函数时不应使用点号；而应该使用->。

    std::cout << "obj's var myname's value:"<< obj->myname << std::endl;
    
    delete obj; // 有delete语句删除obj对象的情况下，程序执行到此处时，对象obj将被销毁，析构函数被调用。
    obj->test();     //本示例中的析构函数主要是用来清理类的成员变量的；清理后（即使我们的析构函数没有清理的语句）
    std::cout << "obj's var myname's value:"<< obj->myname << std::endl;  //清理后（即使我们的析构函数没有清理的语句）;这里会报错（编译不会报错，执行时会报错）

    return 0;   // new语句创建的对象没有delete语句删除obj对象的情况下，程序执行到此处时，对象obj不会被自动被销毁，析构函数不会被调用；
}

Constructor called
obj's mem address:0x61fe08
obj's type:P7MyClass
obj's size:8
you can do anything here.
i'm still alive.
obj's var myname's value:xiamingliang
Destructor called
i'm still alive.
obj's var myname's value:

#include <iostream>
#include <typeinfo>
#include <string>

class MyClass {
private:
    int myInt;  // 非指针类型的成员变量
    double myDouble;
    
public:
    int* myptr; // 指针类型的成员变量
    //myptr = new int;     //C++不允许直接在类体中对动态内存分配函数欸i指针变量分配内存，需要在构造函数行完成
    //*myptr = 10;
    std::string myname = "xiamingliang";    // 非指针类型的成员变量
    MyClass() {
        myptr = new int;   //初始化放在这里就不会报错
        *myptr = 10;   //初始化放在这里就不会报错
        std::cout << "Constructor called" << std::endl;
    }

    void test() {
        std::cout << "i'm still alive." << std::endl;
    }

    ~MyClass() {
        //delete myname;    //删除对象中的非指针类型变量会在编译时出错
        //delete myInt;
        delete myptr;    //删除对象中的指针类型变量是允许的。
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass* obj = new MyClass();   // 创建对象或者MyClass* obj = new MyClass
    std::cout << "obj's mem address:"<< &obj << std::endl; 
    std::cout << "obj's type:"<< typeid(obj).name() << std::endl; 
    std::cout << "obj's size:"<< sizeof(obj) << std::endl; 

    std::cout << "you can do anything here." << std::endl;   //到这里都不会销毁obj也不会执行MyClass的析构函数
    obj->test();
    //obj.test();   //使用new创建的对象，调用其成员函数时不应使用点号；而应该使用->。

    std::cout << "obj's var myname's value:"<< obj->myname << std::endl;
    std::cout << "obj's type:"<< typeid(obj->myname).name() << std::endl; 
    std::cout << "obj's size:"<< sizeof(obj->myname) << std::endl; 
    std::cout << "obj's var myptr's value:"<< *(obj->myptr)<< std::endl;
    std::cout << "obj's type:"<< typeid(obj->myptr).name() << std::endl; 
    std::cout << "obj's size:"<< sizeof(obj->myptr) << std::endl; 
    
    delete obj;     // 有delete语句删除obj对象的情况下，程序执行到此处时，对象obj将被销毁，析构函数被调用。
    obj->test();     //本示例中的析构函数主要是用来清理类的成员变量的；清理后（即使我们呢的析构函数没有清理的语句）
    std::cout << "obj's var myname's value:"<< obj->myname << std::endl;  //清理后（即使我们的析构函数没有清理的语句）;这里会报错（编译不会报错，执行时会出现意外）
    //系统自动清理
    std::cout << "obj's var myptr's value:"<< *(obj->myptr)<< std::endl;   //清理后（即使我们的析构函数没有清理的语句）;这里会报错（编译不会报错，执行时出错）
    //析构函数中手动执行删除语句

    return 0;   // new语句创建的对象没有delete语句删除obj对象的情况下，程序执行到此处时，对象obj不会被自动被销毁，析构函数不会被调用；
}

Constructor called
obj's mem address:0x61fe08
obj's type:P7MyClass
obj's size:8
you can do anything here.
i'm still alive.
obj's var myname's value:xiamingliang
obj's type:NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
obj's size:32
obj's var myptr's value:10
obj's type:Pi
obj's size:8
Destructor called
i'm still alive.
obj's var myname's value:                         <==此处出现意外并卡住

int* p = new int;       // 分配一个整型变量的内存空间
delete p;               // 释放所分配的内存空间

int* p = (int*)malloc(sizeof(int));    // 分配一个整型变量的内存空间
free(p);                               // 释放所分配的内存空间

#include <iostream>

class MyClass {
public:
    static int staticVar;
    //static int staticVar = 10; //静态不允许这里进行初始化，需要在构造函数中进行。
    int a = 10;

    MyClass(){
        staticVar = 10;
    }

};

int MyClass::staticVar = 20; // 初始化静态成员变量,注意必须制指明类型

int main() {
    std::cout << "Value of staticVar after modifications: " << MyClass::staticVar << std::endl; 

    MyClass objA;
    MyClass objB;

    objA.staticVar = 30; // 通过对象A修改静态成员变量的值
    std::cout << "Value of staticVar after modifications: " << MyClass::staticVar << std::endl; 

    objB.staticVar = 40; // 通过对象B修改静态成员变量的值
    std::cout << "Value of staticVar after modifications: " << MyClass::staticVar << std::endl; 
    // 输出：Value of staticVar after modifications: 30

    MyClass objC;
    objB.staticVar = 50; // 通过对象B修改静态成员变量的值
    std::cout << "Value of staticVar after modifications: " << MyClass::staticVar << std::endl; 
    
    return 0;
}

Value of staticVar after modifications: 20
Value of staticVar after modifications: 30
Value of staticVar after modifications: 40
Value of staticVar after modifications: 50

#include <iostream>

class MyClass {
public:
    static int count; // 静态成员变量
    int a = 5;

    static void printCount() { // 静态成员函数
        count = 10;
        // a = 15;     //这里写法是错误的，静态成员函数不能访问非静态资源
        std::cout << "Count: " << count << std::endl;
    }
};

int MyClass::count = 20; // 静态成员变量的定义和初始化

int main() {
    std::cout << "Count: " << MyClass::count << std::endl;     //输出20

    MyClass::count = 30; // 直接使用类名访问静态成员变量
    std::cout << "Count: " << MyClass::count << std::endl;     //输出30

    MyClass::printCount(); // 直接使用类名调用静态成员函数        //输出10

    return 0;
}

Count: 20
Count: 30
Count: 10

class MyClass {
public:
    static void function1() {
        std::cout << "Function 1" << std::endl;
        function2(); // 调用类的另一个静态成员函数
    }

    static void function2() {
        std::cout << "Function 2" << std::endl;
    }
};

int main() {
    MyClass::function1(); // 调用类的静态成员函数

    return 0;
}

Function 1
Function 2

#include <iostream>

class myclass{
private:
    int a = 10;
    static int b;

public:
    int c = 100;
    static int d;
    myclass(){
        b=20;    //【不建议此处初始化static变量】
        d=200;    //【不建议此处初始化static变量】
    }

    void static func01(){
        std::cout<< "我是函数finc01;我是静态的。" << std::endl;
        std::cout<< "尝试调用静态func02" << std::endl;
        func02();
        std::cout<< "尝试调用非静态func03(不能调用，语法错误)" << std::endl;
        //func03();       //这里编译时会失败报错，因为C++允许静态成员函数访问非静态的资源
        std::cout<< "尝试访问非静态变量a(不能访问，语法错误)" << std::endl;
        //std::cout<< "尝试访问非静态变量a:" << a << std::endl;  //这里编译时会失败报错，因为C++允许静态成员函数访问非静态的资源
        std::cout<< "尝试访问静态变量b:" << b << std::endl;
        
    }


    static void func02(){
        std::cout<< "我是函数finc02;我是静态的。" << std::endl;

    }


    void func03(){
        std::cout<< "我是函数finc02;我是非静态的。" << std::endl;
        std::cout<< "尝试访问非静态变量a(可以访问)" << std::endl;
        std::cout<< "尝试访问非静态变量a:" << a << std::endl; 
    }

};

//int myclass::d = 30;  //初始化
int myclass::d;       //或仅仅申明以下也可以;默认初始化为0【非常重要，必须申明】
int myclass::b;       //私有变量也需要申明；否则语法不报错，但编译和调试过不了。【非常重要，必须申明】


int main(){
    std::cout<< "----------静态变量----------"<< std::endl;
    //std::cout<< "在外部尝试访问非静态变量a:"<< myclass::a << std::endl;    //不能通过类名访问非静态资源;在类外不能访问类的private资源
    //std::cout<< "在外部尝试访问静态变量b:"<< myclass::b << std::endl;      //在类外不能访问类的private资源
    //std::cout<< "在外部尝试访问非静态变量c:"<< myclass::c << std::endl;      //不能通过类名访问非静态资源
    std::cout<< "在外部尝试访问静态变量d:"<< myclass::d << std::endl;       //没有初始化或者申明的话会在编译期间报错哦


    std::cout<< "----------静态函数(类名访问)----------"<< std::endl;
    //直接使用类名
    myclass::func01();
    //myclass::func03();       //不能通过类名访问非静态资源


    std::cout<< "----------静态函数(对象名访问)----------"<< std::endl;
    //通过类的对象名
    myclass obj;
    obj.func01(); 
    obj.func03();


    std::cout<< "----------静态函数(对象名访问_动态内存分配)----------"<< std::endl;
    //通过new创建的对象指针访问
    myclass* myptr = new myclass();
    std::cout<< "尝试访问非静态变量c:"<< myptr->c << std::endl;
    std::cout<< "尝试访问静态变量d:"<< myptr->d << std::endl;

    myptr->func01();
    myptr->func03();

    delete myptr;     //不要忘记这里。


    return 0;
}

我是函数finc01;我是静态的。
尝试调用静态func02
我是函数finc02;我是静态的。
尝试调用非静态func03(不能调用，语法错误)
尝试访问非静态变量a(不能访问，语法错误)
尝试访问静态变量b:0
----------静态函数(对象名访问)----------
我是函数finc01;我是静态的。
尝试调用静态func02
我是函数finc02;我是静态的。
尝试调用非静态func03(不能调用，语法错误)
尝试访问非静态变量a(不能访问，语法错误)
尝试访问静态变量b:20
我是函数finc02;我是非静态的。
尝试访问非静态变量a(可以访问)
尝试访问非静态变量a:10
----------静态函数(对象名访问_动态内存分配)----------
尝试访问非静态变量c:100
尝试访问静态变量d:200
我是函数finc01;我是静态的。
尝试调用静态func02
我是函数finc02;我是静态的。
尝试调用非静态func03(不能调用，语法错误)
尝试访问非静态变量a(不能访问，语法错误)
尝试访问静态变量b:20
我是函数finc02;我是非静态的。
尝试访问非静态变量a(可以访问)
尝试访问非静态变量a:10

void someFunction() {
    const int x = 10;
    // 此时x为常量，不能被修改
}

const double PI = 3.14159;
// PI为常量，其值在程序执行期间不能被修改

class MyClass {
public:
    static const int MAX_VALUE = 100;
    // MAX_VALUE为类MyClass的常量成员
};

const int x = 10;
int *ptr = &x; // 错误，将常量的地址赋给指针

*ptr = 20; // 错误，尝试通过指针修改常量的值

const int *ptr = &x;
*ptr = 20; // 错误，尝试通过指针修改常量的值

static const int x = 10;

class MyClass {
public:
    void foo() const {
        // 该函数不能修改对象的成员变量
        // 只能访问成员变量的值
        // 或调用其他常量成员函数（除非成员变量被声明为可变 mutable）
    }

    int getValue() const;  // 声明一个常量成员函数
};

int MyClass::getValue() const {
    // 实现一个常量成员函数
    // 不能修改成员变量的值
    // 只能返回成员变量的值或计算结果
}

const int getValue();  // 函数返回类型是常量 int

class MyClass {
public:
    void foo() const;  // 声明一个常量成员函数
};

void MyClass::foo() const {
    // 实现一个常量成员函数
    // 不能修改非可变成员变量
}

#include <iostream>
#include <string>

using namespace std;

class test{
private:
    int a = 10;
    string b = "aaa";
    //static int c = 20;    //错误，类中的静态变量不能在此赋值。
    static int c;           //默认值：0
    const int d = 30;       //常量不设置初始值会有语法错误。
    const int e;           //必须初始化，要么在此处直接赋值，要么通过构造函数的初始化列表进行初始化。初始化列表优先级较高
    const int f = 50;
    const string g;       //字符串类的常量不用给出初始值
    const string h = "hello world";
    mutable int i;
    mutable string  j = "aaa";

public:
    test():e(40),f(500),h("hello"){   //初始化列表中不能初始化static变量
        a = 100;
        b = "bbbb";
        c = 200;         //【不建议此处初始化static】静态变量不能仅在此赋值（此处可以赋值也可以省略，即使在此处赋值也要配合在类体外仅限申明），编辑器不报错，但是无法通过编译。
        //c在此处的优先级
        //d = 300;       //常量的值不能修改
        //e = 400；        //不能在这里赋值修改
        //h = "world";    //常量的值不能修改
    };

    void show(){
        cout << "----------const变量----------"<< endl;
        cout << "变量a的值是：" << a << endl;
        cout << "变量b的值是：" << b << endl;
        cout << "变量c的值是：" << c << endl;
        cout << "变量d的值是：" << d << endl;
        cout << "变量e的值是：" << e << endl;
        cout << "变量f的值是：" << f << endl;
        cout << "变量g的值是：" << g << endl;
        cout << "变量h的值是：" << h << endl;
    };

    //const定义返回值性质
    const int giveme_an_umber(){
        cout << "----------const类型返回值的函数----------"<< endl;
        int x = 5;
        return x;
    };

    // const类型返的函数,不能修改非可变成员变量 radius
    void show2() const {
        cout << "----------const类型返的函数----------"<< endl;
        cout << "[修改前]int变量a的值是：" << a << endl;
        //a = 121212;      //错误写法；因为变量a不是mutable类型的
        cout << "不能修改，语法错误" << endl;

        cout << "[修改前]string变量b的值是：" << b << endl;
        //b = "abcabc";    //错误写法；因为变量a不是mutable类型的
        cout << "不能修改，语法错误" << endl;

        cout << "[修改前]mutable int变量i的值是：" << i << endl;
        i = 1010;
        cout << "[修改后]mutable int变量i的值是：" << i << endl;

        cout << "[修改前]mutable string变量j的值是：" << j << endl;
        j = "bbb";
        cout << "[修改后]mutable string变量j的值是：" << j << endl;


    };


};

int test::c;      //[重要]类中的静态变量需要在类的外部进行申明或者初始化。如果为必须操作；但此处的赋值优先级要低于在构造函数中赋值。（构造函数中的赋值要加上此处的申明才不会导致编译错误；此处为必须，构造函数中可选，但是构造函数的中赋值的优先级更高）
//int test::c = 11111;    //[重要]这样也可以，但是赋值的优先级较低

int main(){
    test obj;
    obj.show();
    /*
    变量a的值是：100
    变量b的值是：bbbb
    变量c的值是：200
    变量d的值是：30
    变量e的值是：40
    变量f的值是：500
    变量g的值是：
    变量h的值是：hello
    */



    int obj_a = obj.giveme_an_umber();
    cout << "变量obj_a的类型是：" << typeid(obj_a).name() << endl;
    cout << "变量obj_a是否是const类型(取决于obj_a被创建时指定的类型)：" << is_const<decltype(obj_a)>::value << endl;
    /*
    ----------const类型返回值的函数----------
    变量obj_a的类型是：i
    变量obj_a是否是const类型：0
    */


    obj.show2();
    /*
    ----------const类型返的函数----------
    [修改前]int变量a的值是：100
    不能修改，语法错误
    [修改前]string变量b的值是：bbbb
    不能修改，语法错误
    [修改前]mutable int变量i的值是：24
    [修改后]mutable int变量i的值是：1010
    [修改前]mutable string变量j的值是：aaa
    [修改后]mutable string变量j的值是：bbb
    */

    return 0;
}

----------const变量----------
变量a的值是：100
变量b的值是：bbbb
变量c的值是：200
变量d的值是：30
变量e的值是：40
变量f的值是：500
变量g的值是：
变量h的值是：hello
----------const类型返回值的函数----------
变量obj_a的类型是：i
变量obj_a是否是const类型(取决于obj_a被创建时指定的类型)：0
----------const类型返的函数----------
[修改前]int变量a的值是：100
不能修改，语法错误
[修改前]string变量b的值是：bbbb
不能修改，语法错误
[修改前]mutable int变量i的值是：24
[修改后]mutable int变量i的值是：1010
[修改前]mutable string变量j的值是：aaa
[修改后]mutable string变量j的值是：bbb

class A {	// 类A的定义
	public:
		void f(B b);	// 以类B对象为形参的成员函数
};
class B {	// 类B的定义
	public:
		void g(A a);	// 以类A对象为形参的成员函数
}

class MyClass {
    int x;  // 默认为 private
    void foo();  // 默认为 public
};

Class obj;
obj.memberVariable;     // 访问对象的成员变量
obj.memberFunction();   // 调用对象的成员函数

Class* ptr = new Class();
ptr->memberVariable;       // 访问对象的成员变量
ptr->memberFunction();     // 调用对象的成员函数
delete ptr;                // 释放动态分配的对象内存

Class& ref = existingObj;
ref.memberVariable;        // 访问对象的成员变量
ref.memberFunction();      // 调用对象的成员函数

void Class::memberFunction() {
    this->memberVariable;     // 使用 this 指针访问对象的成员变量
    this->anotherFunction();  // 使用 this 指针调用对象的另一个成员函数
}

#include <iostream>
#include <string>
using namespace std;

//成员类;像subclass这种被其他类作为其变量类型或者函数返回值类型的类叫做成员类
class subclass{
private:
    int s_a;
    const int s_b = 10;
    static int s_c;

public:
    int pub_s_a = 100;
    const int pub_s_b = 200;
    static int pub_s_c;
    void showdata_1(){
        cout << "----------我是subclass的showdata_1()----------" << endl;
        cout << "变量s_a的值：" << s_a << endl;
        cout << "变量s_b的值：" << s_b << endl;
        cout << "变量s_c的值：" << s_c << endl;
        cout << "变量pub_s_a的值：" << pub_s_a << endl;
        cout << "变量pub_s_b的值：" << pub_s_b << endl;
        cout << "变量pub_s_c的值：" << pub_s_c << endl;
    }

    static void showdata_2(){
        cout << "----------我是subclass的showdata_2()----------" << endl;
        //cout << "变量s_a的值：" << s_a << endl;
        //cout << "变量s_b的值：" << s_b << endl;
        cout << "变量s_c的值：" << s_c << endl;
        //cout << "变量pub_s_a的值：" << pub_s_a << endl;
        //cout << "变量pub_s_b的值：" << pub_s_b << endl;
        cout << "变量pub_s_c的值：" << pub_s_c << endl;
    }
};

//主类;像mainclass这种成员变量的类型或者成员函数的返回值是subclass类；那么mainclass类就是主类
class mainclass{
private:
    int m_a;
    const int m_b =100;
    static int m_c;
    subclass test;

public:
    void test_use_subclass(){
        cout << "----------我是mainclass的test_use_subclass()----------" << endl;
        cout << "#尝试访问对象成员subclass的private变量#(语法错误)" << endl;
        cout << "#尝试访问对象成员subclass的public变量#" << endl;
        cout << "变量pub_s_a的值：" << test.pub_s_a << endl;
        cout << "变量pub_s_b的值：" << test.pub_s_b << endl;
        cout << "变量pub_s_c的值：" << test.pub_s_c << endl;
        cout << "变量pub_s_c的值：" << subclass::pub_s_c << endl;
        cout << "#尝试访问对象成员subclass的函数#(普通public函数)" << endl;
        test.showdata_1();
        cout << "#尝试访问对象成员subclass的函数#(static函数_实例访问)" << endl;
        test.showdata_2();
        cout << "#尝试访问对象成员subclass的函数#(static函数_静态访问)" << endl;
        subclass::showdata_2();
    }
};

int subclass::s_c;            //必须；被用到的静态变量都需要进行申明。
int subclass::pub_s_c;        //必须；被用到的静态变量都需要进行申明。
//mainclass::m_c为什么不用申明?因为在整个变量创建后整个程序中没有再用到这个变量。

int main(){
    cout << "----------1.通过mainclass执行----------" << endl;
    mainclass mainobj;
    mainobj.test_use_subclass();
    cout << "\n \n" << endl;

    subclass subobj;
    cout << "----------2.直接通过subclass执行----------" << endl;
    subclass::showdata_2();
    cout << "#尝试访问对象成员的public变量#" << endl;
    cout << "变量pub_s_a的值：" << subobj.pub_s_a << endl;
    cout << "变量pub_s_b的值：" << subobj.pub_s_b << endl;
    cout << "变量pub_s_c的值：" << subobj.pub_s_c << endl;
    cout << "变量pub_s_c的值：" << subclass::pub_s_c << endl;
    cout << "#尝试访问对象成员的函数#(普通public函数)" << endl;
    subobj.showdata_1();
    cout << "#尝试访问对象成员的函数#(static函数)" << endl;
    subobj.showdata_2();
    cout << "#尝试访问对象成员的函数#(static函数)" << endl;
    subclass::showdata_2();

    return 0;
}

----------1.通过mainclass执行----------
----------我是mainclass的test_use_subclass()----------
#尝试访问对象成员subclass的private变量#(语法错误)
#尝试访问对象成员subclass的public变量#
变量pub_s_a的值：100
变量pub_s_b的值：200
变量pub_s_c的值：0
变量pub_s_c的值：0
#尝试访问对象成员subclass的函数#(普通public函数)
----------我是subclass的showdata_1()----------
变量s_a的值：42
变量s_b的值：10
变量s_c的值：0
变量pub_s_a的值：100
变量pub_s_b的值：200
变量pub_s_c的值：0
#尝试访问对象成员subclass的函数#(static函数_实例访问)
----------我是subclass的showdata_2()----------
变量s_c的值：0
变量pub_s_c的值：0
#尝试访问对象成员subclass的函数#(static函数_静态访问)
----------我是subclass的showdata_2()----------
变量s_c的值：0
变量pub_s_c的值：0



----------2.直接通过subclass执行----------
----------我是subclass的showdata_2()----------
变量s_c的值：0
变量pub_s_c的值：0
#尝试访问对象成员的public变量#
变量pub_s_a的值：100
变量pub_s_b的值：200
变量pub_s_c的值：0
变量pub_s_c的值：0
#尝试访问对象成员的函数#(普通public函数)
----------我是subclass的showdata_1()----------
变量s_a的值：8
变量s_b的值：10
变量s_c的值：0
变量pub_s_a的值：100
变量pub_s_b的值：200
变量pub_s_c的值：0
#尝试访问对象成员的函数#(static函数)
----------我是subclass的showdata_2()----------
变量s_c的值：0
变量pub_s_c的值：0
#尝试访问对象成员的函数#(static函数)
----------我是subclass的showdata_2()----------
变量s_c的值：0
变量pub_s_c的值：0

#include <iostream>

using namespace std;

class outerclass{
private:
    int o_a = 10;
    //innerclass o_obj;     //语法错误，系统认为未定义；需要定义在内层类的定义之后。
    //innerclass& o_obj;     //不允许，系统认为未定义；需要定义在内层类的定义之后。

public:
    int o_b = 20;

    void o_test01(){
        cout << "----------我是outerclass的o_test01()----------" << endl;
    }

    void o_test02(){
        cout << "----------我是outerclass的o_test02()----------" << endl;
        //innerclass in_obj;   //不允许
        //innerclass& in_obj;   //引用变量需要初始化
        
        innerclass innerObj(*this); // 创建内层类对象  ；从外层类的访问内层类的方法1：实例+this指针
        cout << "[from outer]访问内层类的函数i_test01():"<< endl;
        innerObj.i_test01();     // 调用内层类的方法
        //cout << "访问内层类的变量: " << innerObj.i_a << endl;      //不能直接访问私有变量；这对于内层类来所；外层类属于类外。
        cout << "[from outer]访问内层类的变量: " << innerObj.i_b << endl;


    }


    class innerclass{
    private:
        int i_a = 100;
        //outerclass i_obj;        //语法错误，不允许这样做。在 innerclass 中试图声明一个 outerclass 对象的成员变量是不允许的，因为内部类对象的创建必须依赖于外部类对象的存在。
        outerclass& ref_obj;       //使用引用的方式为外层对象取别名
        
    public:
        int i_b = 200;
        int i_c = 300;
        int i_d = i_a + i_b + i_c;
        //构造函数；配合上面的outerclass& ref_obj;使用
        innerclass(outerclass& obj) : ref_obj(obj) {//在构造函数中初始化引用;若没有此句，在 innerclass 构造函数中就没有初始化这个引用，导致无法使用它访问 outerclass 成员。
        
        }

        //cout << "123" << endl;      //错误写法：在 innerclass 内部的构造函数之外，直接在类体中编写代码是非法的。
        //cout << "在innerclass中尝试访问outerclass的变量"<< ref_obj.o_a  << endl; //错误写法：在 innerclass 内部的构造函数之外，直接在类体中编写代码是非法的。

        void i_test01(){
            cout << "----------我是innerclass的i_test01()----------" << endl;
            cout << "----------访问outerclass资源from inner----------" << endl;
            cout << "[from inner]private变量o_a：" << ref_obj.o_a << endl;
            cout << "[from inner]public变量o_b：" << ref_obj.o_b << endl;
            cout << "[from inner]调用outerclass函数：o_test01()" << endl;
            ref_obj.o_test01();
        }

    };

    /*
    innerclass o_obj;       //从外层类的访问内层类的方法2：实例
    void o_test03(){
        cout << "----------我是outerclass的o_test03()----------" << endl;
        cout << "[from outer]访问内层类的变量: " << o_obj.i_b << endl;
    }
    */

   /*
   innerclass& o_obj;      //从外层类的访问内层类的方法3:引用
   void o_test03(){
        cout << "----------我是outerclass的o_test03()----------" << endl;
        cout << "[from outer]访问内层类的变量: " << o_obj.i_b << endl;
    }
    */

    
};

int main(){
    outerclass main_obj;
    main_obj.o_test02();

    return 0;
}

----------我是outerclass的o_test02()----------
[from outer]访问内层类的函数i_test01():
----------我是innerclass的i_test01()----------
----------访问outerclass资源from inner----------
[from inner]private变量o_a：10
[from inner]public变量o_b：20
[from inner]调用outerclass函数：o_test01()
----------我是outerclass的o_test01()----------
[from outer]访问内层类的变量: 200

#include <iostream>

class OuterClass {
public:
    void OuterMethod();

    class InnerClass;  // ***内层类的声明***

    int o_a = 10;
};

class OuterClass::InnerClass {   //在外层类的类体之外定义内层类
public:
    void InnerMethod() {
        std::cout << "调用内层类的方法" << std::endl;
    }

    int i_a = 100;
};

void OuterClass::OuterMethod() {
    std::cout << "调用外层类的方法" << std::endl;

    InnerClass innerObj;
    innerObj.InnerMethod();

    std::cout << "访问内层类的变量: " << innerObj.i_a << std::endl;
}

int main() {
    OuterClass obj;
    obj.OuterMethod();

    return 0;
}

#include <iostream>

using namespace std;

class A{
private:
    int a = 10;

public:
    class B;
    
    void test1(){     //为啥要放在类体外定义呢？
        int a =100;
        cout << "----------我是outer class的test1()----------" << endl;
        cout << "print 'local var:a' is:" << a << endl;
        cout << "print 'global var:a' is:" << this->a << endl;
        cout << "----------我是outer class的test1(),现在调用outer class的test2()----------" << endl;
        test2();
        cout << "----------调用完成,回到outer class的test1()----------" << endl;
    }

    void test2(){
        int a =200;
        cout << "----------我是test2()----------" << endl;
        cout << "print 'local var:a' is:" << a << endl;
        cout << "print 'global var:a' is:" << this->a << endl;
        cout << "----------退出test2()----------" << endl;

    }

    void test3();

};


class A::B{
private:
    int a = 222;

public:
    void showvar(){
        int a = 333;
        cout << "----------我是inner class B的showvar()----------" << endl;
        cout << "print 'local var:a' is:" << a << endl;
        cout << "print 'global var:a' is:" << this->a << endl;
        cout << "----------现在调用outer class B的test2()----------[无法调用]" << endl;
        cout << "----------现在调用inner class B的showvar2()----------" << endl;
        this->showvar2();
        cout << "----------调用完成,回到inner class B的showvar()----------" << endl;
    }

    void showvar2(){
        int a =444;
        cout << "----------我是inner class B的showvar2()----------" << endl;
        cout << "print 'local var:a' is:" << a << endl;
        cout << "print 'global var:a' is:" << this->a << endl;
        cout << "----------退出inner class B的showvar2()----------" << endl;

    }


};


//在类体外；A::B::showvar()定义之后进行定义
void A::test3(){     //为啥要放在类体外定义呢？
    int a =300;
    cout << "----------我是outer class的test3(),现在调用inner class B的showvar()----------" << endl;
    B testobj;
    testobj.showvar();      //因为如果在类体中定义，那么此处调用B的showvar()因为在B中尚未完成定义（仅做了申明），会导致系统找不到这个函数。
    //因此，需要将调用尚未完成定义的函数的函数放在被调用函数之后。所以上面的问题其实不是为什么要放在类体外定义的问题，而是需要将调用函数放在被调用函数定义之后的问题。


}


int main(){
    A obj;
    obj.test1();
    cout << "\n\n" << endl;

    obj.test3();

    return 0;
}

----------我是outer class的test1()----------
print 'local var:a' is:100
print 'global var:a' is:10
----------我是outer class的test1(),现在调用outer class的test2()----------
----------我是test2()----------
print 'local var:a' is:200
print 'global var:a' is:10
----------退出test2()----------
----------调用完成,回到outer class的test1()----------



----------我是outer class的test3(),现在调用inner class B的showvar()----------
----------我是inner class B的showvar()----------
print 'local var:a' is:333
print 'global var:a' is:222
----------现在调用outer class B的test2()----------[无法调用]
----------现在调用inner class B的showvar2()----------
----------我是inner class B的showvar2()----------
print 'local var:a' is:444
print 'global var:a' is:222
----------退出inner class B的showvar2()----------
----------调用完成,回到inner class B的showvar()----------

#include <iostream>

using namespace std;

class A{
private:
    int a = 10;
    static int b;

public:
    A(){
        A::b = 20; 
    };

    void test1(){
        cout << "直接访问变量a：" << a << endl;
        cout << "直接访问变量b：" << b << endl;
        cout << "通过this指针访问变量this->a：" << this->a << endl;
        cout << "(不建议)通过this指针访问变量this->b：" << this->b << endl;
        cout << "通过::访问变量A::a：" << A::a << endl;
        cout << "通过::访问变量A::b：" << A::b << endl;
    }


    void static test2(){
        //cout << "直接访问变量a：" << a << endl;     //静态函数只能访问静态的变量或函数
        cout << "直接访问变量b：" << b << endl;
        //cout << "通过this指针访问变量this->a：" << this->a << endl;   //静态函数只能访问静态的变量或函数；且this不能在静态函数中使用
        //cout << "(不建议)通过this指针访问变量this->b：" << this->b << endl;   //静态函数只能访问静态的变量或函数；且this不能在静态函数中使用
        //cout << "通过::访问变量A::a：" << A::a << endl;   //静态函数只能访问静态的变量或函数
        cout << "通过::访问变量A::b：" << A::b << endl;
    }

};

int A::b;


int main(){
    A obj;
    obj.test1();

    cout << "\n \n" << endl;

    obj.test2();

    return 0;
}

直接访问变量a：10
直接访问变量b：20
通过this指针访问变量this->a：10
(不建议)通过this指针访问变量this->b：20
通过::访问变量A::a：10
通过::访问变量A::b：20



直接访问变量b：20
通过::访问变量A::b：20

#include <iostream>
using namespace std;

class Parent {
public:
    int parentVar;

    void parentFunc() {
        cout << "Parent Function" << endl;
    }

};

class Child : public Parent {
public:
    void childFunc() {
        this->parentVar = 10;  // 访问父类成员变量
        this->parentFunc();   // 访问父类成员函数
    }
};

int main() {
    Child childObj;
    childObj.childFunc();

    return 0;

}

#include <iostream>

using namespace std;

//基类
class base{
public:
    base(){
        base_d = 40;
        base_f = 60;
    }

private:
    int base_a = 10;
    static const int base_b = 20;    //注意这列static和const一起用其实不是合理的用法；虽然本实例主张不会报错，但在某些情况下会导致链接错误的发生。

    void base_pri_test01(){
        cout << "我是父类base的private类型函数:base_pri_test01()" << endl;
    }

    void base_pri_write(){
        cout << "我会写作..." << endl;
    }

public:
    int base_c = 30;
    static int base_d;

    void base_pub_test01(){
        cout << "我是父类base的public类型函数:base_pub_test01()" << endl;
    }

    void base_pub_football(){
        cout << "我会踢足球..." << endl;
    }

    void reloadfun(){  //测试父子类函数重载
        cout << "我是父类base的public类型函数:reloadfun()" << endl;
    }


protected:
    int base_e = 50;
    static int base_f;

    void base_pro_test01(){
        cout << "我是父类base的protected类型函数:base_pro_test01()" << endl;
    }

    void base_pro_coding(){
        cout << "我会编程..." << endl;
    }

    void samefun(){  //测试父子类同名函数问题
        cout << "我是父类base的protected类型函数:samefun()" << endl;
    }

};


class subA:base{
private:
    int subA_a = 210;

public:
    void sub_pub_music(){
        cout << "子类subA爱好：音乐" << endl;
    }

    //可以在派生类最终使用基类的全部成员
    void test(){
        //cout << "[禁止]使用基类的private变量base_a：" << base_a << endl;  //父类的private成员不能直接被子类访问；需要通过父类的函数接口间接访问。
        cout << "使用基类的public变量base_c：" << base_c << endl;
        cout << "使用基类的protected变量base_e：" << base_e << endl;
        cout << "[禁止]使用基类的private函数：base_pri_write()" << endl;
        //base_pri_write();     //父类的private成员不能直接被子类访问；需要通过父类的函数接口间接访问。
        cout << "使用基类的public函数：base_pub_football()" << endl;
        base_pub_football();
        cout << "使用基类的protected函数：base_pro_coding()" << endl;
        base_pro_coding();
    }

    void samefun(){   //测试父子类同名函数问题
        cout << "我是子类subA的Public类型函数:samefun()" << endl;
    }

};


class subB:public base{
private:
    int subA_a = 310;

public:
    void sub_pub_moive(){
        cout << "子类subB爱好：电影" << endl;
    }

    void reloadfun(int x){  //测试父子类函数重载
        cout << "我是父类base的protected类型函数:reloadfun()" << endl;
    }
};


class subC:private base{
private:
    int subA_a = 410;

public:
    void sub_pub_food(){
        cout << "子类subA爱好：美食" << endl;
    }
};

class subD:protected base{
private:
    int subA_a = 510;

public:
    void sub_pub_game(){
        cout << "子类subA爱好：游戏" << endl;
    }
};


int base::base_d;
int base::base_f;



int main(){
    base baseobj;
    subA subobj_a;
    subB subobj_b;
    subC subobj_c;
    subD subobj_d;

    cout << "----------父类base----------" << endl;
    //baseobj.base_pri_write();         //语法错误：类的私有成员在类外不允许访问。
    baseobj.base_pub_test01();
    //baseobj.base_pro_coding();        //语法错误：类的受保护成员在类外不允许访问。

    cout << "----------子类subA(default:private)----------" << endl;
    //subobj_a.base_pub_test01();         //禁止访问：默认的private关键字将从父类继承过来的public和protected成员变成自己的private成员。
    //subobj_a.base_pro_coding();         //禁止访问：默认的private关键字将从父类继承过来的public和protected成员变成自己的private成员。
    subobj_a.sub_pub_music();
    cout << "测试子类中访问父类不同访问修饰符的成员" << endl;
    subobj_a.test();
    cout << "测试父子类中同名函数访问" << endl;
    subobj_a.samefun();
    


    cout << "----------子类subB(public)----------" << endl;
    subobj_b.base_pub_football();
    //subobj_b.base_pro_coding();          //禁止访问：public关键字将从父类继承过来的public变成自己的Public成员；父类的protected和private成员仍旧是protected和private成员。
    subobj_b.sub_pub_moive();
    cout << "测试父子类函数的重载（继承中被子类覆盖）" << endl;
    /* 需要使用到虚函数实现多态；若不使用虚函数则父子函数同名但参数不太不能构成重载；他们之间互相独立（也就是分片） */
    // subobj_b.reloadfun(); //错误写法，实际上只会调用subB子类的reloadfun()函数；胡ibei检查到参数不符合要求
    subobj_b.reloadfun(1);
    baseobj.reloadfun();

    cout << "----------子类subC(private)----------" << endl;
    //subobj_c.base_pub_football();            //禁止访问：默认的private关键字将从父类继承过来的public和protected成员变成自己的private成员。
    //subobj_c.base_pro_coding();          //禁止访问：默认的private关键字将从父类继承过来的public和protected成员变成自己的private成员。
    subobj_c.sub_pub_food();

    cout << "----------子类subD(protected)----------" << endl;
    //subobj_d.base_pub_football();             //禁止访问：protected关键字将从父类继承过来的public成员变成自己的protectede成员;父类的protected和private成员仍旧是protected和private成员。
    //subobj_d.base_pro_coding();             //禁止访问：protected关键字将从父类继承过来的public成员变成自己的protectede成员;父类的protected和private成员仍旧是protected和private成员。
    subobj_d.sub_pub_game();
    

    return 0;
}

----------父类base----------
我是父类base的public类型函数:base_pub_test01()
----------子类subA(default:private)----------
子类subA爱好：音乐
测试子类中访问父类不同访问修饰符的成员
使用基类的public变量base_c：30
使用基类的protected变量base_e：50
[禁止]使用基类的private函数：base_pri_write()
使用基类的public函数：base_pub_football()
我会踢足球...
使用基类的protected函数：base_pro_coding()
我会编程...
测试父子类中同名函数访问
我是子类subA的Public类型函数:samefun()
----------子类subB(public)----------
我会踢足球...
子类subB爱好：电影
测试父子类函数的重载（继承中被子类覆盖）
我是父类base的protected类型函数:reloadfun()
我是父类base的public类型函数:reloadfun()
----------子类subC(private)----------
子类subA爱好：美食
----------子类subD(protected)----------
子类subA爱好：游戏

class派生类名: 继承方式说明符 基类名1, 继承方式说明符 基类名2..., 继承方式说明基类名n
{
	类体

}

派生类名::派生类名(参数表): 基类名1(基类1 初始化参数表),...,基类名m(基类m初始化参数表),成员对象名1(成员对象1 初始化参数表)..,成员对象名n(成员对象n 初始化参数表)
{
	类构造函数函数体         //其他初始化操作
}

#include<iostream>

using namespace std;

class CBase {
protected:
    int n;
public:
    CBase(int i): n(i) {}
    void print() {
        cout << "CBase:n = " << n << endl;
    }
};
class CDerived: public CBase {
public:
    int v;
    CDerived(int i): CBase(i), v(2 * i) {}
    void Func() {};
    void print() {
        cout << "CDerived:n=" << n << endl;
        cout << "CDerived:v=" << v << endl;
    }
};


int main() {
    CDerived objDerived(3);
    CBase objBase(5);
    CBase * pBase = &objDerived;    // 使用基类指针指向派生类对象
    CDerived *pDerived;
    pDerived = &objDerived;
    cout << "使用派生类指针调用函数" << endl;
    pDerived -> print();    // 调用的是派生类中的函数
    pBase = pDerived;   // 基类指针 = 派生类指针，正确
    cout << "使用基类指针调用函数" << endl;
    pBase -> print();   // 调用的是基类中的函数
    //pBase -> Func()   // 错误，通过基类指针不能调用派生类函数
    //pDerived = pBase; // 错误，派生类指针=基类指针
    pDerived = (CDerived*)pBase;    // 强制类型转换，派生类指针=基类指针
    cout << "使用派生类指针调用函数" << endl;
    pDerived -> print();    // 调用的是派生类中的函数
    return 0;
}

#include <iostream>

using namespace std;

class base{
public:
    int a = 10;
    int b = 20;
    void test1(){
        cout << "I'm base class func: test1()." << endl;
    }

    void test2(){
        cout << "I'm base class func: test2()." << endl;
    }

};


class sub: public base{
public:
    int c = 30;
    int d = 40;
    void test1(){
        cout << "I'm sub class func: test1()." << endl;
    }

    void test3(){
        cout << "I'm sub class func: test3()." << endl;
    }

};



int main(){
    base baseobj;    //创建父类base对象
    sub subobj;      //创建子类sub的对象
    cout << "baseobj对象的地址：" << &baseobj << endl;
    cout << "subobj对象的地址：" << &subobj << endl;
    cout << "\n \n" << endl;


    base* pbase;     //创建base类指针变量;不建议这种写法，这种写法会导致未经初始化的指针变量的值是不确定的；建议写成：base* pbase = nullptr; 
    sub* psub;       //创建sub类指针变量
    cout << "指针变量的pbase的值：" << pbase << endl;
    //cout << "指针变量的pbase指向的值：" << *pbase << endl;     //非法语句；不能对未赋值的指针变量进行解引用
    cout << "指针变量的psub的值：" << psub << endl;
    //cout << "指针变量的psub指向的值：" << *psub << endl;     //非法语句；不能对未赋值的指针变量进行解引用
    cout << "\n \n" << endl;


    base* pbase1 = nullptr;     //创建base类指针变量,并设置为空指针。
    sub* psub1 = nullptr;       //创建sub类指针变量,并设置为空指针。
    cout << "指针变量的pbase1的值：" << pbase1 << endl;
    //cout << "指针变量的pbase1指向的值：" << *pbase1 << endl;     //非法语句；不能对空指针变量进行解引用
    cout << "指针变量的psub1的值：" << psub1 << endl;
    //cout << "指针变量的psub1指向的值：" << *psub1 << endl;     //非法语句；不能对空指针变量进行解引用
    if(pbase1 == nullptr){
        cout << "指针变量的pbase1是空指针" << endl;
    }else{
        cout << "指针变量的pbase1的值：" << pbase1 << endl;
    }
    cout << "\n \n" << endl;


    pbase1 = &baseobj;
    psub1 = &subobj;
    cout << "指针变量的pbase1的值(成员变量)：" << pbase1->a << endl;
    cout << "指针变量的pbase1的值(成员函数)：" << endl;
    pbase1->test1();
    pbase1->test2();
    cout << "指针变量的psub1的值(成员变量)：" << psub1->a << endl;
    cout << "指针变量的psub1的值(成员变量)：" << psub1->c << endl;
    cout << "指针变量的psub1的值(成员函数)：" << endl;
    psub1->test1();
    psub1->test2();
    psub1->test3();
    cout << "\n \n" << endl;

    pbase1 = &subobj;        //基类的指针可以指向派生类对象
    //psub1 = &baseobj;        //派生类的指针不能指向基类对象
    cout << "指针变量的pbase1的值(成员变量)：" << pbase1->a << endl;
    cout << "指针变量的pbase1的值(成员函数)：" << endl;
    pbase1->test1();
    pbase1->test2();
    //pbase1->test3();         //即使base类型指针变量pbase指向了派生类的对象；但依旧不能使用base类中没有但是派生类中有的资源。
    //cout << "指针变量的pbase1的值(派生类独有成员变量)：" << pbase1->c << endl;    //即使base类型指针变量pbase指向了派生类的对象；但依旧不能使用base类中没有但是派生类中有的资源。



    return 0;
}

baseobj对象的地址：0x61fdf8
subobj对象的地址：0x61fde0



指针变量的pbase的值：0x10
指针变量的psub的值：0xd81890



指针变量的pbase1的值：0
指针变量的psub1的值：0
指针变量的pbase1是空指针



指针变量的pbase1的值(成员变量)：10
指针变量的pbase1的值(成员函数)：
I'm base class func: test1().
I'm base class func: test2().
指针变量的psub1的值(成员变量)：10
指针变量的psub1的值(成员变量)：30
指针变量的psub1的值(成员函数)：
I'm sub class func: test1().
I'm base class func: test2().
I'm sub class func: test3().



指针变量的pbase1的值(成员变量)：10
指针变量的pbase1的值(成员函数)：
I'm base class func: test1().
I'm base class func: test2().

#include <iostream>

using namespace std;

template <class X>
void myswap(X& a, X& b){
    X temp = a;
    a = b;
    b = temp;
}


int main(){
    int x = 10;
    int y = 100;
    cout << "交换前x=" << x << ";y=" << y << endl;
    myswap(x, y);           // 实例化函数模板swap，并交换x和y的值
    cout << "交换后x=" << x << ";y=" << y << endl;


    string ss = "hello";
    string tt = "xiamingliang";
    cout << "交换前ss=" << ss << ";tt=" << tt << endl;
    myswap(ss, tt);           // 实例化函数模板swap，并交换ss和tt的值
    cout << "交换后ss=" << ss << ";tt=" << tt << endl;


    return 0;
}

交换前x=10;y=100
交换后x=100;y=10
交换前ss=hello;tt=xiamingliang
交换后ss=xiamingliang;tt=hello

#include <iostream>

template <class X1, typename X2, typename X3>       //可以使用关键字typename(推荐)或class来声明模板参数。它们在语义上是等价的，可以互换使用。
void myfunction(X1& a, X2& b, X3& c){
    std::cout << "a的值是：" << a << std::endl;
    std::cout << "b的值是：" << b << std::endl;
    std::cout << "c的值是：" << c << std::endl;
}

template <typename A, typename B>
void test01(A a, B b){
    std::cout << "您输入的a是：" << a << std::endl;
    std::cout << "您输入的b是：" << b << std::endl;
}

int main(){
    {   //用大括号将使用相同名字的变量分割为不通的作用域；防止出现编译错误。
        std::string x = "hello";
        int y = 100;
        float z = 1.224356;
        myfunction(x, y, z);
    }

    {
        int x = 10;
        int y = 500;
        std::string z = "xiamingliang";
        myfunction(x, y, z);
    }
    
    {
        int x = 999;
        double y = 3.22345678;
        test01<int, double>(x, y);
        test01<int>(x, y);    //可以省略后面的类型；显式指定模板参数类型为int。这样，函数模板会被实例化为处理int类型的参数，并输出相应的结果。
        //test01<,double>(x, y);       //不能省略前面的类型
        test01(x, y);       //但可以全部省略

    }
    

    return 0;
}

a的值是：hello
b的值是：100
c的值是：1.22436
a的值是：10
b的值是：500
c的值是：xiamingliang
您输入的a是：999
您输入的b是：3.22346
您输入的a是：999
您输入的b是：3.22346
您输入的a是：999
您输入的b是：3.22346

template <typename T>
class 类模板名{
	类体... ...

}；

template <typename T>
class 类模板名{
	类体... ...
    
    返回值类型 成员函数名(参数表);          //外部定义的函数的申明

};
    
    
template <typename T>
返回值类型 类模板名<模板参数标识符列表>::成员函数名(参数表){
    函数体… …
}

类模板名 <模板参数表> 对象名1, ..., 对象名n;

类模板名 <模板参数表> 对象名1(构造函数实参), ..., 对象名n(构造函数实参);

#include <iostream>
#include <iomanip> // 包含这个头文件用于设置输出精度和格式。

using namespace std;

template <typename T>
class test{
    public:
        T list[10];   //定义一个长度为10的数组，数组元素的类型是T。
        T testfunc(int i);     //申明一个名为testfunc的函数，该函数需要一个整型的参数i；该函数运行完成后将返回一个类型为T的返回值。

};



template <typename T>
T test<T>::testfunc(int i){
    if(i < 10){
        return list[i];
    }else{
        cout << "已超出list的最大范围10。" << endl;
        return list[0];
    }
}



int main(){
    //第一个实例
    test<char> obj;      //直接test obj;是错误的，必须test<xxx>为模板类指定变量类型。
    int k;
    char str[20] = "hello world!";

    for(k=0; k<10; k++){
        obj.list[k] = str[k];
    }

    cout << "赋值后obj.list的值为：" << obj.list << endl;       //这里不符合C++语法；意会即可。

    for(k=0; k<=5; k++){
        char res = obj.testfunc(k);
        cout << "取到第" << k << "个值是：" << res << endl;
    }

    cout << endl;
    cout << "----------" << endl;


    //第二个实例
    test<double> obj2;
    int j;
    double data[10] = {1.23, 2.34, 3.45, 4.56, 5.67, 6.78, 7.89, 0.99, 12.34};
    for(j=0; j<=5; j++){
        // cout << data[j] << endl;
        obj2.list[j] = data[j];
    }
    cout << "赋值后obj2.list的值为：" << obj2.list << endl;        //这里不符合C++语法；意会即可。
    for(j=0; j<=5; j++){
        double res = obj2.list[j];
        cout << "取到第" << j << "个值是：" << res << endl;
    }

    return 0;
}

赋值后obj.list的值为：hello worl@
取到第0个值是：h
取到第1个值是：e
取到第2个值是：l
取到第3个值是：l
取到第4个值是：o
取到第5个值是：

----------
赋值后obj2.list的值为：0x61fd80
取到第0个值是：1.23
取到第1个值是：2.34
取到第2个值是：3.45
取到第3个值是：4.56
取到第4个值是：5.67
取到第5个值是：6.78

#include <iostream>

using namespace std;

template<typename T>
class T_base{       //类模板 基类
public:
    T tb_a;

    void tbtest(){
        cout << "我是T_base类的成员函数：tbtest();输出变量tb_a的值为：" << tb_a << endl;
    };

};

class T_sub:public T_base<int>{};      // 从类模板继承的类 普通类;实质上对模板仅限了实例化。

int main(){
    T_sub obj;
    obj.tb_a = 20;
    obj.tbtest();

    /*
    obj.tb_a = "test";      // 会因类型不匹配到到组织编译失败。
    obj.tbtest();
    */

    return 0;
}

我是T_base类的成员函数：tbtest();输出变量tb_a的值为：20

#include <iostream>

using namespace std;

class base{
public:
    int base_a = 10;
    void show(){
        cout << "我是base类的show();将显示变量base_a：" << base_a << endl;
    }

    void show1(){
        cout << "我是base类的show1();将显示变量base_a：" << base_a << endl;
    }
};


template <class T>     // 同temlate<typename T>
class T_sub:public base{
public:
    T sub_a;
    void show(){
        cout << "我是T_sub类的show();将显示变量sub_a：" << sub_a << endl;
    }

    void test(){
        cout << "我是T_sub类的test();将显示变量sub_a：" << sub_a << endl;
    }
};


int main(){
    T_sub<int> obj1;
    obj1.sub_a = 100;
    obj1.show();
    obj1.show1();
    obj1.test();

    cout << endl;
    cout << "----------" << endl;

    T_sub<string> obj2;
    obj2.sub_a = "hello";
    obj2.show();
    obj2.show1();
    obj2.test();


    return 0;
}

我是T_sub类的show();将显示变量sub_a：100
我是base类的show1();将显示变量base_a：10
我是T_sub类的test();将显示变量sub_a：100

----------
我是T_sub类的show();将显示变量sub_a：hello
我是base类的show1();将显示变量base_a：10
我是T_sub类的test();将显示变量sub_a：hello

#include <iostream>

using namespace std;

template<typename T1>
class T_Base{
public:
    T1 data1;
    void show(){
        cout << "我是类模板T_Base中的成员函数show();将显示变量data1的值：" << data1 << endl;
    }
};


template <class T1, typename T2>
class T_sub:public T_Base<T1>{      //继承类模板T_Base
public:
    T2 data2;
    void print(){
        cout << "我是类模板T_sub中的成员函数print();将显示变量data2的值：" << data2 << endl;
    }

};


int main(){
    T_sub<int, string> obj1;         //这主意这里的不同
    obj1.data1 = 10;
    obj1.data2 = "hello";
    obj1.show();
    obj1.print();

    cout << endl;
    cout << "----------" << endl;

    T_sub<char, double> obj2;         //这主意这里的不同
    obj2.data1 = 'A';
    obj2.data2 = 3.14159;
    obj2.show();
    obj2.print();

    return 0;
}

我是类模板T_Base中的成员函数show();将显示变量data1的值：10
我是类模板T_sub中的成员函数print();将显示变量data2的值：hello

----------
我是类模板T_Base中的成员函数show();将显示变量data1的值：A
我是类模板T_sub中的成员函数print();将显示变量data2的值：3.14159

#include <iostream>
#include <vector>
#include <algorithm>

template<typename T>
void printVector(const std::vector<T>& vec) {
    for (const auto& element : vec) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> numbers { 5, 2, 8, 1, 9 };

    // 向量中的元素排序
    std::sort(numbers.begin(), numbers.end());

    // 输出排序后的向量
    std::cout << "Sorted numbers: ";
    printVector(numbers);

    // 向量中是否包含特定元素
    int target = 8;
    bool contains = std::find(numbers.begin(), numbers.end(), target) != numbers.end();
    std::cout << "Does the vector contain " << target << "? " << (contains ? "Yes" : "No") << std::endl;

    // 向量中的元素求和
    int sum = 0;
    for (const auto& number : numbers) {
        sum += number;
    }
    std::cout << "Sum of numbers: " << sum << std::endl;

    return 0;
}

#include <iostream>

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Animal makes sound!" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Dog barks!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Cat meows!" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->makeSound();  // 实际调用的是 Dog 类的 makeSound() 函数
    animal2->makeSound();  // 实际调用的是 Cat 类的 makeSound() 函数
    
    delete animal1;
    delete animal2;
    
    return 0;

}

virtual 函数返回值类型 函数名(形参表)

#include <iostream>

using namespace std;

class A{
public:
    int a = 10;
    void aaa(){
        cout << "我是基类A中的aaa()函数" << endl;
    }

    void test(){
        cout << "我是基类A中的test()函数" << endl;
    }

    void heihei(){
        cout << "我是基类A中的heihei()函数" << endl;
    }

    virtual void wawa(){
        cout << "我是基类A中的wawa()函数" << endl;
    }

    virtual void haha(){       //基类中的虚函数不能省略virtual
        cout << "我是基类A中的haha()函数" << endl;
    }

    virtual void haha1(int x){
        cout << "我是基类A中的haha1(int x)函数" << endl;
    }

};



class B:public A{
public:
    int b = 20;
    void bbb(){
        cout << "我是派生类B中的bbb()函数" << endl;
    }

    void test(){
        cout << "我是派生类B中的test()函数" << endl;
    }

    void heihei(int x){
        cout << "我是派生类B中的heihei(int x)函数" << endl;
    }

    void wawa(int x){
        cout << "我是派生类B中的wawa(int x)函数" << endl;
    }

    void haha(){
        cout << "我是派生类B中的haha()函数" << endl;
    }

    void haha1(int x){
        cout << "我是派生类B中的haha1(int x)函数" << endl;
    }

};



class C:public A{
public:
    virtual void haha(){    //派生类中与基类构成多态的函数可以省略virtual；但是强烈建议不要省略
        cout << "我是派生类C中的haha()函数" << endl;
    }

    void haha1(int x){        //派生类中与基类构成多态的函数可以省略virtual；但是强烈建议不要省略
        cout << "我是派生类C中的haha1(int x)函数" << endl;
    }
};


int main(){
    A obja;
    B objb;

    obja.aaa();
    //obja.bbb();         //不能使用派生类函数
    obja.test();
    obja.heihei();
    obja.wawa();
    obja.haha();
    obja.haha1(1);
    cout << "\n \n" << endl;

    objb.aaa();         //可以使用继承自父类的函数
    objb.bbb();
    objb.test();
    //objb.heihei();    //非法，只能使用派生类的成员函数
    //objb.wawa();      //非法，只能使用派生类的成员函数；这里要注意，父类的虚函数要和派生类的函数构成多态，则必须两者名字相同参数一致。
    objb.heihei(1);     //只能使用派生类的成员函数
    objb.wawa(1);     //只能使用派生类的成员函数
    objb.haha();
    objb.haha1(1);
    cout << "\n \n" << endl;


    A* pa = nullptr;
    B* pb = nullptr;
    pa = &objb;
    //pb = &obja;        //非法；不能将父类对象的地址赋予派生类类型的指针变量
    pa->aaa();
    //pa.bbb();            //非法；不能使用基类中没有申明过的函数
    pa->test();
    pa->heihei();
    //pa->heihei(1);            //非法；不能使用基类中没有申明过的函数(参数清单也要匹配)
    pa->wawa();      //因虚函数的参数列表不一致，没有构成多态
    //pa->wawa(1);            //非法；不能使用基类中没有申明过的函数(参数清单也要匹配)
    pa->haha();      //多态性质，使用了派生类B的haha()函数
    //pa->haha1();            //非法；不能使用基类中没有申明过的函数(参数清单也要匹配)
    pa->haha1(1);    //多态性质，使用了派生类B的haha(int x)函数
    cout << "\n \n" << endl;


    A* pc = new C;
    pc->aaa();         //继承自类A
    pc->test();         //继承自类A
    pc->heihei();         //继承自类A
    pc->wawa();         //继承自类A；在类A中wawa()是虚函数，但是在派生类C中没有重新定义，因此知识会简单继承过来。
    pc->haha();         //多态性质，在类A中haha()是虚函数，但是在派生类C中进行了重新定义，且因为A类类型的指针变量pc实际指向的是C类的对象；
    //因此，根据多态的性质，这里会调用C类对象的haha()函数。
    pc->haha1(1);       //同上，这里强调要构成多态：父类定义的虚函数和和派生类重新定义的函数在名字和参数列表上必须完全一致。

    delete pc;

    return 0;
}

我是基类A中的aaa()函数
我是基类A中的test()函数
我是基类A中的heihei()函数
我是基类A中的wawa()函数
我是基类A中的haha()函数
我是基类A中的haha1(int x)函数



我是基类A中的aaa()函数
我是派生类B中的bbb()函数
我是派生类B中的test()函数
我是派生类B中的heihei(int x)函数
我是派生类B中的wawa(int x)函数
我是派生类B中的haha()函数
我是派生类B中的haha1(int x)函数



我是基类A中的aaa()函数
我是基类A中的test()函数
我是基类A中的heihei()函数
我是基类A中的wawa()函数
我是派生类B中的haha()函数
我是派生类B中的haha1(int x)函数



我是基类A中的aaa()函数
我是基类A中的test()函数
我是基类A中的heihei()函数
我是基类A中的wawa()函数
我是派生类C中的haha()函数
我是派生类C中的haha1(int x)函数

#include<iostream>

using namespace std;

class A {
public:
    virtual void Print() {  // 虚函数
        cout << "A::Print" << endl;
    }
};

class B : public A { // 公有派生
public:
    virtual void Print() {  // 虚函数
        cout << "B::Print" << endl;
    }
};

void PrintInfo(A &r) {
    r.Print();  // 多态,使用基类引用调用哪个Print()取决于r引用了哪个类的对象
}

int main() {
    A a;
    B b;
    PrintInfo(a);  // 使用基类对象，调用基类中的函数，输出A::Print
    PrintInfo(b);  // 使用基类对象，调用派生类中的函数，输出B::Print
    return 0;
}

virtual ~类名( );

virtual 函数类型 函数名(参数表)=0;

virtual void fun()=0;

#include<iostream>

using namespace std;

class A {
private:
    int a;
public:
    virtual void print() = 0;   // 纯虚函数
    void func1() {
        cout << "func1" << endl;
    }
};

class B : public A {
public:
    void print();

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

void B::print() {
    cout << "B_Print" << endl;
}

int main() {
    // A a; // 错误，抽象类不能实例化
    // A *p = new A;    // 错误，不能创建类A的实例
    // A b[2];  // 错误，不能声明抽象类的数组
    A *pa;  // 正确，可以声明抽象类的指针
    A *pb = new B;  // 使用基类指针指向派生类对象
    pb->print();    // 调用的是类B中的函数，多态，输出B——print
    B b;
    A *pc = &b;
    pc->func1();    // 因为不是虚函数，调用的是类A中的函数，输出func1
    return 0;
}

class 派生类名: virtual 派生方式 基类名
{
	派生类体;
};

#include<iostream>

using namespace std;

class A {
public:
    int a;

    void showa() {
        cout << "a=" << a << endl;
    }
};

class B : virtual public A { // 对A进行了虚继承
public:
    int b;
};

class C : virtual public A { // 对A进行了虚继承
public:
    int c;
};

class D : public B, public C {
    // 派生类D的俩个基类B、C具有共同的基类A
    // 采用了虚继承，从而使类D的对象中只包含着类A的1个实例
public:
    int d;
};

int main() {
    D Dobj; // 说明派生类D的对象
    Dobj.a = 11;    // 若不是虚继承，此行会出错！因为 "D::a" 具有二义性（A->B->D和A->C->D）
    Dobj.b = 22;    // 若不是虚继承，下面行会出错！因为 "D::showa" 具有二义性
    Dobj.showa();   // 输出 a=11
    cout << "Dobj.b=" << Dobj.b << endl;    // 输出Dobj.b=22
    return 0;
}

#include <iostream>

using namespace std;

class A{
public:
    int a = 10;
    int x = 10;
    int aa = 10;

    virtual void test(){
        cout << "我是Class A的test()函数。" << endl;    
    }

};

class B:public A{
public:
    int a = 20;
    int bb = 20;

    virtual void test(){
        cout << "我是Class B的test()函数。" << endl;    
    }

};

class C:public A{
public:
    int a = 30;
    int cc = 30;

    virtual void test(){
        cout << "我是Class C的test()函数。" << endl;    
    }

};

class D:public B,public C{
public:
    int a = 40;
    int dd = 40;
};


class E:virtual public A{      //这里和class B/C不同。(public省略则默认是private)
public:
    int a = 50;
    int x = 50;
    int ee = 50;

    virtual void test(){
        cout << "我是Class E的test()函数。" << endl;   
    }
};


class F:virtual public A{      //这里和class B/C不同。(public省略则默认是private)
public:
    int a = 60;
    int x = 60;
    int ff = 60;

    virtual void test(){
        cout << "我是Class F的test()函数。" << endl;   
    }
};


class G:public E,public F{
public:
    int a = 70;
    int gg = 70;

    //若么有下段代码，则class的定义就会报错；因为编译时不能确定A/E/F中同名函数到底要使用哪个？（相当于为同名函数指定默认值/动作）
    void test() override {     //类G中重复继承了虚基类A导致冲突，因此编译器无法确定要调用的具体虚函数版本。为了解决这个问题，可以使用作用域解析运算符来明确指定要调用的函数版本。
        A::test();  // 明确指定调用基类A的test函数
        //或者：E::test();
        //或者：F::test();
        
        //根据实际需要明确指定
    }
};


int main(){
    D obj1;
    cout << "类D的变量obj1.a:" << obj1.a << endl;
    //cout << "类D的变量obj1.aa:" << obj1.aa << endl;      //具有二义性；错误用法
    cout << "类D的变量obj1.bb:" << obj1.bb << endl;
    cout << "类D的变量obj1.cc:" << obj1.cc << endl;
    //cout << "类D的函数obj1.test():" << endl;
    //obj1.test();    //具有二义性；错误用法


    G obj2;
    cout << "类G的变量obj2.a:" << obj2.a << endl;
    //cout << "类G的变量obj2.x:" << obj2.x << endl;      //具有二义性；错误用法
    cout << "类G的变量obj2.x:" << obj2.A::x << endl;     //规避二义性；正确用法
    cout << "类G的变量obj2.x:" << obj2.E::x << endl;     //规避二义性；正确用法
    cout << "类G的变量obj2.x:" << obj2.F::x << endl;     //规避二义性；正确用法
    cout << "类G的变量obj2.aa:" << obj2.aa << endl;
    cout << "类G的变量obj2.ee:" << obj2.ee << endl;
    cout << "类G的变量obj2.ff:" << obj2.ff << endl;
    cout << "类G的变量obj2.gg:" << obj2.gg << endl;
    cout << "[默认]类G的函数obj2.test():" << endl;
    obj2.test();
    cout << "[指定A]类G的函数obj2.A::test():" << endl;
    obj2.A::test();
    cout << "[指定E]类G的函数obj2.E::test():" << endl;
    obj2.E::test();
    cout << "[指定F]类G的函数obj2.F::test():" << endl;
    obj2.F::test();


    return 0;
}

类D的变量obj1.a:40
类D的变量obj1.bb:20
类D的变量obj1.cc:30
类G的变量obj2.a:70
类G的变量obj2.x:10
类G的变量obj2.x:50
类G的变量obj2.x:60
类G的变量obj2.aa:10
类G的变量obj2.ee:50
类G的变量obj2.ff:60
类G的变量obj2.gg:70
[默认]类G的函数obj2.test():
我是Class A的test()函数。
[指定A]类G的函数obj2.A::test():
我是Class A的test()函数。
[指定E]类G的函数obj2.E::test():
我是Class E的test()函数。
[指定F]类G的函数obj2.F::test():
我是Class F的test()函数。

class Base {
public:
    virtual void print() {         // 基类中的虚函数
        cout << "Base::print()" << endl;
    }
};

class Derived : public Base {
public:
    void print() override {        // 派生类中重写基类的虚函数
        cout << "Derived::print()" << endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->print();   // 调用派生类的虚函数

    delete basePtr;
    return 0;
}

Derived::print()

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

class Derived : public Base {
public:
    void func() override;  // 显式使用 override 关键字声明重写函数
};

#include <iostream>

class MyNumber {
private:
    int value;

public:
    MyNumber(int val) : value(val) {}

    // 运算符重载：加法运算符+
    MyNumber operator +(const MyNumber& other) const {
        return MyNumber(value + other.value);
    }

    int getValue() const {
        return value;
    }
};

int main() {
    MyNumber num1(5);
    MyNumber num2(10);

    MyNumber sum = num1 + num2;  // 调用重载的加法运算符+

    std::cout << "Sum: " << sum.getValue() << std::endl;

    return 0;
}

#include <iostream>

using namespace std;

class A{
private:
    int a = 10;   //优先级低
    int b = 20;

public:
    A(){
        a = 100;   //优先级高
        b = 200;
    }

    //类内运算符函数重载
    int operator+(A& x){    //因为+是双目运算符，因此如果定义为类成员函数则类对象本身就占了一个参数，因此只能在设定一个参数；多于1个就会报错。
    //这里的函数返回值类型当然也可以是本类；例如本示例中就是A
        return a+b;         //在只要是A类的任意两个对象在执行+运算，都会返回a+b=300
    }

    //因为-是双目运算符，但函数定义为友元函数（不是类的成员函数），因此本类示例不能默认占用参数，所以还是可以定义2个参数。
    friend int operator-(A& x, A& y);   //类外运算符函数重载（用友元函数的方法实现）

};


int operator -(A& x, A& y) {
    return x.a-x.b;    //与第二个参数完全无关哈，示例而已，领会下逻辑就行
}



int main(){
    A obj1;
    A obj2;
    int sum = obj1 + obj2;    //**sum的类型要和operator+返回值的类型一致**
    cout << "A类的两个对象相加结果为：" << sum << endl;
    cout << "\n \n" << endl;

    int diff = obj1 - obj2;   //**diff的类型要和operator-返回值的类型一致**
    cout << "A类的两个对象相减结果为：" << diff << endl;

    return 0;
}

A类的两个对象相加结果为：300


A类的两个对象相减结果为：-100

#include <iostream>

class B {
public:
    B(int value) : data(value) {}

    void printData() {
        std::cout << "Data: " << data << std::endl;
    }

private:
    int data;
};

class A {
public:
    operator B() {
        std::cout << "Converting A to B" << std::endl;
        return B(42);
    }
};

int main() {
    A aObject;
    B bObject = aObject;  // 类型转换调用

    bObject.printData();  // 打印输出结果：Data: 42

    return 0;
}

#include <iostream>
#include <string>

class MyString {
public:
    std::string value;

    MyString(const std::string& str) : value(str) {}

    MyString operator+(const MyString& other) {
        return MyString(value + other.value);
    }
};

int main() {
    MyString str1("Hello");
    MyString str2(" world!");

    MyString result = str1 + str2;

    std::cout << result.value << std::endl;  // 输出结果：Hello world!

    return 0;
}

#include <iostream>

class A {
public:
    operator int() const {
        return value;
    }

private:
    int value = 42;
};

int main() {
    A aObject;
    int intValue = aObject;  // 类型转换调用

    std::cout << intValue << std::endl;  // 输出结果：42

    return 0;
}

#include <iostream>

using namespace std;

int main(){
    int x, y;
    cout << "请输入2个数字x y:" << endl;
    cin >> x >> y;
    freopen("test_std_out01.txt", "w", stdout);  //不能使用单引号（汗...）;  freopen()=file reopen
    if(y == 0){
        cerr << "除数y不能为0." << endl;
    }else{
        cout << "x/y=" << x << "/" << y << "=" << x/y << endl;   //不会输出到屏幕，而是输出到"test_std_out01.txt"
    }


    return 0;
}

请输入2个数字x y:
100 10

x/y=100/10=10

#include <iostream>

using namespace std;

int main(){
    int x, count, sum = 0;
    freopen("test_infile_01.txt", "r", stdin);     // 将标准输入重定向到"test_infile_01.txt"；freopen()=file reopen
    for(count = 0; count < 10; count++){           // 循环10次；
        cin >> x;                                  // 从标准输入中读取数据并赋予变量x；
        if(cin.eof()){                             // 判断标准输入是否已经到了文件结尾(空行)；
            break;
        }else{
            sum = sum + x;
        }
    }
    cout << "test_infile_01.txt文件中的前10个数之和是：" << sum << endl;

    return 0;
}

5
10
15
20

test_infile_01.txt文件中的前10个数之和是：50

#include <iostream>

int main() {
    char ch = 'A';

    std::cout.put(ch); // 输出字符 'A'
    std::cout.put('\n'); // 输出换行符

    return 0;
}

#include <iostream>
#include <iomanip>

int main(){
    int x = 888;
    double pi = 3.1415926;

    std::cout << x << std::endl;
    std::cout << std::setw(8) << x << std::endl;      //设置输出宽度为8个字符；不足位数默认使用空格填充。
    std::cout << std::setw(8) << std::setfill('c') << x << std::endl;     //setfile()参数用单引号引起来，不能使用双引号。。。

    std::cout << std::setprecision(4) << pi << std::endl;        //设置输出内容的精度（四舍五入）

    std::cout << true << std::endl;                              //输出：1
    std::cout << std::boolalpha << true << std::endl;            //输出：true

    std::cout << x << std::endl;                                 //默认十进制
    std::cout << std::oct << x << std::endl;                     //八进制
    std::cout << std::dec << x << std::endl;                     //十进制
    std::cout << std::hex << x << std::endl;                     //十六进制

    std::cout << std::setbase(2) << x << std::endl;                     //错误用法，仍输出十进制
    std::cout << std::setbase(8) << x << std::endl;                     //八进制
    std::cout << std::setbase(10) << x << std::endl;                     //十进制
    std::cout << std::setbase(16) << x << std::endl;                     //十六进制


    return 0;
}

888
     888
ccccc888
3.142
1
true
888
1570
888
378
888
1570
888
378

#include <iostream>
#include <limits>

using namespace std;

int main(){
    char x;
    cout << "请输入一个字符:" << endl;
    cin >> x;
    cout << "输入的值被赋予x:" << x << endl;

    cout << "请输入一个字符:" << endl;
    //cin.ignore();                         // 忽略换行符;否则将受到上次输入缓冲中仍然有一个换行符残留在输入流中的影响。（因只能忽略换行符在第一次输入大量字符后仍会影响本次获取输入的数据）
    cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');    // 清空输入流,依赖#include <limits>.
    x = cin.get();
    cout << "输入的值被赋予x:" << x << endl;

    const int MAX_LENGTH = 100;         //存储最大字符串的长度
    char y[MAX_LENGTH];
    cout << "请输入一段话(getline()):" << endl;
    //cin.ignore();                         // 忽略换行符;否则将受到上次输入缓冲中仍然有一个换行符残留在输入流中的影响。（因只能忽略换行符在第一次输入大量字符后仍会影响本次获取输入的数据）
    cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');    // 清空输入流,依赖#include <limits>.
    cin.getline(y, MAX_LENGTH);
    cout << "输入的值被赋予y:" << y << endl;

    string z;
    cout << "请输入一段话(cin >> z):" << endl;
    cin >> z;
    cout << "输入的值被赋予z:" << z << endl;


    return 0;
}

请输入一个字符:
qwerty rtyu
输入的值被赋予x:q
请输入一个字符:
qwerty dfd
输入的值被赋予x:q
请输入一段话(getline()):
qwer 123#$% %^gg
输入的值被赋予y:qwer 123#$% %^gg
请输入一段话(cin >> z):
qe helllo world!
输入的值被赋予z:qe

#include <iostream>
#include <limits>

int main() {
    char ch;

    std::cout << "请输入一个字符：" << std::endl;
    std::cin >> ch; // 读取一个字符

    // 忽略输入缓冲区中的剩余字符
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

    std::cout << "继续输入一个字符串：" << std::endl;
    std::string str;
    std::getline(std::cin, str); // 读取一行字符串
    std::cout << "您输入的字符串是：" << str << std::endl;

    return 0;
}

#include <iostream>

using namespace std;

int main(){
    char x;
    cout << "请任意输入一段话：" << endl;
    cin >> x;        //从输入中取走了第一个字符

    char y;
    y = cin.peek();   //看一眼当前缓冲中的下一个字符
    cout << "C++使用peek()函数偷看了一眼输入流，看到了：" << y << endl;
    cout << "判断看到的值是否是空值或者/n或者EOF等" << endl;
    if(y == EOF){
        //cout << "y的值是EOF。" << endl;     //这样写回出现警告：warning: character constant too long for its type
        cout << "y的值是EOF。\n";           //上一句改写成这样
    }else if (y == '\n')
    {
        cout << R"(y的值是\n。)" << endl;       //特殊字符原样输出的技巧    R"(xxxxxxxx)"
    }else if(y == ' '){
        cout << "y的值是' '。" << endl;
    }else{
        cout << "y的值猜不中。" << endl;
    }
    

    return 0;
}

请任意输入一段话：
a
C++使用peek()函数偷看了一眼输入流，看到了：

判断看到的值是否是空值或者/n或者EOF等
y的值是\n。

请任意输入一段话：
qwerty uiop[
C++使用peek()函数偷看了一眼输入流，看到了：w
判断看到的值是否是空值或者/n或者EOF等
y的值猜不中。

流类名 对象名;
对象名.open(文件名, 模式);

对象名.close();

#include <iostream>
#include <fstream>

using namespace std;

int main(){
    // 使用ifstream类创建对象并以读模式（ios::in）打开文件;ios::in模式支持ifstream和fstream的对象使用
    // 若文件不存在则打开出错
    ifstream obj1(".\\test_file_001.txt", ios::in);
    if(obj1){
        cout << "文件.\\test_file_001.txt  打开成功！" << endl;
        obj1.close();
    }else{
        cout << "文件.\\test_file_001.txt  打开失败！！" << endl;
    }


    // 使用ofstream类创建对象并以写模式（ios::out）打开文件;;ios::out模式支持ofstream和fstream的对象使用
    // 若文件不存在则创建；存在则清空文件
    ofstream obj2(".\\test_file_002.txt", ios::in);
    if(obj2){
        cout << "文件.\\test_file_002.txt  打开成功！" << endl;
        obj2.close();
    }else{
        cout << "文件.\\test_file_002.txt  打开失败！！" << endl;
    }



    // 使用ofstream类创建对象并以附加 模式（ios::app）打开文件;;ios::app模式支持ofstream对象使用
    // 若文件不存在则创建；若存在则打开并将光标定位到文件尾部。
    ofstream obj3(".\\test_file_003.txt", ios::in);
    if(obj3){
        cout << "文件.\\test_file_003.txt  打开成功！" << endl;
        obj3.close();
    }else{
        cout << "文件.\\test_file_003.txt  打开失败！！" << endl;
    }


    return 0;
}

文件.\test_file_001.txt  打开成功！
文件.\test_file_002.txt  打开成功！
文件.\test_file_003.txt  打开成功！

#include <iostream>
#include <fstream>

using namespace std;

int main(){
    // 定义输入变量
    string id, name;
    int age, score;
    string filename = ".\\student.txt";
    

    // 定义输出文件的对象
    //ofstream obj(".\\student.txt", ios::out);      // 写入的数据中文乱码
    ofstream obj(filename, ios::binary);
    if(obj.is_open()){
        cout << "文件" << filename << "打开成功！" << endl;
    }else{
        cout << "文件" << filename << "打开失败！" << endl;
    }


    // 输入数据并写入数据
    cout << "请输入：学号 姓名 年龄 成绩" << endl;
    cin >> id >> name >> age >> score;
    cout << "您输入的信息分别是：    " << " 学号：" << id  << " 姓名：" << name << " 年龄：" << age << " 成绩：" << score << endl;
    //obj << u8"学号 姓名 年龄 成绩" << endl;                 // u8配合ios::binary将中文以utf-8编码写入文件
    obj << "学号 姓名 年龄 成绩" << endl;
    obj << id << ' ' << name << ' '  << age << ' '  << score << endl; 
    obj.close();



    return 0;
}

文件.\student.txt打开成功！
请输入：学号 姓名 年龄 成绩
1001 夏明亮 18 100
您输入的信息分别是：     学号：1001 姓名：夏明亮 年龄：18 成绩：100

#include <iostream>
#include <fstream>

using namespace std;

int main(){
    string filename = ".\\student.txt";
    
    //将写入结果从文件中读取出来
    string content_line;
    ifstream obj1(filename, ios::in);      //只读打开
    if(obj1.is_open()){
        cout << "文件" << filename << "打开成功！" << endl;
        int i = 1;
        while(getline(obj1, content_line)){
            cout << i << "==>" << content_line << endl;
            i++;
        }
        obj1.close();
    }else{
        cout << "文件" << filename << "打开失败！" << endl;
    }
    return 0;
}

文件.\student.txt打开成功！
1==>学号 姓名 年龄 成绩
2==>1001 夏明亮 18 100

#include<iostream>
#include<fstream>
using namespace std;
#include<sstream>

#include <iostream>
#include <iomanip>
int main() {
    int num1 = 123;
    int num2 = 456;
    std::cout << std::setw(8) << num1 << std::endl;
    std::cout << std::setw(8) << num2 << std::endl;
    return 0;
}

123
     456

#include <iostream>
#include <iomanip>
int main() {
    int num = 123;
    std::cout << std::setfill('*') << std::setw(8) << num << std::endl;
    std::cout << std::setfill('#') << std::setw(8) << num << std::endl;
    return 0;
}

****123
####123

#include <iostream>
#include <iomanip>     //需要引入这个头文件支持
int main(){
    for(int i=0; i<=100; i++){
        std::cout << std::setw(3) << i << std::endl;  //3位；默认右对齐；默认空格填充
    }

    for(int i=0; i<=100; i++){
        std::cout << std::setw(4) << std::left << i << std::endl;  //3位；左对齐；默认空格填充
    }

    for(int i=0; i<=100; i++){
        std::cout << std::setw(3) << i << std::endl;      //3位；左对齐（延续前面的设定）；默认空格填充
    }

    for(int i=0; i<=100; i++){
        std::cout << std::setfill('*') << std::setw(4) << std::right << i << std::endl;      //4位；右对齐（延续前面的设定）；*填充
    }

    for(int i=0; i<=100; i++){
        std::cout << std::setw(4) << i << std::endl;      //4位；右对齐（延续前面的设定）；*填充(延续前面的设定)
    }

    for(int i=0; i<=100; i++){
        std::cout << std::setfill('0') << std::setw(8) << std::right << i << std::endl;      //8位；右对齐（延续前面的设定）；0填充[字符串不是int要注意]
    }

    double num = 3.14159;
    std::cout << std::fixed << std::setprecision(2) << num << std::endl;     //输出3.14

    return 0;
}

0
……
100
0
1
……
100
0
1
……
100
***0
***1
……
*100
***0
***1
……
*100
00000000
00000001
……
00000100
3.14

#include<iostream>
using namespace std;
#include<fstream>
int main(){
	ofstream file;
}
123456

#include <fstream>
using namespace std;

fstream file;
file.open("filename.txt", ios::in);

string line;
getline(file, line);

string line;
while (getline(file, line)) {
    // 处理读取到的数据
}

file.close();

#include <iostream>
#include <fstream>
#include <string>     //可省略的
using namespace std;
int main(){
    ifstream inf;
    inf.open("00.temp.cpp", ios::in);

    if(!inf){
        cerr << "文件打开失败！" << endl;
        return 1;
    }

    string line;
    int num = 1;
    while(getline(inf, line)){
        cout << num << ":" << line << endl;
        num ++;
    }

    inf.close();
    return 0;
}

#include <iostream>
#include <fstream>
using namespace std;

class logmgr{
public:
    bool addlogtofile(int id,int type, char msg[100], string logfilepath){
        fstream file(logfilepath, ios::binary | ios::app);    //以二进制和追加的模式打开
        if(file.is_open()){
            file << id << " "<< type << " " << msg << endl;  //注意别忘了加上适当的空格
            file.close();
            return true;
        }else{
            return false;
        }
    }

    int getloglinenum(string logfilepath){
        fstream file;
        file.open(logfilepath,  ios::in);
        int linecount = 0;
        string line;
        if(file.is_open()){
            while(getline(file, line)){
                if(!file.eof()){
                    linecount++;
                }else{
                    file.close();
                }
            }
        }else{ 
            return 1; 
        }
        return linecount;
    }

    void getloglast_10(string logfilepath){
        ifstream file;
        file.open(logfilepath, ios::in);
        string line;
        if(file.is_open()){
            for(int i=0 ; i<10 && getline(file, line); i++){
                //if(!file.eof()){}
                cout << i+1 << ":" << line << endl; 
            }
            file.close();
        }else{ 
            cout << "show last 10 logs error!" << endl; 
        }
        
    }
};

int main(){
    logmgr obj;
    for(int i=1; i<=5; i++){
        obj.addlogtofile(1000+i, 01, "test msg 001", ".\\log.bat");  //这里将string传给char[]编译时会出现警告；建议换种写法。
    }
    cout << "Log file's linecount:" << obj.getloglinenum(".\\log.bat") << endl;
    obj.getloglast_10(".\\log.bat");

    return 0;
}

Log file's linecount:5
1:1001 1 test msg 001
2:1002 1 test msg 001
3:1003 1 test msg 001
4:1004 1 test msg 001
5:1005 1 test msg 001

#include <iostream>
#include <fstream>

int main() {
    std::ifstream inputFile("input.txt");
    std::ofstream outputFile("output.txt");

    int number;
    inputFile >> number;
    outputFile << "The number is: " << number;

    inputFile.close();
    outputFile.close();

    return 0;
}

#include <iostream>
#include <fstream>

int main() {
    std::ifstream input("example.txt", std::ios::binary);

    if (input) {
        // 设置读指针从文件开头向后移动100字节
        input.seekg(100, std::ios::beg);
    
        // 或者直接设置读指针的绝对位置为200字节
        // input.seekg(200);
    
        // 进行后续的读取操作
    }
    else {
        std::cout << "Failed to open file." << std::endl;
    }
    
    input.close();
    
    return 0;

}

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("example.txt"); // 打开一个文件用于写入

    if (file.is_open()) {
        file << "Hello, World!\n"; // 写入一些数据
    
        // 使用seekp()函数将输出位置设置到文件开头
        file.seekp(0);
    
        file << "New data"; // 从文件开头开始覆盖写入新的数据
    
        file.close(); // 关闭文件
    } else {
        std::cout << "Unable to open file";
    }
    
    return 0;

}

#include <iostream>

// 声明内联函数
inline int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4); // 调用内联函数
    std::cout << "Result: " << result << std::endl;
    return 0;
}

#include <iostream>
// 必须的头文件是
#include <pthread.h>

using namespace std;

#define COUNT_THREADS 5

// 线程的运行函数
void* say_hello(void* args)
{
    cout << "Hello boy!" << endl;
    return nullptr;  // 返回一个空指针
}

int main()
{
    // 定义线程的 id 变量，多个变量使用数组
    pthread_t tids[NUM_THREADS];
    for(int i = 0; i < NUM_THREADS; ++i)
    {
        //参数依次是：创建的线程id，线程参数，调用的函数，传入的函数参数
        int ret = pthread_create(&tids[i], NULL, say_hello, NULL);
        if (ret != 0)
        {
           cout << "pthread_create error: error_code=" << ret << endl;
        }
    }
    //等各个线程退出后，进程才结束，否则进程强制结束了，线程可能还没反应过来；
    pthread_exit(NULL);
}

PS D:\MyC++> g++ test.cpp -lpthread -o test.exe

PS D:\MyC++> .\test.exe
Hello boy!
Hello boy!
Hello boy!
Hello boy!
Hello boy!

PS D:\MyC++>

#include <iostream>
#include <cstdlib>
#include <pthread.h>
#include <windows.h> //包含头文件,解决中文乱码的依赖

using namespace std;

#define NUM_THREADS     5

void* PrintHello(void *threadid)
{  
   // 对传入的参数进行强制类型转换，由无类型指针变为整形数指针，然后再读取
   int tid = *((int*)threadid);
   cout << "Hello world!线程 ID: " << tid << endl;
   pthread_exit(NULL);
   return nullptr;  // 返回一个空指针
}

int main ()
{
   SetConsoleOutputCP(65001);  //***需要include <windows.h>
   pthread_t threads[NUM_THREADS];
   int indexes[NUM_THREADS];// 用数组来保存i的值
   int rc;
   int i;
   for( i=0; i < NUM_THREADS; i++ ){      
      cout << "main() : 创建线程, " << i << endl;
      indexes[i] = i; //先保存i的值
      // 传入的时候必须强制转换为void* 类型，即无类型指针        
      rc = pthread_create(&threads[i], NULL, 
                          PrintHello, (void *)&(indexes[i]));
      if (rc){
         cout << "Error:无法创建线程," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

PS D:\MyC++> g++ test.cpp -lpthread -o test.exe
PS D:\MyC++> .\test.exe
main() : 创建线程, 0
main() : 创建线程, 1
Hello world!线程 ID: 0
main() : 创建线程, 2
Hello world!线程 ID: 1
main() : 创建线程, 3
Hello world!线程 ID: 2
main() : 创建线程, 4
Hello world!线程 ID: 3
Hello world!线程 ID: 4
PS D:\MyC++>

#include <iostream>
#include <cstdlib>
#include <pthread.h>

using namespace std;

#define NUM_THREADS     5

struct thread_data{
   int  thread_id;
   char *message;
};

void *PrintHello(void *threadarg)
{
   struct thread_data *my_data;

   my_data = (struct thread_data *) threadarg;

   cout << "Thread ID : " << my_data->thread_id ;
   cout << " Message : " << my_data->message << endl;

   return pthread_exit(NULL);
}

int main ()
{
   pthread_t threads[NUM_THREADS];
   struct thread_data td[NUM_THREADS];
   int rc;
   int i;

   for( i=0; i < NUM_THREADS; i++ ){
      cout <<"main() : creating thread, " << i << endl;
      td[i].thread_id = i;
      td[i].message = "This is message";
      rc = pthread_create(&threads[i], NULL,
                          PrintHello, (void *)&td[i]);
      if (rc){
         cout << "Error:unable to create thread," << rc << endl;
         exit(-1);
      }
   }
   pthread_exit(NULL);
}

$ g++ -Wno-write-strings test.cpp -lpthread -o test.o
$ ./test.o
main() : creating thread, 0
main() : creating thread, 1
main() : creating thread, 2
main() : creating thread, 3
main() : creating thread, 4
Thread ID : 3 Message : This is message
Thread ID : 2 Message : This is message
Thread ID : 0 Message : This is message
Thread ID : 1 Message : This is message
Thread ID : 4 Message : This is message

#include <iostream>
#include <thread>

// 线程函数，打印一条消息
void threadFunction() {
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建一个新线程，并指定线程函数
    std::thread myThread(threadFunction);

    // 主线程继续执行其他任务
    std::cout << "Hello from main thread!" << std::endl;

    // 等待新线程执行完毕
    myThread.join();

    return 0;
}

#include <iostream>
#include <thread>

// 线程函数
void threadFunc() {
    // 线程执行的代码
    std::cout << "Hello from thread!" << std::endl;
}

int main() {
    // 创建线程并启动
    std::thread myThread(threadFunc);

    // 等待线程完成
    myThread.join();

    return 0;
}

#include <iostream>
#include <future>

// 异步执行的函数
int asyncFunc() {
    // 执行一些操作
    return 42;
}

int main() {
    // 启动异步任务
    std::future<int> result = std::async(asyncFunc);

    // 在需要时获取异步任务的结果
    int value = result.get();

    std::cout << "Result: " << value << std::endl;

    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>

// 共享数据
int counter = 0;
std::mutex mutex;

// 线程函数
void threadFunc() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mutex);
        ++counter;
    }
}

int main() {
    // 创建多个线程并启动
    std::thread thread1(threadFunc);
    std::thread thread2(threadFunc);

    // 等待线程完成
    thread1.join();
    thread2.join();

    std::cout << "Counter value: " << counter << std::endl;

    return 0;
}

#include <iostream>

class MyClass {
public:
    int* data;

    MyClass(int value) {
        data = new int(value);
    }

    // 默认的拷贝构造函数
    MyClass(const MyClass& other) {
        data = other.data;  // 浅拷贝，直接复制指针
    }

    // 默认的赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data;  // 首先释放原有资源
            data = other.data;  // 浅拷贝，直接复制指针
        }
        return *this;
    }

    ~MyClass() {
        delete data;
    }
};

int main() {
    MyClass obj1(5);
    MyClass obj2 = obj1;  // 使用拷贝构造函数进行浅拷贝

    std::cout << *obj1.data << std::endl;  // 输出: 5
    std::cout << *obj2.data << std::endl;  // 输出: 5

    *obj1.data = 10;
  
    std::cout << *obj1.data << std::endl;  // 输出: 10
    std::cout << *obj2.data << std::endl;  // 输出: 10，因为两个对象共享同一个指针

    return 0;
}

#include <iostream>

class MyClass {
public:
    MyClass(int size) {
        data_size = size;
        data = new int[size];
    }

    ~MyClass() {
        delete[] data;
    }

    // 默认的拷贝构造函数（浅拷贝）
    MyClass(const MyClass& other) {
        data_size = other.data_size;
        data = other.data;  // 执行浅拷贝，两个指针指向相同的动态内存
    }

    void setData(int index, int value) {
        if (index >= 0 && index < data_size) {
            data[index] = value;
        }
    }

    void printData() {
        for (int i = 0; i < data_size; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }

private:
    int* data;
    int data_size;
};

int main() {
    MyClass obj1(5);
    obj1.setData(0, 1);
    obj1.setData(1, 2);
    obj1.printData();  // 输出：1 2

    MyClass obj2(obj1);  // 执行浅拷贝，obj2和obj1共享同一块内存
    obj2.setData(0, 3);
    obj2.printData();  // 输出：3 2

    obj1.printData();  // 输出：3 2
    return 0;
}

#include <iostream>

class MyClass {
public:
    int* data;

    MyClass(int value) {
        data = new int(value);
    }

    // 深拷贝的拷贝构造函数
    MyClass(const MyClass& other) {
        data = new int(*other.data);  // 深拷贝，创建新的内存空间并复制值
    }

    // 深拷贝的赋值运算符重载
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            delete data;  // 首先释放原有资源
            data = new int(*other.data);  // 深拷贝，创建新的内存空间并复制值
        }
        return *this;
    }

    ~MyClass() {
        delete data;
    }
};

int main() {
    MyClass obj1(5);
    MyClass obj2 = obj1;  // 使用拷贝构造函数进行深拷贝

    std::cout << *obj1.data << std::endl;  // 输出: 5
    std::cout << *obj2.data << std::endl;  // 输出: 5

    *obj1.data = 10;

    std::cout << *obj1.data << std::endl;  // 输出: 10
    std::cout << *obj2.data << std::endl;  // 输出: 5，因为两个对象有独立的指针和内存空间

    return 0;
}

#include<iostream>
using namespace std;
class demo{
public:
    int* data;

    demo(int value){
        data = new int(value);
    }

    demo(demo& other){
        data = other.data;    //这个行为就是浅拷贝；没有为指针变量开辟专属的内存空间
    }

    demo(demo& other, int m){  //这里为了和demo(demo& other)区别，我们多加一个参数ssww
        data = new int(*other.data);   //这个行为就是深拷贝；为指针变量开辟专属的内存空间，值还是使用源对象的值*other.data
    }

    ~demo(){
        delete data;
    }
};

int main(){
    demo obj1(10);
    demo obj2(obj1);     //这个时候根据demo对象的构造函数定义会执行浅拷贝动作。
    cout << "查看obj1对象的data的地址：" << obj1.data << endl;
    cout << "查看obj1对象的data的值：" << *obj1.data << endl;     //10
    cout << "查看obj2对象的data的地址：" << obj2.data << endl;    //地址与obj1.data相同
    cout << "查看obj2对象的data的值：" << *obj2.data << endl;     //10

    //obj1.data = 20;   //这个写法错误；因为obj1.data实际上是一个指针；指针赋值要么将地址赋给它，要么解指针后进行赋值；
    *obj1.data = 20;
    /* 或者
    int x = 20;
    obj1.data = &x;
    */
    cout << "再次查看obj1对象的data的地址：" << obj1.data << endl;
    cout << "再次查看obj1对象的data的值：" << *obj1.data << endl;    //20
    cout << "再次查看obj2对象的data的地址：" << obj2.data << endl;   //地址与obj1.data相同
    cout << "再次查看obj2对象的data的值：" << *obj2.data << endl;    //20


    demo obj3(100);
    demo obj4(obj3, 888);    // 888随便写一个整数就行，我们的函数定义中根本没用到；仅仅为了避免重载。
    cout << "查看obj3对象的data的地址：" << obj3.data << endl;
    cout << "查看obj3对象的data的值：" << *obj3.data << endl;     //100
    cout << "查看obj4对象的data的地址：" << obj4.data << endl;    //地址与obj3.data不同
    cout << "查看obj4对象的data的值：" << *obj4.data << endl;     //100

    *obj3.data = 200;
    cout << "再次查看obj3对象的data的地址：" << obj3.data << endl;
    cout << "再次查看obj3对象的data的值：" << *obj3.data << endl;    //200
    cout << "再次查看obj4对象的data的地址：" << obj4.data << endl;   //地址与obj3.data不同
    cout << "再次查看obj4对象的data的值：" << *obj4.data << endl;    //100

    return 0;
}

查看obj1对象的data的地址：0x741920
查看obj1对象的data的值：10
查看obj2对象的data的地址：0x741920
查看obj2对象的data的值：10
再次查看obj1对象的data的地址：0x741920
再次查看obj1对象的data的值：20
再次查看obj2对象的data的地址：0x741920
再次查看obj2对象的data的值：20
查看obj3对象的data的地址：0x741960
查看obj3对象的data的值：100
查看obj4对象的data的地址：0x7419a0
查看obj4对象的data的值：100
再次查看obj3对象的data的地址：0x741960
再次查看obj3对象的data的值：200
再次查看obj4对象的data的地址：0x7419a0
再次查看obj4对象的data的值：100

class Animal {
public:
    void breathe() {
        // 实现呼吸功能
    }
    
    void move() {
        // 实现移动功能
    }
};

class Dog : public Animal {
public:
    void bark() {
        // 实现吠声功能
    }
};

int main() {
    Dog dog;
    dog.breathe();    // 调用继承自基类的函数
    dog.move();       // 调用继承自基类的函数
    dog.bark();       // 调用派生类自己的函数
    
    return 0;
}

class Engine {
public:
    void start() { cout << "Engine is starting" << endl; }
};

class Car {
private:
    Engine engine;

public:
    void startCar() { engine.start(); }
};

int main() {
    Car car;
    car.startCar();    // 输出：Engine is starting
    
    return 0;
}