• 对类和对象的详细解析

    目录

    1.类的构成

    2.this指针

     3.C++类里面的静态成员

     3.1 类里面的静态成员函数

    3.2 类里面的静态成员变量

    静态成员变量的特点

    共享性

    存储位置

    生命周期

    访问权限

    如何初始化？

     构造函数

    1.类的构成

     public修饰的成员在类外可以直接被访问

    private和protected修饰的成员不能在类外被访问

    如果变量没有被这三个修饰词来修饰的话,则默认为private

    2.this指针

    关于this指针的一个经典回答：

    有一个房子类

    当你进入这个房子的时候，你可以看见桌子、椅子等，但是房子的全貌你看不见了

    对于一个类的实例来说，你可以看见他的成员函数、成员变量

    但是实例本身呢？

    this这个指针就时时刻刻指向这个实例本身

    this指针是指向对象的指针，存放对象的首地址

    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     void Setage(int age)
    7.     {
    8.         this->age = age;//this->age表示这个类所指向的age,单独的age是形参
    9.     }
    10.     void Showage()
    11.     {
    12.         cout << age << endl;
    13.     }
    14.  
    15. private:
    16.     int age;
    17. };
    18. int main()
    19. {
    20.     Student s;
    21.     s.Setage(18);
    22.     s.Showage();
    23.     return 0;
    24. }
    25. //输出结果为18
    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     void Setage(int age)
    7.     {
    8.         age = age;//age=age,并不会改变类里面age的值
    9.     }
    10.     void Showage()
    11.     {
    12.         cout << age << endl;
    13.     }
    14.  
    15. private:
    16.     int age;
    17. };
    18. int main()
    19. {
    20.     Student s;
    21.     s.Setage(18);
    22.     s.Showage();
    23.     return 0;
    24. }
    25. //输出结果是0

    this指针是编译器帮我们加上的，不占用空间

    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. private:
    6.     int age;
    7. };
    8.  
    9. int main()
    10. {
    11.     cout << sizeof(Student) << endl;//结果为4
    12.     return 0;
    13. }

    既然this指针指向类，那么类的地址和this的地址是一样的

    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     void test()
    7.     {
    8.         cout << this << endl;
    9.     }
    10.  
    11. private:
    12.     int age;
    13. };
    14.  
    15. int main()
    16. {
    17.     Student s;
    18.     s.test();
    19.     cout << &s << endl;
    20.     return 0;
    21. }

    输出的地址是一样的

     3.C++类里面的静态成员

    静态成员是属于整个类的而不是某个对象，静态成员只存储一份供所有对象使用

     3.1 类里面的静态成员函数

    静态成员函数没有隐藏的this指针

    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     void Set(int age)
    7.     {
    8.         this->age = age;
    9.     }
    10.     void Showage()
    11.     {
    12.         cout << age << endl;
    13.     }
    14.     static void test()
    15.     {
    16.         cout<<this->age<//这个地方的age会报错,如果不加this也会报错
    17.         //静态成员函数不能引用非静态成员,但是可以在类的非静态成员函数里面使用静态成员
    18.     }
    19. private:
    20.     int age;
    21. };
    22.  
    23. int main()
    24. {
    25.     Student s;
    26.     return 0;
    27. }

    这就说明了静态函数是在这个类创建出来之前就出现了，也就是说静态函数的创建时间比这个类早，所以在这个静态函数里面使用类里面的东西会报错

    那么应该如何使用这个函数呢

    首先要注意一点：这个静态函数不能使用类里面的东西

    1. class Student
    2. {
    3.     static void test()
    4.     {
    5.         cout<<"i want to sleep"<
    6.     }
    7. };
    8.  
    9. int main()
    10. {
    11.     Student s;
    12.     Student::test();//这里记住不能通过类名调用非静态成员函数
    13.     s.test();
    14.     //上面两句说明类的对象可以使用静态和非静态成员函数
    15.     return 0;
    16. }

    这两种方法都可以调用这个静态函数

    3.2 类里面的静态成员变量

    静态成员变量在类的所有实例之间共享，并且可以在不创建类的情况下访问（在类创建之前就创建好了）

    3.3静态成员变量的特点

    共享性

    静态成员变量在类所有的实例之间共享，这个类的每个对象的静态变量都是相同的

    存储位置

    静态成员变量存储在静态存储区，而不是每个对象的堆栈中。这使得他们可以在不创建类的实例的情况下访问

    生命周期

    与程序的生命周期一样。在程序启动的时候就创建了，在程序结束的时候就销毁

    访问权限

    静态成员变量可以通过类名来访问，也可以通过对象来访问。但是建议前者，这样子能强调他们的共享性

    如何初始化？

    1. class Student
    2. {
    3. private:
    4.     static int a;
    5. };
    6.  
    7. int Student::a=0;

     4构造函数

    构造函数的主要作用不是开辟空间创建对象，而是为了初始化对象

    特征

    他不是开空间创建对象，而是初始化对象

    1. 无返回值（也不用写void）

    2. 函数名与类名相同

    3. 构造函数可以重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Student
    6. {
    7. public:
    8.     Student(int a,int b,int c)//构造函数
    9.     {
    10.         _a=a;
    11.         _b=b;
    12.         _c=c;
    13.     }
    14.     Student(int a,int b)
    15.     {
    16.         _a=a;
    17.         _b=b;
    18.     }
    19.     void Show()
    20.     {
    21.         printf("%d %d %d",_a,_b,_c);
    22.     }
    23. private:
    24.     int _a,_b,_c;
    25. };
    26.  
    27. int main()
    28. {
    29.     Student s(1,2,3);//创建s对象的同时调用构造函数
    30.     Student p(1,2);//函数重载
    31.     s.Show();
    32.     return 0;
    33. }
    34. //输出结果1 2 3
    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Student
    6. {
    7. public:
    8.     void Show()
    9.     {
    10.         printf("%d %d %d",_a,_b,_c);
    11.     }
    12. private:
    13.     int _a,_b,_c;
    14. };
    15.  
    16. int main()
    17. {
    18.     Student s;
    19.     s.Show();
    20.     return 0;
    21. }
    22. /*
    23. 输出结果32767 0 0
    24. 如果类里面没有构造函数,则C++编译器会自动调用一个无参的默认构造函数
    25. */
    1. private:
    2.     int _a=1,_b=1,_c=1;
    3.  
    4. /*
    5. 这里对_a,_b,_c不是赋值不是初始化，而是给缺省值
    6. 原因：这里的变量都是声明，还没有创建出来
    7. */

    5析构函数

    作用与构造函数相反。在对象销毁时自动调用，完成对象中资源的清理工作

    特征

    析构函数名是在类名的签名加~

    无参数无返回值

    一个类只能有一个析构函数，如果自己没有定义，系统会调用默认的析构函数。析构函数不能重载

    对象生命周期结束时调用

    析构函数的执行在return之前

    1. #include 
    2. using namespace std;
    3. class S
    4. {
    5. public:
    6.     S()
    7.     {
    8.         cout << "构造" << endl;
    9.     }
    10.     ~S()
    11.     {
    12.         cout << "析构" << endl;
    13.     }
    14. };
    15. int main()
    16. {
    17.     S s;
    18.     return 0;
    19. }

    先输出构造，然后再输出析构

     作用

    当我们在类中声明了一些指针变量的时候，我们一般在析构函数里面释放这些指针变量所占有的空间，因为系统不会释放指针变量指向的空间，我们需要自己来delete

    6.构造函数和析构函数的一些应用

    6.1 定义为局部变量

    先补充一个知识点：局部变量存储在栈区，全局变量和静态变量存储在静态区

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7. public:
    8.     Date(int a)
    9.     {
    10.         _a = a;
    11.         cout << "Date()->" << _a << endl;
    12.     }
    13.     ~Date()
    14.     {
    15.         cout << "~Date()->" << _a << endl;
    16.     }
    17.  
    18. private:
    19.     int _a;
    20. };
    21.  
    22. int main()
    23. {
    24.     Date a(1);
    25.     Date b(2);
    26.     return 0;
    27. }

    输出结果

    析构函数的时候为什么先输出~Date()->2呢？

    首先我们要知道a和b变量都是局部变量，都存储在栈区，栈区遵循后进先出的原则

     6.2 局部变量和全局变量同时存在时

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7. public:
    8.     Date(int a)
    9.     {
    10.         _a = a;
    11.         cout << "Date()->" << _a << endl;
    12.     }
    13.     ~Date()
    14.     {
    15.         cout << "~Date()->" << _a << endl;
    16.     }
    17.  
    18. private:
    19.     int _a;
    20. };
    21.  
    22. Date b(2);
    23.  
    24. int main()
    25. {
    26.     Date a(1);
    27.     return 0;
    28. }

    输出结果

    全局变量先定义，在程序结束之后再销毁（在局部变量销毁之后再销毁）

     6.3 静态变量、局部变量、全局变量共存

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7. public:
    8.     Date(int a)
    9.     {
    10.         _a = a;
    11.         cout << "Date()->" << _a << endl;
    12.     }
    13.     ~Date()
    14.     {
    15.         cout << "~Date()->" << _a << endl;
    16.     }
    17.  
    18. private:
    19.     int _a;
    20. };
    21.  
    22. Date b(2);
    23.  
    24. int main()
    25. {
    26.     Date a(1);
    27.     static Date c(3);
    28.     return 0;
    29. }

    输出结果

    创建变量按顺序来。首先是局部变量被销毁，静态区的变量（只考虑这个区域时）在销毁时也是类似“后进先出”一样来销毁

     6.4 静态变量在循环中

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7. public:
    8.     Date(int a)
    9.     {
    10.         _a = a;
    11.         cout << "Date()->" << _a << endl;
    12.     }
    13.     ~Date()
    14.     {
    15.         cout << "~Date()->" << _a << endl;
    16.     }
    17.  
    18. private:
    19.     int _a;
    20. };
    21.  
    22. int main()
    23. {
    24.     for (int i = 0; i <= 1; i++)
    25.     {
    26.         static Date a(1);
    27.         Date b(2);
    28.     }
    29.     return 0;
    30. }

    输出结果

    静态变量只会被创建一次，所以只有一次构造函数和一次析构函数

     7.拷贝构造函数

    浅拷贝

    拷贝成员变量的值

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Student
    6. {
    7. public:
    8.     Student(int a, int b, int c)
    9.     {
    10.         _a = a;
    11.         _b = b;
    12.         _c = c;
    13.     }
    14.     /*
    15.     当有Student b(a)这行代码的时候
    16.     问题1：为什么要写成 Student &s呢？
    17.     写成Student &s表示s是a的别名,不需要调用拷贝构造函数
    18.     如果写成Student s的话,会无限递归
    19.     原因：在调用拷贝构造函数的时候,
    20. Student(Student s)
    21.     {
    22.         this->_a = s._a;
    23.         this->_b = s._b;
    24.         this->_c = s._c;
    25.     }
    26. 把a传给s也会调用拷贝够咱函数,也就是说,调用一个拷贝构造函数会使得其内部嵌套另一个拷贝构造函数
    27. 那这个嵌套的拷贝构造函数也会继续嵌套一个,依次无限嵌套下去而导致死循环;所以要加一个&
    28.     问题2：那为什么加一个const呢？
    29.     因为我们要a的值不变,将其内部的值赋给b(s),所以我们最好加一个const来修饰来让a的值不变
    30. 只要a里面的值变,就会报错
    31. 因为有可能出现以下情况
    32. Student(const Student &s)
    33.     {
    34.         a._a = this->_a;
    35.         a._b = this->_b;
    36.         a._c = this->_c;
    37.     }
    38. 如果没有const,出现上述情况编译器是不会报错的
    39.     */
    40.     Student(const Student &s)
    41.     {
    42.         this->_a = s._a;
    43.         this->_b = s._b;
    44.         this->_c = s._c;
    45.     }
    46.     void Show()
    47.     {
    48.         printf("%d %d %d\n", _a, _b, _c);
    49.     }
    50.  
    51. private:
    52.     int _a, _b, _c;
    53. };
    54.  
    55. int main()
    56. {
    57.     Student a(10, 20, 30);
    58.     Student b(a);
    59.     b.Show();
    60.     return 0;
    61. }

    输出结果

     8.重载

    关键字：operator

    8.1 运算符重载

    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     Student(int a, int b, int c)
    7.     {
    8.         _a = a;
    9.         _b = b;
    10.         _c = c;
    11.     }
    12.     bool operator==(const Student &b)//重载==运算符
    13.     {
    14.         return _a == b._a && _b == b._b && _c == b._c;//a和b相等的条件
    15.     }
    16. private:
    17.     int _a, _b, _c;
    18. };
    19.  
    20. int main()
    21. {
    22.     Student a(10, 20, 30);
    23.     Student b(10, 20, 30);
    24.     cout << (a == b) << endl;//这里判断a和b是否相等只需要判断a和b里面的_a,_b,_c是否分别相等
    25.     return 0;
    26. }
    1. #include 
    2. using namespace std;
    3. class Student
    4. {
    5. public:
    6.     Student(int a, int b, int c)
    7.     {
    8.         _a = a;
    9.         _b = b;
    10.         _c = c;
    11.     }
    12.     int operator-(const Student &b)
    13.     {
    14.         return b._c - _c;
    15.     }
    16.  
    17. private:
    18.     int _a, _b, _c;
    19. };
    20.  
    21. int main()
    22. {
    23.     Student a(10, 20, 30);
    24.     Student b(10, 20, 50);
    25.     cout << (b - a) << endl;
    26.     return 0;
    27. }
    28. //输出结果是a._c - b._c  结果为-20

    这里就有一个问题

    void operator++是怎么区别前置++和后置++的呢？

    1. int operator++();//前置++
    2.     int operator++(int);//后置++
    3. //规定:()里面无参数的为前置++,否则为后置++

    注意点

    1. #include 
    2. using namespace std;
    3. class A
    4. {
    5. public:
    6.     A(int val){
    7.         _val=val;
    8.     }
    9.     void operator+(const A& d){
    10.         _val+=d._val;
    11.     }
    12.     void operator=(const A& d){
    13.         _val=d._val;
    14.     }
    15.     void Print(){
    16.         cout<<_val<
    17.     }
    18. private:
    19.     int _val;
    20. };
    21. int main()
    22. {
    23.     A a(3),b(4),c(7);
    24.     c=a=b;
    25. /*
    26. c=a=b会报错,但是a=b,不会报错
    27. 因为c=a=b这句话首先执行的是a=b,然后返回值是void
    28. 所以
    29. void operator=(const A& d){
    30.         _val=d._val;
    31.     }
    32. 应该改成
    33. A operator=(const A& d){
    34.         _val=d._val;
    35.         return *this;//这里返回值是*this的一个拷贝(拷贝的话可能调用其中的拷贝函数或者构造函数什么的)
    36.     }
    37. 所以最好写成
    38. A& operator=(const A& d){
    39.         _val=d._val;
    40.         return *this;//这里返回的是*this的别名,不会再去调用拷贝函数
    41.     }
    42. */
    43.     a.Print();
    44.     return 0;
    45. }

    8.2 流重载

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class Date
    6. {
    7. public:
    8.     Date(int year, int month, int day)
    9.     {
    10.         _year = year;
    11.         _month = month;
    12.         _day = day;
    13.     }
    14.     void operator<<(ostream &out) // out是cout的别名
    15.     {
    16.         out << _year << '/' << _month << '/' << _day << endl;
    17.     }
    18.     void operator>>(istream &in)
    19.     {
    20.         in>>_year>>_month>>_day;
    21.     }
    22.  
    23. private:
    24.     int _year, _month, _day;
    25. };
    26.  
    27. int main()
    28. {
    29.     Date a(2023, 9, 16);
    30.     a>>cin;//a是被操作的对象,cin传给in
    31.     a<
    32.     return 0;
    33. }

    const的参与

    1. #include 
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6.     Date(int year, int month, int day)
    7.     {
    8.         _year = year;
    9.         _month = month;
    10.         _day = day;
    11.     }
    12.     void Print()
    13.     {
    14.         printf("%d %d %d\n", _year, _month, _day);
    15.     }
    16.  
    17. private:
    18.     int _year, _month, _day;
    19. };
    20. int main()
    21. {
    22.     Date a(2023, 9, 17);
    23.     const Date b(1,1,1);
    24.     a.Print();
    25.     b.Print();//这里会报错
    26. /*
    27. 因为b是一个const Date类型的
    28. b.Print()的原型是b.Print(&b),&b是一个const Date*类型的
    29. void Print()的原型是void Print(Date* const this)
    30. &b从const Date*变成Date*权限放大了
    31. 所以我们将void Print()写成void Print() const,这样他的原型变成了:
    32. void Print(const Date* const this)是const Date*类型,后面那个const是修饰this
    33. 让this一直指向这个类且不能变
    34. */
    35.     return 0;
    36. }
    1. #include 
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6.     Date(int year, int month, int day)
    7.     {
    8.         _year = year;
    9.         _month = month;
    10.         _day = day;
    11.     }
    12.     void Print()const
    13.     {
    14.         printf("%d %d %d\n", _year, _month, _day);
    15.     }
    16.     bool operator<(const Date& d)
    17.     {
    18.         return _year
    19.     }
    20.  
    21. private:
    22.     int _year, _month, _day;
    23. };
    24. int main()
    25. {
    26.     Date a(2023, 9, 17);
    27.     const Date b(1,1,1);
    28.     a//不会报错
    29.     b//这里会报错
    30. /*
    31. bool operator<(const Date& d)的原型是
    32. bool operator
    33. 所以写成b
    34. b由const Date*变成Date*,权限变大
    35. 可以写成
    36. bool operator<(const Date& d)const
    37. */
    38.     return 0;
    39. }

     9.初始化列表

    初始化列表可以认为是成员变量定义的地方

    （private里面是声明）

    9.1格式

    1. #include 
    2. using namespace std;
    3. class Date
    4. {
    5. public:
    6. //格式如下
    7.     Date(int a)
    8.         : _a(a),
    9.           _b(a)
    10.     {
    11.     }
    12.     void Print()
    13.     {
    14.         cout << _a << endl;
    15.     }
    16.  
    17. private:
    18.     int _a;
    19.     int &_b;
    20. };
    21. int main()
    22. {
    23.     Date a(6);
    24.     a.Print();
    25.     return 0;
    26. }

    9.2例子

    每个成员变量在初始化列表中只能出现一次

    类中包含以下成员，必须放在初始化列表位置进行初始化

    1.引用成员变量

    2.const成员变量

    3.自定义类型成员

    1. class A
    2. {
    3. public:
    4.     A(int a)
    5.         : _a(a)
    6.     {
    7.     }
    8.     void Print()
    9.     {
    10.         cout << _a << endl;
    11.     }
    12.  
    13. private:
    14.     int _a;
    15. };
    16.  
    17. class B
    18. {
    19. public:
    20.     B(int a, int b)
    21.         : _b(b),
    22.           _a(a),
    23.           _n(10),
    24.           _r(b)
    25.     {
    26.     }
    27.     void Print()
    28.     {
    29.         _a.Print();
    30.         cout << _b << endl;
    31.     }
    32.  
    33. private:
    34.     int _b;
    35.     A _a;
    36.     const int _n;
    37.     int& _r;
    38. };

     成员变量在类中声明的次序就是其在初始化列表里面初始化的次序，与其在初始话列表里面的先后顺序无关

    例子：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class A
    6. {
    7. public:
    8.     A(int a)
    9.     :_a(a),
    10.     _b(_a)
    11.     {}
    12.     void Print()
    13.     {
    14.         cout<<_a<
    15.         cout<<_b<
    16.     }
    17. private:
    18.     int _b;
    19.     int _a;
    20. };
    21.  
    22. int main()
    23. {
    24.     A a(3);
    25.     a.Print();
    26.     return 0;
    27. }
    28. /*
    29. 输出结果是 3 随机值
    30. 因为先是把_a赋值给_b,再把a赋值给_a
    31. */

    9.3explicit关键字

    用explicit修饰的构造函数，会禁止单参构造函数的隐式转换

    首先搞明白什么是隐式转换

    1. class A
    2. {
    3. public:
    4.     A(int a)//单参构造函数
    5.         : _a(a)
    6.     {
    7.     }
    8.  
    9. private:
    10.     int _a;
    11. };
    12.  
    13. //定义一个类对象
    14. A a(10);
    15. /*
    16. 此时_a的值为10,如果进行以下操作,a=20,这样子会把_a的值变为20
    17. 编译器会用20(将20赋值给无名对象的_a)构造一个无名对象
    18. 最后用无名对象赋值给对象a,这种转换就叫隐式转换
    19. */

    隐式转换其实还有很多，比如

    int a=2;

    double b=a;

    编译器会先引入一个中间变量，类型为double，然后再将这个值赋值给b

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class A
    6. {
    7. public:
    8.     A(int a)
    9. /*
    10. 如果这里改成explicit A(int a)的话
    11. a=5那行代码会报错
    12. 因为explicit会禁止单参构造函数的隐式转换
    13. */
    14.         : _a(a)
    15.     {
    16.     }
    17.     void Print()
    18.     {
    19.         cout << _a << endl;
    20.     }
    21.  
    22. private:
    23.     int _a;
    24. };
    25.  
    26. int main()
    27. {
    28.     A a(3);
    29.     a = 5;
    30.     a.Print();
    31.     return 0;
    32. }

     9.4 匿名对象

    生命周期只有它所在的那一行

    1. class A
    2. {
    3. public:
    4.     A(int a)
    5.     :_a=a
    6.     {}
    7. private:
    8.     int _a;
    9. }; 
    10.  
    11. A a(10);
    12.     a = A(20);
    13.     a.Print();
    14.  
    15. 如果不使用匿名对象，那就需要：
    16. A a(10);
    17. A b(20);
    18. a=b;
    19. 这样子来操作
    20. /*
    21. A(20)表示创建一个匿名对象,他的_a值为20
    22. 这个匿名对象创建的时候也会调用构造函数和析构函数
    23. */

    10.友元类

    如果类A是类B的友元类，那么B可以调用A里面的private成员和protected成员

    但是这样子做会破坏类的封装性

    注意点

    1. 友元关系不能被继承

    2. 友元关系是单向的，A是B的友元，但是B不一定是A的友元

    3. 友元不具有传递性，比如A是B的友元，B是C的友元，但是A不是C的友元

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. class A
    6. {
    7. public:
    8.     friend class B;//代表A是B的友元类,B可以访问A里面的所有成员
    9.     A(int a)
    10.     {
    11.         _a=a;
    12.     }
    13. private:
    14.     int _a;
    15. };
    16.  
    17. class B
    18. {
    19. public:
    20.     B(int b)
    21.     {
    22.         _b=b;
    23.     }
    24.     void Show_A_a(A a)
    25.     {
    26.         cout<//这里就体现了可以访问A定义的对象a里面的私有成员
    27.     }
    28. private:
    29.     int _b;
    30. };
    31.  
    32. int main()
    33. {
    34.     A a(666);
    35.     B b(555);
    36.     b.Show_A_a(a);
    37.     return 0;
    38. }

    10. 2内部类

    定义：如果一个类定义在另一个类的里面，那这个里面的类就叫做内部类

    内部类是外部内的友元类，但是外部类不是内部类的友元类

    比如A是外部类，B是外部类

    那么定义一个类的时候应该A::B b;定义一个对象b，b能调用A和B里面的成员，但是如果A a，那a不能调用B里面的成员

  • 相关阅读:
    算法竞赛备赛进阶之状态机模型训练
    [java刷算法]牛客—剑指offer链表有环的入口、反转链表、合并排序链表
    JavaEE进阶（5/27）Spring Boot
    Scapy样例三则
    安卓毕业设计选题基于Uniapp实现的Android的餐饮管理系统实现的App
    Windows上安装和配置Apache Kafka
    浅谈分布式系统
    2023年首届天府杯数学建模国际大赛问题A思路详解与参考代码：大地测量数据中异常现象的特征和识别
    UI设计工具都哪些常用的，推荐这5款
    MySQL事务——事务隔离界别,MVCC
  • 原文地址：https://blog.csdn.net/pengyupan/article/details/132643287