• 【C++】继承 -- 详解

    一、继承的概念及定义

    1、继承的概念

    继承  (inheritance) 机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保 持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。
    继承呈现了面向对象 程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继 承是类设计层次的复用。 

    1. // 基类
    2. class Person
    3. {
    4. protected:
    5.     void print()
    6. 	{
    7. 		cout << "name:" << _name << endl;
    8. 		cout << "age:" << _age << endl;
    9. 	}
    10. protected:
    11.     string _name = "张三"; // 姓名
    12.     int _age = 18;  // 年龄
    13. };
    14.  
    15. // 派生类
    16. class Student : public Person
    17. {
    18. protected:
    19.     int _stuid; // 学号
    20. };
    21.  
    22. // 派生类
    23. class Teacher : public Person
    24. {
    25. protected:
    26.     int _jobid; // 工号
    27. };
    28.  
    29. int main()
    30. {
    31.     Person p;
    32. 	p.Print();
    33.  
    34.     Student s;
    35.     s.print();
    36.  
    37.     Teacher t;
    38.     t.print();
    39.  
    40.     return 0;
    41. }

    继承后父类 Person 的成员（成员函数 + 成员变量）都会变成子类的一部分。
    这里体现出了 Student 和 Teacher 复用了 Person 的成员。 

    2、继承定义

    （1）定义格式
    下面我们看到 Person 是父类，也称作基类。Student 是子类，也称作派生类。

     

    （2）继承关系和访问限定符

    继承后成员的访问权限是同时受父类的访问限定符和子类继承父类的方式影响的，也就是说互相组合一共有 9 种继承方式。 

    （3）继承基类成员访问方式的变化

    下面这个表格不需要记忆，通过理解加深印象即可。

    （红色框住的是常用的）

    【总结】
    1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。【这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是在语法上限制派生类对象不管是在类里面还是在类外面都不能去访问它。】
    2. 基类 private 成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为 protected。可以看出保护成员限定符是因继承才出现的。
    3. 实际从上面的表格种，我们总结一下可以发现，基类的私有成员在子类都是不可见的。基类的其他成员在子类的访问方式 == Min（访问方式，继承方式），public > protected > private。
    4. 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public，不过最好显示的写出继承方式。
    5. 在实际运用中一般使用都是 public（公有） 继承，几乎很少使用 protetced（保护）/ private（私有） 继承，也不提倡使用 protetced / private 继承，因为 protetced / private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

    实例演示三种继承关系下基类成员的各类型成员访问关系的变化：

    1. // 基类
    2. class Person
    3. {
    4. public :
    5.     void Print ()
    6.     {
    7.         cout << _name << endl;
    8.     }
    9. protected :
    10.     string _name ; // 姓名
    11. private :
    12.     int _age ; // 年龄
    13. };
    14.  
    15. // 派生类
    16. //class Student : protected Person
    17. //class Student : private Person
    18. class Student : public Person
    19. {
    20. protected :
    21.     int _stunum ; // 学号
    22. };
    ⚪【补充】 
    如何给基类成员设置合适的访问限定符？
    1. 基类成员想让它被所有人访问，就设置成 public【公有】。
    2. 基类成员不想让它在类外被直接访问，但需要在派生类中被访问，就设置成 protected【保护】。
    3. 基类成员不想让它在类外被直接访问，也不想让它在派生类中被访问，就设置成 private【私有】。

    二、基类和派生类对象赋值转换

    • 派生类对象可以赋值给 ① 基类的对象 / ② 基类的指针 / ③ 基类的引用。（前提是公有）这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

    • 基类对象不能赋值给派生类对象。
    • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用 RTTI（Run-Time Type Information）的 dynamic_cast 来进行识别后进行安全转换。（了解）
    1. // 基类
    2. class Person
    3. {
    4. protected :
    5.     string _name; // 姓名
    6.     string _sex;  // 性别
    7.     int _age; // 年龄
    8. };
    9.  
    10. // 派生类
    11. class Student : public Person
    12. {
    13. public :
    14.     int _id; // 学号
    15. };
    16.  
    17. void Test ()
    18. {
    19.     Student sobj ;
    20.     // 1.子类对象可以赋值给父类对象/指针/引用
    21.     Person pobj = sobj ;
    22.     Person* pp = &sobj;
    23.     Person& rp = sobj;
    24.     
    25.     // 2.基类对象不能赋值给派生类对象
    26.     sobj = pobj;
    27.     
    28.     // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    29.     pp = &sobj
    30.     Student* ps1 = (Student*)pp; // 这种情况转换是可以的
    31.     ps1->_No = 10;
    32.     
    33.     pp = &pobj;
    34.     Student* ps2 = (Student*)pp; // 这种情况转换虽然可以，但是会存在越界访问的问题
    35.     ps2->_No = 10;
    36. }

    三、继承中的作用域

    1. 在继承体系中基类和派生类都有独立的作用域。
    2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
    3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
    4. 注意在实际中在继承体系里面最好不要定义同名的成员。
    1. // Student的_num和Person的_num构成隐藏关系，虽然这样的代码虽然能跑，但是非常容易混淆
    2.  
    3. // 基类
    4. class Person
    5. {
    6. protected :
    7.     string _name = "李四"; // 姓名
    8.     int _num = 333444;   // 身份证号
    9. };
    10.  
    11. // 派生类
    12. class Student : public Person
    13. {
    14. public:
    15.     void Print()
    16.     {
    17.         cout << "姓名:" << _name << endl;
    18.         cout << "身份证号:" << Person::_num << endl; // 类名::成员显示访问
    19.         cout << "学号:" << _num << endl; // 打印的是派生类的学号
    20.     }
    21. protected:
    22.     int _num = 111222; // 学号
    23. };
    24.  
    25. int main()
    26. {
    27.     Student s1;
    28.     s1.Print();
    29.  
    30.     return 0;
    31. };

    1. class A
    2. {
    3. public:
    4.     void fun()
    5.     {
    6.         cout << "func()" << endl;
    7.     }
    8. };
    9.  
    10. class B : public A
    11. {
    12. public:
    13.     void fun(int i)
    14.     {
    15.         A::fun(); // 类名::成员 还是可以访问的
    16.         cout << "func(int i)->" << i << endl;
    17.     }
    18. };
    19.  
    20. int main()
    21. {
    22.     B b;
    23.     b.fun(10);
    24.  
    25.     return 0;
    26. };

    注意：这里要重点区分一下函数重载，首先重载是对同一作用域中才存在的概念，这里肯定不构成重载。其次隐藏的要求也和重载不同，只需要和基类成员函数同名就能构造隐藏。

     

    B 中的 fun 和 A 中的 fun 不是构成重载，因为不在同一作用域。
    B 中的 fun 和 A 中的 fun 构成隐藏，成员函数满足函数名相同就构成隐藏。 

    四、派生类的默认成员函数

    6 个默认成员函数，“默认” 的意思就是指我们不写，编译器会给我们自动生成一个，那么 在派生类中，这几个成员函数是如何生成的呢？

    1、派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。

    如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

    1. 对于继承的基类成员 ——> 把它当作一个整体，先自动调用基类的默认构造函数初始化。
    2. 对于类中的内置类型成员 ——> 不任何处理（除非声明时给了缺省值）。
    3. 对于类中的自定义类型成员 ——> 调用它的默认构造函数（不需要参数就可以调用的，比如无参构造函数或全缺省构造函数）。

    2、派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

    1. 对于继承的基类成员 ——> 把它作为一个整体，先自动调用基类的拷贝构造函数来完成拷贝初始化。
    2. 对于类中的内置类型成员 ——> 完成值拷贝。
    3. 对于类中的自定义类型成员 ——> 自动调用它的拷贝构造函数来完成拷贝初始化。

    3、派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。设计子类析构时只要保证自己的资源正确释放即可。

    1. 对于继承的基类成员 ——> 把它作为一个整体，调用基类的拷贝赋值函数来完成赋值初始化。
    2. 对于类中的内置类型成员 ——> 完成值拷贝。
    3. 对于类中的自定义类型成员 ——> 调用它的赋值重载函数来完成赋值初始化。

    4、派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。（因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。（要符合先定义的先析构））

    1. 对于继承的基类成员 ——> 把它作为一个整体，派生类的析构函数调用完成后，会自动调用基类的析构函数完成清理工作。

    2. 对于类中的内置类型成员 ——> 不处理。

    3. 对于类中的自定义类型成员 ——> 调用它的析构函数完成清理工作。

    5、派生类对象初始化先调用基类构造再调派生类构造。

    6、派生类对象析构清理先调用派生类析构再调基类的析构。

    在一些场景下，析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成 destrutor()，所以父类析构函数不加 virtual 的情况下，子类析构函数和父类析构函数构成隐藏关系。

    • 子类的析构函数在执行结束后会自动调用父类的析构函数。

      因为创建派生类对象时，先创建初始化了基类成员，再创建初始化了派生类成员。所以派生类对象析构清理先调用派生类析构函数清理派生类成员后，再调用基类析构函数清理基类成员。

    1. // 基类
    2. class Person
    3. {
    4. public :
    5.     // 默认构造函数
    6.     Person(const char* name = "Peter")
    7.         : _name(name )
    8.     {
    9.         cout << "Person()" << endl;
    10.     }
    11.     
    12.     // 拷贝构造函数
    13.     Person(const Person& p)
    14.         : _name(p._name)
    15.     {
    16.         cout << "Person(const Person& p)" << endl;
    17.     }
    18.     
    19.     // 赋值重载函数
    20.     Person& operator=(const Person& p )
    21.     {
    22.         cout << "Person operator=(const Person& p)" << endl;
    23.         if (this != &p)
    24.             _name = p ._name;
    25.         
    26.         return *this ;
    27.     }
    28.     
    29.     // 析构函数
    30.     ~Person()
    31.     {
    32.         cout << "~Person()" << endl;
    33.     }
    34. protected :
    35.     string _name ; // 姓名
    36. };
    37.  
    38. //派生类
    39. class Student : public Person
    40. {
    41. public :
    42.     // 自己实现派生类的构造函数
    43.     // 注意：继承的基类成员是作为一个整体，调用基类的构造函数进行初始化
    44.     Student(const char* name, int num)
    45.         : Person(name) // 显示调用基类的构造函数
    46.         , _num(num)
    47.     {
    48.         cout << "Student()" << endl;
    49.     }
    50.  
    51.     // 如果我们要自己实现派生类的拷贝构造，如下所示：
    52. 	// 但一般用编译器默认生成的即可，如果派生类中存在深拷贝，才需要自己实现
    53.     Student(const Student& s)
    54.         : Person(s) // 必须显示调用基类的拷贝构造（这里会发生切片）
    55.         , _num(s ._num)
    56.     {
    57.         cout << "Student(const Student& s)" << endl ;
    58.     }
    59.  
    60.     // 自己实现派生类的赋值重载函数
    61.     Student& operator = (const Student& s )
    62.     {
    63.         cout << "Student& operator= (const Student& s)" << endl;
    64.         if (this != &s)
    65.         {
    66.             Person::operator =(s); // 必须显示调用基类的赋值重载（这里会发生切片）
    67.             _num = s ._num;
    68.         }
    69.         return *this ;
    70.     } 
    71.  
    72.     ~Student() // 先清理自己的资源
    73.     {
    74.         cout << "~Student()" << endl;
    75.     } // 结束后会自动调用父类的析构函数
    76. protected :
    77.     int _num ; //学号
    78. };
    79.  
    80. int main()
    81. {
    82.     Student s1 ("Jack", 18);// 调用构造函数
    83.     Student s2 (s1); // 调用拷贝构造函数
    84.     Student s3 ("Rose", 17);
    85.     s1 = s3 ; // 调用重载赋值函数
    86.  
    87.     return 0;
    88. }

    五、继承与友元

    友元关系 不能 继承，也就是说基类友元不能访问子类私有和保护成员。 
    1. class Student;
    2.  
    3. // 基类
    4. class Person
    5. {
    6. public:
    7.     friend void Display(const Person& p, const Student& s); // 声明该函数是基类的友元
    8. protected:
    9.     string _name; // 姓名
    10. };
    11.  
    12. // 派生类
    13. class Student : public Person
    14. {
    15. protected:
    16.     int _stuNum; // 学号
    17. };
    18.  
    19. void Display(const Person& p, const Student& s)
    20. {
    21.     cout << p._name << endl; // 你是基类的友元，访问基类对象是可以的
    22.     cout << s._stuNum << endl; // 友元不继承你不能访问派生类对象，这里会报错，显示不可访问
    23. }
    24.  
    25. int main()
    26. {
    27.     Person p;
    28.     Student s;
    29.     Display(p, s);
    30.  
    31.     return 0;
    32. }

    六、继承与静态成员

    基类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个 static 成员实例 。 
    1. //无论继承多少层，大家用的始终是同一个变量
    2.  
    3. // 基类
    4. class Person
    5. {
    6. public :
    7.     Person () {++ _count ;}
    8. protected :
    9.     string _name ; // 姓名
    10. public :
    11.     static int _count; // 统计人的个数
    12. };
    13.  
    14. int Person :: _count = 0;
    15. class Student : public Person
    16. {
    17. protected :
    18.     int _stuNum ; // 学号
    19. };
    20.  
    21. class Graduate : public Student
    22. {
    23. protected :
    24.     string _seminarCourse ; // 研究科目
    25. };
    26.  
    27. void TestPerson()
    28. {
    29.     Student s1 ;
    30.     Student s2 ;
    31.     Student s3 ;
    32.     Graduate s4 ;
    33.     cout << " 人数 :" << Person ::_count << endl;
    34.     Student ::_count = 0;
    35.     cout << " 人数 :" << Person ::_count << endl;
    36. }

    七、复杂的菱形继承及菱形虚拟继承

    1、单继承：一个子类只有一个直接父类时称这个继承关系为单继承。

     

    2、多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承。

    3、菱形继承：菱形继承是多继承的一种特殊情况。

    菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有 数据冗余 和 二义性 的问题。 在 Assistant 的对象中 Person 成员会有两份。

     

    1. class Person
    2. {
    3. public :
    4.     string _name ; // 姓名
    5. };
    6.  
    7. class Student : public Person
    8. {
    9. protected :
    10.     int _num ; //学号
    11. };
    12.  
    13. class Teacher : public Person
    14. {
    15. protected :
    16.     int _id ; // 职工编号
    17. };
    18.  
    19. class Assistant : public Student, public Teacher
    20. {
    21. protected :
    22.     string _majorCourse ; // 主修课程
    23. };
    24.  
    25. int main()
    26. {
    27.     // 这样会有二义性无法明确知道访问的是哪一个
    28.     Assistant a ;
    29.     a._name = "Peter";
    30.     // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    31.     a.Student::_name = "xxx";
    32.     a.Teacher::_name = "yyy";
    33.  
    34.     return 0;
    35. }
    虚拟继承 可以解决菱形继承的二义性和数据冗余的问题。
    如上面的继承关系，在 Student 和  Teacher 的继承 Person 时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地 方去使用。
    注意：virtual 不是在 Assistant 处加，而是在菱形中间腰部 (Student 和 Teacher) 的位置加。 
    1. class Person
    2. {
    3. public :
    4.     string _name ; // 姓名
    5. };
    6.  
    7. class Student : virtual public Person
    8. {
    9. protected :
    10.     int _num ; //学号
    11. };
    12.  
    13. class Teacher : virtual public Person
    14. {
    15. protected :
    16.     int _id ; // 职工编号
    17. };
    18.  
    19. class Assistant : public Student, public Teacher
    20. {
    21. protected :
    22.     string _majorCourse ; // 主修课程
    23. };
    24.  
    25. int main()
    26. {
    27.     Assistant a ;
    28.     a._name = "Peter"; //这个时候_name其实只有一个
    29.  
    30.     // 这下面两个显示访问其实访问的都是一个变量
    31.     a.Student::_name = "xxx";
    32.     a.Teacher::_name = "yyy";
    33.  
    34.     return 0;
    35. }
    虚拟继承解决数据冗余和二义性的原理。
    为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成 员的模型。 
    1. class A
    2. {
    3. public:
    4.     int _a;
    5. };
    6.  
    7. // class B : public A
    8. class B : virtual public A
    9. {
    10. public:
    11.     int _b;
    12. };
    13.  
    14. // class C : public A
    15. class C : virtual public A
    16. {
    17. public:
    18.     int _c;
    19. };
    20.  
    21. class D : public B, public C
    22. {
    23. public:
    24.     int _d;
    25. };
    26.  
    27. int main()
    28. {
    29.     D d;
    30.     d.B::_a = 1;
    31.     d.C::_a = 2;
    32.     d._b = 3;
    33.     d._c = 4;
    34.     d._d = 5;
    35.  
    36.     return 0;
    37. }

    下图是菱形继承的内存对象成员模型：这里可以看到数据冗余。

    下图是菱形虚拟继承的内存对象成员模型：这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个 A 同时属于 B 和 C，那么 B 和 C 如何去找到公共的 A 呢？
    这里是通过了 B 和 C 的两个指针，指向的一张表，这张表是什么呢？
    B 和 C 中还各自多了 4 个字节的地址，我们再通过其它内存窗口查看 B 和 C 中那两个地址放的到底是什么，发现 B 和 C 中各自那所谓多余的 4 个字节指向的空间中存储了 十进制：20（十六进制：14 00 00 00） 和 十进制：12（十六进制：0c 00 00 00），其实它们一点都不多余，其代表的含义是对于 A 的偏移量 —— 0x005EF75C + 20 = 0x005EF770；0x005EF764 + 14 = 0x005EF770；，官方来讲对于 0x005EF75C 和 0x005EF764 所指向的内存 2 和内存 3，称之为虚基表。
    这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 A。

    为什么 D 中 B 和 C 部分要去找属于自己的 A ？那么看看当下面的赋值发生时，d 是不是要去找出 B/C 成员中的 A 才能赋值过去？
    1. D d;
    2. B b;
    3. B* p1 = &d; // B对象指针 -> D对象，把D对象切片给B对象指针
    4. p1->_a;     // 指针访问虚基类A的成员＿ａ
    5. B* p2 = &b; // B对象指针 -> B对象
    6. p2->_a;     // 指针访问虚基类A的成员＿ａ
    （1）为什么需要偏移量？ 

    指针是无法识别自己指向的是哪个类的对象，即可能指向自己，也可能指向子类，比如上面这段代码，B 对象和 D 对象中的虚基类成员 _a 的偏移量是不一样的，所以我们也只能通过偏移量来计算出 _a 的位置。

    B 或 C 的对象、对象指针、对象引用访问继承的虚基类 A 的对象中的成员 _a，都要取偏移量计算 _a 的位置。

    （2）为什么不在 0x005EF75C、0x005EF764 直接存偏移量？

    这样也是可以的，但是使用虚基表来存储的原因是：

    还有其它场景 —— 在引入多态时 0x00BC5F50 和 0x00BC5F5C 处还需要再存储一个值。

    （3）virtual 已经能解决菱形继承所带来的问题了，为什么还是不建议使用？

    在解决问题的同时，效率也降低了，它的这个对象模型变的更加复杂。之前是编译器编译完直接就可以找到，因为它们是紧挨着的，而现在却必须得通过指针来找到偏移量，再与现在的地址进行相加才可以找到。

    下面是上面的 Person 关系菱形虚拟继承的原理解释：

    八、继承的总结和反思

    1. 很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
    2. 多继承可以认为是 C++ 的缺陷之一，很多后来的 OO 语言都没有多继承，如 Java。
    3. 继承和组合
    • public 继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。
    • 组合是一种 has-a 的关系。假设 B 组合了 A，每个 B 对象中都有一个 A 对象。
    • 优先使用 对象组合 ，而不是类继承 。
    可参考下面这篇博客：

            继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用（white-box reuse）。术语 “白箱” 是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

            对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为 黑箱复用 （black-box reuse），因为对象的内部细节是不可见的。对象只以 “黑箱” 的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
            实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有
    些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。 
    1. // Car和BMW Car和Benz构成is-a的关系
    2. class Car{
    3. protected:
    4.     string _colour = "白色"; // 颜色
    5.     string _num = "粤DK0896"; // 车牌号
    6. };
    7.    
    8. class BMW : public Car{
    9. public:
    10.     void Drive()
    11.     {
    12.         cout << "好开-操控" << endl;
    13.     }
    14. };
    15.    
    16. class Benz : public Car{
    17. public:
    18.     void Drive()
    19.     {
    20.         cout << "好坐-舒适" << endl;
    21.     }
    22. };
    23.    
    24. // Tire和Car构成has-a的关系
    25. class Tire{
    26. protected:
    27.     string _brand = "Michelin"; // 品牌
    28.     size_t _size = 17;          // 尺寸
    29. };
    30.    
    31. class Car{
    32. protected:
    33.     string _colour = "白色";  // 颜色
    34.     string _num = "粤DK0896"; // 车牌号
    35.     Tire _t; // 轮胎
    36. };
  • 相关阅读:
    uniapp实现发送获取验证码
    redis报错 Error getaddrinfo ENOTFOUND
    postgresql|数据库|数据迁移神器ora2pg的安装部署和初步使用
    渡众机器人自动驾驶小车运行Autoware 实现港口物流运输
    Open3D 二维图像读取与写入
    git项目管理中如何fork别人的代码以及如何拉取最新的源项目代码
    孙卫琴的《精通Vue.js》读书笔记-插槽slot的基本用法
    计算机内功内功修炼：信息的表示与和处理
    JAVA基于微信小程序的校园信息共享平台毕业设计-附源码211615
    云课五分钟-04一段代码学习-大模型分析C++
  • 原文地址：https://blog.csdn.net/weixin_74531333/article/details/133560695