C++入门——12继承

于 2024-08-18 23:53:22 发布
阅读量589 收藏 6
点赞数 3
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56989421/article/details/141302255
版权

1.继承

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

class Person
{
public:
    void Print()
    {
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    }
protected:
    string _name = "peter"; // 姓名
    int _age = 18;  // 年龄
};

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

class Student : public Person
 {
 protected:
     int _stuid; // 学号
};

class Teacher : public Person
{
protected:
     int _jobid; // 工号
};
 
int main()
{
     Student s;
     Teacher t;
     s.Print();
     t.Print();
     return 0;
}

//name:peter
//age:18
//name:peter
//age:18

2 继承的定义

2.1格式

Person是父类，也称作基类。Teacher是子类，也称作派生类。

2.2继承关系和访问限定符

类成员/继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected 成员派生类的private 成员
基类的protected 成员派生类的protected成员派生类的protected 成员派生类的private 成员
基类的private成 员在派生类中不可见在派生类中不可见在派生类中不可见

  • 基类 private 成员的访问：

    • 基类中的 private 成员在派生类中确实是不可见的。无论继承方式如何，这些成员对派生类都是不可访问的。
    • 如果需要在派生类中访问这些成员，可以通过基类提供 protected 或 public 方法间接访问，或者在基类中提供友元类或友元函数。

  • 基类 protected 成员的访问：

    • 基类中的 protected 成员在派生类中是可访问的，允许派生类访问和修改这些成员，但它们在派生类外部仍然不可见。
    • protected 成员的访问权限是为了支持派生类访问，限制了直接外部访问。

  • 继承方式与访问控制：

    • 基类的 private 成员在子类中是不可见的，protected 成员在子类中可见。实际访问方式取决于基类成员的访问修饰符和继承方式的组合。
    • 继承方式（public、protected、private）会影响基类成员在派生类中的访问级别。通常，public 继承使基类的 public 成员保持 public，protected 继承使基类的 public 和 protected 成员都变为 protected，private 继承则使基类的所有 public 和 protected 成员都变为 private。

  • 默认继承方式：

    • class 默认使用 private 继承。
    • struct 默认使用 public 继承。
    • 明确指定继承方式可以提高代码的可读性和维护性，避免由于默认继承方式带来的混淆。

  • 继承的使用建议：

    • 在实际编程中，public 继承是最常用的，因为它能够支持广泛的代码复用和接口设计。
    • protected 和 private 继承通常用于更特殊的场景，比如在实现某些设计模式时。protected 继承可以防止外部代码直接使用基类的接口，而 private 继承则主要用于实现内部细节的封装。

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

class Person
{
public :
    void Print ()
    {
        cout<<_name <<endl;
    }

protected :
    string _name ; // 姓名

private :
    int _age ; // 年龄
};
  • public 继承
class Student : public Person
{
protected:
    int _stunum; // 学号
};


Student s;
s.Print(); // 可以访问
// s._name; // 不可访问，编译错误
// s._age; // 不可访问，编译错误
  • protected 继承
class Student : protected Person
{
protected:
    int _stunum; // 学号
};


Student s;
// s.Print(); // 不可访问，编译错误
// s._name; // 不可访问，编译错误
// s._age; // 不可访问，编译错误
  • private 继承
  • class Student : private Person
{
protected:
    int _stunum; // 学号
};


Student s;
// s.Print(); // 不可访问，编译错误
// s._name; // 不可访问，编译错误
// s._age; // 不可访问，编译错误

    3.基类和派生类对象赋值转换

  • 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
  • 基类对象不能赋值给派生类对象。
  • 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。

3.1. 对象切片（Object Slicing）

  • 当派生类对象赋值给基类对象时，只有派生类中的基类部分会被复制，这个过程称为“切片”。
  • 切片后的基类对象不再包含派生类独有的数据和行为，只保留基类部分的内容。
class Base {
public:
    int baseVar;
};

class Derived : public Base {
public:
    int derivedVar;
};

Derived d;
d.baseVar = 1;
d.derivedVar = 2;

Base b = d;  // 切片，Base 对象只保留 baseVar，丢失 derivedVar

3.2. 基类对象不能赋值给派生类对象

基类对象不包含派生类的所有信息，因此无法赋值给派生类对象。这会导致派生类独有的成员无法初始化或被错误地初始化。

3.3指针和引用的类型转换

向上转换（Upcasting）：派生类的指针或引用可以赋值给基类的指针或引用。这是安全的，因为派生类总是包含基类的部分。

Derived* d = new Derived();
Base* b = d;  // 向上转换

向下转换（Downcasting）：基类的指针或引用可以通过强制类型转换赋值给派生类的指针或引用，但前提是这个基类指针或引用实际指向的是派生类的对象，否则会导致未定义行为。

  • 在多态情况下，可以使用 dynamic_cast 进行向下转换，并通过 RTTI 确保转换的安全性：
Base* b = new Derived();  //这个基类指针或引用实际指向的是派生类的对象
Derived* d = dynamic_cast<Derived*>(b);  // 安全的向下转换

if (d != nullptr) {
    // 转换成功，可以安全使用 d
}
  • RTTI（Run-Time Type Information）：C++ 提供了 dynamic_cast 来在运行时检查和转换类型。dynamic_cast 只能用于多态类型（即至少有一个虚函数的类），它会在类型不匹配时返回 nullptr。

4.继承中的作用域

4.1. 独立的作用域

  • 在 C++ 中，基类和派生类各自拥有独立的作用域。这意味着即使在派生类中定义了与基类同名的成员，它们也属于不同的作用域。
  • 由于作用域不同，在派生类中定义的同名成员会“隐藏”基类的成员，这种隐藏可以通过显式指定作用域来解决。

4.2. 成员隐藏（Name Hiding）

  • 当子类和父类有同名成员时，子类的成员会隐藏父类的同名成员。这种隐藏机制适用于成员变量和成员函数。
  • 访问隐藏成员：如果需要访问被隐藏的基类成员，可以使用 基类名::成员名 的形式来访问。 
     
    class Base {
public:
    int value = 10;
    void display() { cout << "Base display" << endl; }
};

class Derived : public Base {
public:
    int value = 20;  // 隐藏了 Base::value
    void display() { cout << "Derived display" << endl; }  // 隐藏了 Base::display()
};

Derived d;
cout << d.value << endl;          // 输出 20，访问的是 Derived::value
cout << d.Base::value << endl;    // 输出 10，访问的是 Base::value

d.display();                      // 输出 "Derived display"
d.Base::display();                // 输出 "Base display"

     
     
 

4.3. 成员函数的隐藏
 

  • 成员函数的隐藏仅仅依赖于函数名是否相同，而不考虑参数列表（即使参数列表不同，基类的函数依然会被隐藏）。
  • 这种情况在函数重载和继承结合时容易导致混淆，因此在派生类中重新定义基类函数时需要特别小心。
 

4.4. 避免同名成员
 

  • 在实际开发中，尽量避免在继承体系中定义同名成员，尤其是函数和变量。这不仅可以减少隐藏问题，也可以提升代码的可读性和维护性。
 

5.派生类的默认成员函数
 

5.1. 构造函数
 

  • 在派生类的构造函数中，必须先调用基类的构造函数来初始化基类部分。如果基类没有默认构造函数，必须在派生类的初始化列表中显式调用基类的构造函数。
 

class Base {
public:
    Base(int x) : value(x) {}
protected:
    int value;
};

class Derived : public Base {
public:
    Derived(int x, int y) : Base(x), derivedValue(y) {}
protected:
    int derivedValue;
};

 

5.2. 拷贝构造函数
 

  • 派生类的拷贝构造函数会调用基类的拷贝构造函数，以确保基类部分被正确复制。
 

Derived(const Derived& other) : Base(other), derivedValue(other.derivedValue) {}

 

5.3. 赋值运算符 operator=
 

  • 派生类的赋值运算符必须调用基类的赋值运算符来处理基类部分的赋值。通常是在派生类的赋值操作中先调用基类的赋值运算符，然后再处理派生类自身的数据成员。
 

Derived& operator=(const Derived& other) {
    if (this != &other) {
        Base::operator=(other); // 调用基类的赋值运算符
        derivedValue = other.derivedValue;
    }
    return *this;
}

 

5.4. 析构函数
 

  • 派生类的析构函数在执行完派生类的清理工作后，自动调用基类的析构函数，确保基类部分也被正确清理。这种顺序确保资源的释放顺序与分配顺序相反。
 

~Derived() {
    // 派生类的清理工作
    // 自动调用基类的析构函数
}

 

5.5. 构造和析构顺序
 

  • 构造函数的调用顺序是：先调用基类构造函数，再调用派生类构造函数。
  • 析构函数的调用顺序则相反：先调用派生类析构函数，再调用基类析构函数。
 

5.6. 析构函数的隐藏与重写
 

  • 如果基类析构函数没有声明为 virtual，派生类的析构函数会隐藏基类的析构函数。这意味着通过基类指针删除派生类对象时，只有基类部分会被释放，可能导致资源泄露。因此，如果类可能作为基类使用，析构函数通常应声明为 virtual。
 

class Base {
public:
    virtual ~Base() {} // 推荐用法
};

class Derived : public Base {
public:
    ~Derived() {} // 派生类析构函数
};

 

6.继承与友元
 

  • 友元关系不受继承方式的影响，友元函数和友元类可以访问被友元声明类的所有成员。基类的友元函数或友元类不能访问派生类的私有或受保护成员，除非在派生类中重新声明它们为友元。友元关系在继承层次中是不可传递的。
 

#include <iostream>
using namespace std;

class Student;  // 前向声明

class Person {
public:
    Person(const string& name = "") : _name(name) {}
    friend void Display(const Person& p, const Student& s);  // 友元函数声明
protected:
    string _name;  // 姓名
};

class Student : public Person {
public:
    Student(const string& name = "", int stuNum = 0) : Person(name), _stuNum(stuNum) {}
protected:
    int _stuNum;  // 学号
};

void Display(const Person& p, const Student& s) {
    cout << "Name: " << p._name << endl;
    cout << "Student Number: " << s._stuNum << endl;
}

int main() {
    Person p("Alice");
    Student s("Bob", 12345);
    Display(p, s);
    return 0;
}

 

 

 

 

7.继承与静态成员
 

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子
 类，都只有一个static成员实例 。
 

#include <iostream>
using namespace std;

class Person {
public:
    Person() { ++_count; }  // 构造函数中增加计数
    static int _count;     // 静态数据成员声明
protected:
    string _name;         // 姓名
};

int Person::_count = 0;  // 静态数据成员定义

class Student : public Person {
protected:
    int _stuNum;          // 学号
};

class Graduate : public Student {
protected:
    string _seminarCourse; // 研究科目
};

void TestPerson() {
    Student s1;
    Student s2;
    Student s3;
    Graduate s4;
    
    // 输出人数
    cout << "人数: " << Person::_count << endl;  //4
    
    // 注意: 直接访问和修改 Person::_count 是有效的，因为静态数据成员是共享的
    // Student::_count = 0;  // 这行代码实际上不影响 Person::_count，因为静态数据成员是共享的
    
    // 重置静态数据成员 (这行代码将 Person::_count 设置为0)
    Person::_count = 0;
    
    // 输出人数
    cout << "人数: " << Person::_count << endl;  //0
}  

int main() {
    TestPerson();
    return 0;
}

 

 

 

8.复杂的菱形继承及菱形虚拟继承
 

 

 

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

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

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

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

 

class Person
{
public :
    string _name ; // 姓名
};

class Student : public Person
{
protected :
    int _num ; //学号
};
class Teacher : public Person
{
protected :
    int _id ; // 职工编号
};

class Father : public Student, public Teacher
{
protected :
    string _childname ; // 孩子名字
};
void Test ()
{
    // 这样会有二义性无法明确知道访问的是哪一个
    Father a ;
    a._name = "peter";
    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}
 

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。
 

class Person
{
public :
    string _name ; // 姓名
};

class Student : virtual public Person
{
protected :
    int _num ; //学号
};

class Teacher : virtual public Person
{
protected :
    int _id ; // 职工编号
};

class father : public Student, public Teacher
{
protected :
    string _childname ; 
};
void Test ()
{
    Assistant a ;
    a._name = "peter";
}
 

8.1虚拟继承解决数据冗余和二义性的原理
 

 

在内存中，A的内存地址会在D后面，这里B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
 

 

 

9.继承vs组合
 

  •  
    继承（is-a）每个派生类对象都是一个基类对象。：
     
  
    • 特点：派生类是基类的一种类型，继承基类的接口和实现。继承实现了类的复用，但可能会破坏基类的封装。
    • 优点：简单直接，适合实现明确的“是一个”关系。例如，Cat 是 Animal 的一种。
    • 缺点：耦合度高，基类的变化可能影响到所有派生类。继承可能导致复杂的继承层次结构（如菱形继承）。
 

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

class Shape {
public:
    Shape(const string& color) : _color(color) {}
    virtual void draw() const = 0; // 纯虚函数，强制子类实现
protected:
    string _color; // 颜色属性
};

class Circle : public Shape {
public:
    Circle(const string& color, double radius)
        : Shape(color), _radius(radius) {}
    void draw() const override {
        cout << "Drawing a " << _color << " circle with radius " << _radius << endl;
    }
private:
    double _radius;
};

class Rectangle : public Shape {
public:
    Rectangle(const string& color, double width, double height)
        : Shape(color), _width(width), _height(height) {}
    void draw() const override {
        cout << "Drawing a " << _color << " rectangle with width " << _width << " and height " << _height << endl;
    }
private:
    double _width, _height;
};

int main() {
    Circle c("red", 5.0);
    Rectangle r("blue", 4.0, 6.0);
    
    c.draw();
    r.draw();
    
    return 0;
}

 

  •  
    组合（has-a）假设B组合了A，每个B对象中都有一个A对象：
     
  
    • 特点：类通过包含其他类的对象来实现功能，强调“有一个”关系。组合对象的内部细节对外部是隐藏的。
    • 优点：低耦合度，组合对象的变化不会影响到其他类。组合支持更灵活的设计，符合“黑箱复用”原则。
    • 缺点：组合可能需要更多的代码来实现对象之间的协调和交互。
 

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

class Color {
public:
    Color(const string& color) : _color(color) {}
    string getColor() const { return _color; }
private:
    string _color;
};

class Shape {
public:
    Shape(const Color& color) : _color(color) {}
    virtual void draw() const = 0; // 纯虚函数，强制子类实现
protected:
    Color _color; // 通过组合来管理颜色
};

class Circle : public Shape {
public:
    Circle(const Color& color, double radius)
        : Shape(color), _radius(radius) {}
    void draw() const override {
        cout << "Drawing a " << _color.getColor() << " circle with radius " << _radius << endl;
    }
private:
    double _radius;
};

class Rectangle : public Shape {
public:
    Rectangle(const Color& color, double width, double height)
        : Shape(color), _width(width), _height(height) {}
    void draw() const override {
        cout << "Drawing a " << _color.getColor() << " rectangle with width " << _width << " and height " << _height << endl;
    }
private:
    double _width, _height;
};

int main() {
    Color red("red");
    Color blue("blue");
    
    Circle c(red, 5.0);
    Rectangle r(blue, 4.0, 6.0);
    
    c.draw();
    r.draw();
    
    return 0;
}

 

  • 则设计原 
  
    • 优先使用组合：组合提供了更多的灵活性和更低的耦合度。通过组合，你可以创建更复杂的对象而不依赖于继承体系的复杂性。
    • 合理使用继承：当类之间存在明确的“is-a”关系，并且继承不会导致过度的耦合和复杂性时，继承是合适的选择。继承在实现多态和共享行为时是必要的。
    • 理解封装：组合支持更好的封装，因为对象的内部实现对外部是隐藏的，而继承可能暴露了基类的内部实现。
 

 

 

 


                

        

        

    




            

                    
            

    

      

        

            

              
                
                  木木没有哒
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    3
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    6
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
c++入门实验及源码集合.zip

				
			

			

				

					05-14
				

			

		

		

			
				
"C++入门实验及源码集合.zip" 文件提供了一个优秀的学习资源，包含了通过实践来理解C++基本概念和编程技巧的实验项目。  这个压缩包主要分为6大类实验，旨在覆盖C++编程的基础到进阶内容。以下是对这些实验类别可能...

			
		

	



                

              
                



	

		

			

				
					
C++入门视频教程-13

				
			

			

				

					03-16
				

			

		

		

			
				
本视频教程是针对初学者设计的C++入门课程，旨在帮助学习者掌握C++的基础知识，为后续深入学习打下坚实基础。  在"1-15集"中，你将初步接触到C++编程的基础概念。这包括： 1. **编程环境**：如何安装并配置C++编译器...

			
		

	



                


  
              

                


	

		

			

				
					
C++入门——面向对象

				
			

			

				

					beilizhang的博客
				

				

					07-18
					
					2262
					
				

			

		

		

			
				
面向对象
面向对象与面向过程，即对象


面向对象把数据即对数据的操作方法放在一起，作为一个相互依存的整体，即对象。对同类对象抽象出其共性，即类，类中的大多数数据都只能被本类的方法进行处理。类通过一个简单的外部接口与外界发生关系，对象与对象之间通过消息进行通信。抽象流程由用户在使用中决定


面向过程是一个以事件为中心的开发方法，就是自顶向下顺序执行，逐步求精，其程序结构是按功能划分为若干个基本模块，这些模块形成一个树状结构，各模块之间的关系也比较简单，在功能上相互独立，每一模块内部都是由顺序、选择和循环三

			
		

	





	

		

			

				
					
C++入门——虚函数

				
			

			

				

					beilizhang的博客
				

				

					07-18
					
					1078
					
				

			

		

		

			
				
虚函数
虚函数是面向对象编程中函数的一种特定形态，是C++中用于实现多态的一种有效机制
什么是虚函数
指向基类的指针在操作它的多态对象时，会根据不同的类对象调用相应的对象函数，这个函数就是虚函数，虚函数用virtual修饰函数名。虚函数的作用是在程序的运行阶段动态地选择合适的成员函数，定义了虚函数后，可以在派生类中对虚函数重新定义。在派生类中重新定义的函数应与基类的虚函数具有相同的形参个数和形参类型（参数类型顺序也要一致），以实现统一的接口。如果在派生类中没有对虚函数重新定义，则它继承基类的虚函数
使用虚函

			
		

	



		

			
		



	

		

			

				
					
C++——继承

				
			

			

				

					花想云的博客
				

				

					05-31
					
					853
					
				

			

		

		

			
				
在C++中，既然将之取名为继承，自然是因为与现实中的继承有某些相似的地方。

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

			
		

	





	

		

			

				
					
C++入门——struct与class

				
			

			

				

					beilizhang的博客
				

				

					07-14
					
					188
					
				

			

		

		

			
				
struct与class
C语言中的struct与union的区别


union中所有成员共用一块地址空间，即union只存放了一个被选中的成员，而struct所有成员占用空间是累加的，其所有成员都存在，不同成员会存放在不同的地址。struct的内存空间大小等于所有成员的长度之和（需要考虑字节对齐），而union变量的长度等于其最长的成员的长度


对于union的不同成员赋值，会对它的其他成员重写，原来成员的值就不存在了，而对struct的不同成员赋值是互不影响的


C和C++中struct的区别



			
		

	





	

		

			

				
					
c++入门学习⑦——继承和多态（超级详细版）

				
			

			

				

					2301_79328557的博客
				

				

					02-20
					
					2503
					
				

			

		

		

			
				
基类：被继承的类，又称为“父类”派生类：继承其他类的类，又称为“子类”简单来说：普通的成员前加上一个static关键字，就被称为静态成员。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。被关键字virtual修饰的类成员函数，而且子类中要重写虚函数（可加virtual也可不加）同一作用城，同名函教，参数的顺序，个数，类型不同都可以重载。函数的返回值类型不能作为重载条件（函数重载，运算行重载）有继承，子类重定义父亲的同名函数（非虚函数。

			
		

	





	

		

			

				
					
C++入门视频教程-18

				
			

			

				

					03-16
				

			

		

		

			
				
本套"C++入门视频教程-18"主要围绕一个实际应用案例——机房预约系统，通过一系列的教学视频，深入浅出地介绍了C++编程的基础知识和实战技巧。在这个系统中，涉及了对象的创建、类的设计、数据的存储与访问等多个...

			
		

	





	

		

			

				
					
C++入门教程视频-7

				
			

			

				

					03-05
				

			

		

		

			
				
《C++入门教程视频-7》是黑马程序员提供的一个C++学习资源，主要涵盖了C++中的核心概念——类和对象的封装以及相关的高级特性。在这个系列教程中，讲解了如何利用C++进行面向对象编程，以下是对每个视频文件名所对应...

			
		

	





	

		

			

				
					
01第1章 初识C++——C++程序设计入门

				
			

			

				

					12-01
				

			

		

		

			
				
本章"初识C++——C++程序设计入门"是学习C++之旅的起点，旨在为初学者构建坚实的基础。  首先，C++程序的基本结构通常包括预处理指令、函数定义、变量声明和控制流语句。预处理指令以`#`开头，如`#include`用于引入...

			
		

	





	

		

			

				
					
C++匿名函数lamba简介

				
			

			

				

					yao_tao11的博客
				

				

					08-18
					
					512
					
				

			

		

		

			
				
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]

			
		

	





	

		

			

				
					
c++编程（22）——STL（6）set

				
			

			

				

					2301_77239666的博客
				

				

					08-16
					
					1030
					
				

			

		

		

			
				
欢迎来到博主的专栏——c++编程博主ID：代码小豪。

			
		

	





	

		

			

				
					
【漫谈C语言和嵌入式011】嵌入式系统中常用的校验方式

					
最新发布

				
			

			

				

					2403_83044722的博客
				

				

					08-18
					
					338
					
				

			

		

		

			
				
在嵌入式系统中，选择合适的校验方式取决于应用场景的需求。简单的数据传输可以使用奇偶校验或校验和，而对于更复杂、更可靠的数据传输，CRC和汉明码则是更好的选择。

			
		

	





	

		

			

				
					
C++ | Leetcode C++题解之第337题打家劫舍III

				
			

			

				

					Ddddddd_158的博客
				

				

					08-15
					
					334
					
				

			

		

		

			
				
C++ | Leetcode C++题解之第337题打家劫舍III

			
		

	





	

		

			

				
					
C语言典型例题43

				
			

			

				

					2302_77517102的博客
				

				

					08-18
					
					276
					
				

			

		

		

			
				
有一个函数：y={x,x

			
		

	





	

		

			

				
					
【C语言】字符串操作函数详解

				
			

			

				

					EleganceJiaBao的博客
				

				

					08-14
					
					1033
					
				

			

		

		

			
				
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。

			
		

	





	

		

			

				
					
C++_基本语法笔记_模板

				
			

			

				

					qq_45629864的博客
				

				

					08-14
					
					431
					
				

			

		

		

			
				
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。

			
		

	





	

		

			

				
					
C++编译器对类模板的按需实例化

				
			

			

				

					2301_76197086的博客
				

				

					08-16
					
					124
					
				

			

		

		

			
				
简析C++类模板的按需实例化

			
		

	





	

		

			

				
					
typdef 与 struct

				
			

			

				

					ligreenjian的博客
				

				

					08-14
					
					129
					
				

			

		

		

			
				
int age;int num;//每使用一次就要多一个struct。使用typdef就简洁些。

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值