C++ 继承

已于 2024-09-10 21:38:58 修改
阅读量652 收藏 14
点赞数 17
分类专栏： C++ 文章标签： c++
于 2024-08-12 00:12:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kjl167/article/details/141108212
版权

C++ 继承

一、继承概念与语法

1.1 继承是什么

 继承（Inheritance）是面向对象编程程序设计（OOP）的一个重要特征。它允许一个类（派生类）继承另一个类（基类）的属性和方法，并可以在此基础上修改已有的功能或增加新的功能。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程，继承是类设计层次的代码复用。

1.2 继承语法

class <派生类名>: [继承方式] <基类名>    // 单继承
{
	// member list
};

class <派生类名>: [继承方式] <基类名1>, [继承方式] <基类名2>,...   // 多继承
{
	// member list
};

单继承：只有一个基类
多继承：有两个或两个以上基类

继承方式：public、protected、private三种，不指定时使用默认继承方式（不推荐）。
a. 对于class，默认继承方式是private
b. 对于struct，默认继承方式是public

1.3 访问控制

继承方式与访问限定符共同决定了基类成员在派生类中的可见性。

类成员\继承方式public继承protected继承private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见
class Person 
{
public :
    void print() const 
    {
        cout << "name：" << _name << " age: " << _age << endl;
    }

    void set_name(const string &name) { _name = name; };

    void set_age(int age) { _age = age; };

protected:
    void eat() const { cout << "eating" << endl; }

private :
    string _name;
    int _age;
};

class Student : public Person 
{
public:
    void students_eat() { eat(); };
private:
    int _id;
};

int main() {
    Student s;
    s._name = "张三"; // 错误，public继承，但_name在基类为private成员，所以在派生类不可见
    s._age = 10; // 错误，同上
    s.set_name("张三"); // 正确，public继承，set_name在基类为public成员，所以在派生类为public
    s.set_age(18); // 正确，同上
    s.print(); // 正确，同上
    s.eat(); // 错误，public继承，但eat在基类为protected成员，所以在派生类为protected,只能在类里面调用该函数
    s.students_eat(); // 正确
    
    return 0;
}

在这里插入图片描述

问题：不管使用什么继承方式，基类中private的成员在派生类中是不可见的，为什么派生类还要含有这些不可见的成员？

  1. 虽然派生类不能直接访问基类的private成员，但基类可以提供public或protected的方法（方法里面访问private成员）。当派生类调用基类的这些方法时，它会间接访问或修改基类的private成员，所以派生类要含有这些不可见成员。
  2. 为保证对象模型的一致性。如果派生类不包含基类的private成员，那么派生类的对象在内存布局上就会与基类的对象不同，这会导致继承体系中的类型兼容性问题。在派生类中保留基类的私有成员，可以确保派生类对象在内存中包含基类对象的所有部分，这使得基类指针或引用可以安全地指向派生类对象，以及通过派生类对象构造出基类对象。

1.4 继承中的作用域

 在继承体系中,基类和派生类都有独立的作用域，如果派生类定义了与基类同名的成员（变量和函数），则基类的同名成员会被隐藏（shadowed），派生类默认访问的是自身的成员，如要访问基类的成员,需要显式指定基类作用域。

语法: 基类名::成员名

注意：

  • 对于变量来说，同名即构成隐藏。
  • 对于函数来说，如果基类函数不是虚函数，派生类只要函数同名即构成隐藏。如果基类为虚函数，派生类同名函数的参数列表不相同构成隐藏，而不是覆盖。
class A 
{
public:
    void f1() { cout << "A::f1()" << endl; }

    void f2() { cout << "A::f2()" << endl; }

    void f3(int i) { cout << "A::f3()" << endl; }

    virtual void f4(int i) { cout << "A::f4()" << endl; }
	
	void f5(int i) { cout << "A::f5(int i)" << endl; }

    void f5() { cout << "A::f5()" << endl; }
};

class B : public A 
{
public:
    void f1() { cout << "B::f1()" << endl; }

    int f2() 
    {
        cout << "B::f2()" << endl;
        return 1;
    }

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

    virtual void f4() { cout << "B::f4()" << endl; }
};

int main() 
{
    B b;
    b.f1(); // 隐藏
    b.f2(); // 隐藏
    b.f3(); // 隐藏 
    b.f4(); // 隐藏，虽然基类f4为虚函数，但派生类f4与基类f4参数列表不相同，所以不构成覆盖(override)
    b.f5(); // 基类有2个f5函数，处于同一作用域，构成函数重载
    b.f5(1); // 基类有2个f5函数，处于同一作用域，构成函数重载
	
	b.A::f1(); // 使用作用域解析运算符访问基类f1函数
	
    return 0;
}

上面代码运行后输出内容如下：

B::f1()
B::f2()
B::f3()
B::f4()
A::f5(int i)
A::f5()
A::f1()

1.5 继承下的类型转换

1.5.1 向下类型转换

将基类的指针、引用、对象转换为派生类指针、引用、对象称为向下类型转换。
说明：

  1. 将基类对象转换为派生类对象时，实际上参照基类对象创建了一个新的派生类对象，所以派生类要提供一个Derived(const Base&)拷贝构造函数。
  2. 将基类指针、引用转换为派生类指针、引用时没有创建新的对象，编译器只是对这个起始内存空间从按基类类型解释变为按派生类类型解释，所以有内存越界风险。
  3. 对于使用protected/private继承方式，向下类型转换没有什么实际意义，因为基类很多成员对派生类是不可见的。

在这里插入图片描述

class Person 
{
public :
    void print() const 
    {
        cout << "name：" << _name << " age: " << _age << endl;
    }

    void set_name(const string &name) { _name = name; };

    void set_age(int age) { _age = age; };

private :
    string _name;
    int _age;
};

class Student : public Person 
{
public:
    Student(const Person &obj) {} // 对象的向下类型转换必须提供该拷贝构造函数
	
	void set_id(int id) { _id = id; };

private:
    int _id;
};

int main() 
{
    Person p;
    Student s(p); // 调用Student(const Person &obj)拷贝构造函数
    Student *point = (Student *) &p; // 将p对象的内存空间按Student类型解释
    Student &ref = (Student &) p; // 将p对象的内存空间按Student类型解释

	// 非法访问内存，point指向的区域实际是Person类型，现在将它按Student类型解释，调用set_id函数会修改p对象后面的内存区域
	point->set_id(10); 
    
    return 0;
}

1.5.2 向上类型转换

将派生类的指针、引用、对象转换为基类指针、引用、对象称为向上类型转换。
说明：

  1. 将派生类对象转换为基类对象时，实际上根据派生类对象裁剪出创建了一个新的基类对象。
  2. 将派生类指针、引用转换为基类指针、引用时没有创建新的对象，编译器只是对这个起始内存空间从按派生类类型解释变为按基类类型解释。
  3. 对于使用protected/private继承方式，向上类型转换没有什么实际意义，且需要通过强制类型转换实现。
    在这里插入图片描述
class Bike 
{
public:
    void move();

    void stop();

    void repair();

protected:
    int change_color(int color);

private:
    int _color;
};

class Player : private Bike 
{
public:
    void start_race();

    void end_race();

protected:
    int cur_strength();

private:
    int _max_strength;
    int _age;
};

int main() {
    Player player;
    Bike *p = (Bike *) &player; // 使用protected/private继承时，需要强制类型转换
    Bike &ref = (Bike &) player; // 使用protected/private继承时，需要强制类型转换

    return 0;
}

class Person 
{
public :
    void print() const 
    {
        cout << "name：" << _name << " age: " << _age << endl;
    }

    void set_name(const string &name) { _name = name; };

    void set_age(int age) { _age = age; };

private :
    string _name;
    int _age;
};

class Student : public Person 
{
public:
    void set_id(int id) { _id = id; };

private:
    int _id;
};

int main() {
    Student s;
    Person *point = &s; // 将s对象的内存空间按Person类型解释
    Person &ref = s; // 将s对象的内存空间按Person类型解释
    Person p(s);

    return 0;
}

1.6 继承下的友元

友元关系不能继承

class Base;  // 前向声明

class A 
{
   	friend class Base;  // 声明 Base 为 A 的友元类
private:
    int secret = 42;
};

class Base 
{
public:
    void accessSecret(A& a) 
    {
        std::cout << "Base can access secret: " << a.secret << std::endl;
    }
};

class Derived : public Base 
{
public:
    void accessSecret(A& a) 
    {
        // 尝试访问 A 的私有成员,编译错误
        std::cout << "Derived can access secret: " << a.secret << std::endl; 
    }
};

int main() 
{
    A a;
    Base base;
    Derived derived;

    base.accessSecret(a);      // 正常工作，Base 可以访问 A 的私有成员
    derived.accessSecret(a);   // 编译错误，Derived 无法访问 A 的私有成员

    return 0;
}

1.7 继承下的static成员变量

static成员变量在类中是共享的，这意味着类的所有实例共享同一个变量，无论派生出多少个类，都只有一个static成员变量 。

class A 
{
public:
    static int _a;
};

class B : public A 
{
};

class C : public A 
{
};

int A::_a = 1;

int main() 
{
    A a;
    B b;
    C c;
    
    // 打印出的地址相同
    cout << &a._a << endl; 
    cout << &b._a << endl;
    cout << &c._a << endl;
    
    return 0;
}

二、派生类的成员函数

2.1 派生类构造与析构函数

2.1.1 派生类构造函数

在派生类中不显式定义构造函数，编译器自动生成构造函数。这个构造函数会先调用基类的默认构造函数，然后调用派生类中自定义类型成员变量的默认构造函数。

派生类显式定义构造函数说明：

  • 构造顺序：先基类，再派生类
  • 若没在派生类的初始化列表中显式指定基类构造函数，编译器会隐式调用基类的无参构造函数
  • 多重继承时，基类按先后顺序构造
class A 
{
public:
    A(int a) : _a(a) { cout << "A()" << endl; };
    
private:
    int _a;
};

class B 
{
public:
    B(int b) : _b(b) { cout << "B()" << endl; };
    
private:
    int _b;
};

class C : public A, public B 
{
public:
    C(int a, int b, int c) : A(a), B(b), _c(c) 
    {
        cout << "C()" << endl;
    }

private:
    int _c;
};

int main() 
{
    C(1, 2, 3); // 依次输出 A() 、B() 、C()
    
    return 0;
}

2.1.2 派生类析构函数

在派生类中不显式定义析构函数，编译器自动生成析构函数。这个析构函数会先调用派生类中自定义类型成员变量的析构函数，然后调用基类的析构函数。

派生类显式定义析构函数说明：

  • 析构顺序：先派生类，再基类
  • 不要显式调用基类析构函数：为了保证析构顺序,编译器会在派生类的析构函数结束前自动调用基类析构函数。如果用户显式调用了,则会对基类析构两次。
  • 多重继承时，基类析构顺序与基类构造顺序相反
class A 
{
public:
    virtual ~A() // 基类的析构函数建议为虚函数，通过基类指针或引用删除一个派生类对象，virtual确保能调用派生类的析构函数，后续多态章节会详细讲解
    {
        cout << "~A()" << endl;
    }
};

class B : public A 
{
public:
    ~B() 
    {
        cout << "~B()" << endl;
        A::~A(); // 不应该显式调用基类的析构函数，这样基类会析构两次
    }
};

int main() 
{
    B b; // 依次输出 ~B() 、~A() 、~A()， 基类调用了两次析构函数
    
    return 0;
}

2.2 派生类拷贝构造与赋值函数

2.2.1 派生类拷贝构造函数

在派生类中不显式定义拷贝构造函数，编译器自动生成拷贝构造函数。这个拷贝构造函数会先调用基类的拷贝构造函数，然后对派生类对象中内置类型成员变量按字节拷贝（浅拷贝），如果成员变量为自定义类型则调用它的拷贝构造函数。

派生类显式定义析构函数说明：

  • 拷贝构造顺序：先基类，再派生类
  • 若没在派生类的初始化列表中显式指定基类拷贝构造函数，编译器会隐式调用基类的拷贝构造函数
  • 多重继承时，基类按先后顺序拷贝构造
class A 
{
public:
    A(int a = 0) : _a(a) {};

    A(const A &obj):_a(obj._A)
    {
        cout << "A(const &A)" << endl;
    }
    
    int _a;
};

class B : public A 
{
public:
    B() = default;

    B(const B &obj) : A(obj) 
    {
        cout << "B(const &B)" << endl;
    }
};

int main() {
    B b1;
    B b2(b1); // 依次输出 A(const &A)、B(const &B)
    
    return 0;
}

2.2.2 派生类赋值函数

在派生类中不显式定义赋值函数，编译器自动生成赋值函数。这个赋值函数会先调用基类的赋值函数，然后对派生类对象中内置类型成员变量按字节拷贝（浅拷贝），如果成员变量为自定义类型则调用它的赋值函数。

派生类显式定义赋值函数说明：

  • 赋值顺序：先基类，再派生类
  • 多重继承时，基类按先后顺序赋值
class A {
public:
    A(int a = 0) : _a(a) {};

    A &operator=(const A &obj) 
    {
        if (this != &obj) 
        {
            _a = obj._a;
            cout << "A=()" << endl;
        }

        return *this;
    }

private:
    int _a;
};

class B : public A {
public:
    B() = default;

    B &operator=(const B &obj) 
    {
        if (this != &obj) 
        {
            A::operator=(obj); // 调用基类的赋值函数
            cout << "B=()" << endl;
        }

        return *this;
    }
};

int main() {
    B b1;
    B b2;
    b2 = b1; // 依次输出 A=()、B=()
    
    return 0;
}

三、菱形继承

3.1 什么是菱形继承

多个子类继承同一个父类而又有子类同时继承这几个子类或其子孙类。
在这里插入图片描述

class Person
{
public:
    std::string _name;
};
 
class Student : public Person {
protected:
    int _num; // 学号
};
 
class Teacher : public Person{
protected:
    int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
    std::string _majorCourse; // 主修课程
};

3.2 菱形继承带来的问题

菱形继承带来了二义性和数据冗余的问题。

二义性：Student和Teacher类都继承Person类，所以它们继承了_name属性，Assistant类继承Student和Teacher类，所以在Assistant类中访问_name时会有歧义，编译器不知道是访问Student类的_name还是Teacher类的_name。

数据冗余：对于Assistant对象来说存放两份_name。

int main()
{
	Assistant a;
    a._name = "张三"; // 错误，二义性
	
	// 指定基类作用域解决二义性问题，但是无法解决数据冗余问题。
    a.Student::_name = "张三"; 
    a.Teacher::_name = "李四";
}

指定基类作用域解决二义性问题，但是用起来很奇怪，对Assistant类来说_name属性应该只有一个才对，不能我学生身份时有一个名字，教师身份时又有一个名字，而且没有解决数据冗余问题。

3.3 菱形继承内存布局

为了便于观察菱形继承的内存布局，下面使用简化的类结构。
测试环境： MSVC编译器 32位

class A 
{
public:
    int _a;
};

class B : public A 
{
public:
    int _b;
};

class C : public A 
{
public:
    int _c;
};

class D : public B, public C 
{
public:
    int _d;
};

int main() {
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    return 0;
}

在这里插入图片描述

3.4 虚继承解决方案

3.4.1 虚继承原理

 虚继承（虚拟继承） 是面向对象编程中的一种技术，是指一个指定的基类，在继承体系结构中，将其成员数据实例共享给也从这个基类型直接或间接派生的其它类。通过虚继承可以解决菱形继承带来的二义性与数据冗余问题。

语法：
class Derive: virtual public Base{};

注意：只有直接继承基类的派生类需要进行虚继承,间接继承的派生类不需要。
测试环境： MSVC编译器 32位

class A 
{
public:
    int _a;
};

class B : virtual public A 
{
public:
    int _b;
};

class C : virtual public A 
{
public:
    int _c;
};

class D : public B, public C 
{
public:
    int _d;
};

int main() {
    D d;
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;

    return 0;
}

在这里插入图片描述
观察d对象内存视图可以发现，使用虚继承后，将同属于B和C的A存放到对象最下面， 将 B空间位置原来存放基类A的地方现在存放了一个指针，C空间位置原来存放基类A的地方现在也变为存放了一个指针，这两个指针为虚基表指针，虚基表中存放了A的偏移量。查看B的虚基表（0x00bfbb40）可以看到有一个值0x14000000(补码)，转换为源码后对应的值为20，B空间首地址加上偏移量20刚好是A中成员_a的地址。查看C的虚基表（0x00bfbb48）可以看到有一个值0x0c000000(补码)，转换为源码后对应的值为12，C空间首地址加上偏移量12刚好是A中成员_a的地址。这就是虚继承解决二义性与数据冗余的原理。

说明：

  • 虚基表中起始全0的4个字节空间是为了实现多态的虚表指针预留的。
  • 虚继承的基类只会调用一次构造.
  • 菱形继承没有虚基表,菱形虚拟继承才有虚基表

同一派生类的所有对象共享一份虚基表

D d1, d2 ,d3;

在这里插入图片描述

3.4.2 虚继承缺点

  1. 参照前文部分，虚继承对于B类与C类的开发者提出更高要求，能预言出未来会被多继承而引发的菱形继承问题。
  2. 在public继承下向上类型转换是安全的，但是虚继承改变了对象内存布局，类型转换时编译器要做很多额外操作，效率低下。

四、继承与组合的选择

组合：

  • 具有"has-a"或"contain-a"的关系
  • 子对象所属类的源代码可有可无
  • 类间是水平关系，相比继承可减少类的层次
  • 黑盒复用，功能复用

继承：继承方式不同，目的不同

  • 基类源代码必须有
  • 白盒复用，代码复用
  • public继承表示“is-a”关系
  • private继承表示“has-a”，“contain-a”，"implement of"关系，完全可以换成组合
  • protected继承同private，同时便于在多层继承中保持这种关系

总结：除了"is-a"关系使用public继承以外其它都使用组合。

kjl167
关注
专栏目录
C++继承
FanBrother的博客
12-01 1057
文章开头先打一波广告，慕课网C++继承的课讲的真心到位，有空多看看：http://www.imooc.com/video/8703。所以呢，我这篇笔记就是我自己学习的一个记录。如果看到这里浪费了网友的时间，抱歉，您只管转走，靴靴。一道题先从一道我死活“没想通”的关于基类和派生类的对象、指针转换问题的一道题说起，代码跟上， 定义一个基类BaseClass，从它派生出类DerivedClass，Ba
C++ 继承详解
热门推荐
TABE_的博客
02-21 1万+
C++ 继承继承语法继承方式改变访问权限名字遮蔽继承时的对象模型无变量遮蔽有变量遮蔽 继承语法 继承的一般语法为： class 派生类名:［继承方式］ 基类名{ 派生类新增加的成员 }; 继承方式 继承方式包括 public（公有的）、private（私有的）和 protected（受保护的），此项是可选的，如果不写，那么默认为 private。不同的继承方式会影响基类成员在派生类中的访问权限。 （1）public继承方式 基类中所有 public 成员在派生类中为 public 属性； 基类中
C++继承详解
DR5200的博客
10-14 2666
文章目录一.继承的概念和定义二.基类和派生类对象赋值转换三.继承中的作用域四.派生类的默认成员函数五.继承和友元六.继承与静态成员七.菱形继承及菱形虚拟继承八.C++编译器如何通过虚继承解决数据冗余和二义性 一.继承的概念和定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的
C++ 继承详解及实例代码
09-01
C++继承是面向对象编程中的一个核心概念，它允许创建一个新的类（子类或派生类）基于已存在的类（基类或父类）。通过继承，子类不仅可以获得基类的所有成员（包括数据成员和成员函数），还可以添加新的功能或者重写...
实例代码讲解c++ 继承特性
12-17
以下是对C++继承特性的详细解释： 1. **派生类构造函数**：派生类需要定义自己的构造函数来初始化新增加的数据成员。在派生类构造函数中，通常需要调用基类的构造函数来初始化继承过来的成员。这可以通过成员初始化...
c++继承分类
04-28
C++继承是面向对象编程（OOP）中的一个核心概念，它允许我们创建新的类，这些新类可以扩展已存在的类的功能。在这个“c++继承分类”主题中，我们将深入探讨C++中的继承机制，以及如何在Qt环境中利用这一特性进行开发...
C++ 继承机制易犯的错误
01-21
继承作为面向对象的基本特征之一，其使用率极高。不管是为了实现软件的基本功能，还是再程序的重构的过程中，我们总是会用到继承机制。正是因为其用途极为广泛，而且使用简单，大众程序员对其真正的内部实现机制的...
C语言 12 函数
天河有尽后为涯，星海无边前作岸。
09-13 1127
程序的入口点就是main函数，只需要将程序代码编写到主函数中就可以运行了，不过这个函数只是由我们来定义，而不是我们来调用。当然，除了主函数之外，一直在使用的printf那么，函数的具体定义是什么呢？函数是完成特定任务的独立程序代码单元。每次要做这个任务时，都要完完整整地将任务的每一行代码都写下来，如果程序中多处都需要执行这个任务，每个地方都完整地写一遍，实在是太臃肿了，有没有一种更好的办法能优化代码呢？
CF C. Nikita and LCM
qq_74190237的博客
09-13 289
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++_map_set详解
2302_77644537的博客
09-16 858
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
【C++11 —— 异常】
最新发布
jokr_的博客
09-17 857
实际使用中很多公司都会自定义自己的异常体系进行规范的异常管理，因为一个项目中如果大家随意抛异常，那么外层的调用者基本就没办法玩了，所以实际中都会定义一套继承的规范体系。这样大家抛出的都是继承的派生类对象，捕获一个基类就可以了。在软件开发中，尤其是复杂系统的开发中，使用自定义异常体系可以帮助团队规范化异常管理。通过定义一套继承体系，所有抛出的异常都是特定基类的派生类，这样外层调用者可以通过捕获基类来处理所有相关的异常。使用自定义异常可以提供更具体的错误信息，使得代码的可读性和可维护性得到提升。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 596
继续学习头文件的数学函数。
C++ 中 vector 的常用功能介绍
2202_75569688的博客
09-12 440
在 C++ 中，vector是一种常用的动态数组容器，提供了方便的自动扩展、内存管理以及各种便捷的操作方法。它是 C++ 标准模板库（STL）的一部分，适用于需要动态存储和管理大量元素的场景。在本文中，我们将简要介绍vector的常用功能，展示如何对其进行操作和排序。为了简洁起见，假设我们已经使用了。
CCF201903_1
m0_67663419的博客
09-14 220
【代码】CCF201903_1。
C++入门基础
2301_76564849的博客
09-12 896
•定义命名空间，需要使⽤到namespace关键字，后⾯跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。//命名空间里可以定义变量/函数/类型int Add(int x, int y)//整数相加的函数struct Node//定义一个结构体int val;//其中::叫做域作用限定符•namespace本质是定义出⼀个域，这个域跟全局域各⾃独⽴，不同的域可以定义同名变量，所以上。
在typescript浏览器端中调用C++编写的函数，WebAssembly传递指针类型的参数，以及处理指针类型的返回值。
Xeon_CC的博客
09-17 301
最后是返回一个C++结构体指针，在TypeScript中通过DataView来获取内存中的地址偏移量来取得结构体中的数据，因为em++编译器是以32位来编译.cpp文件的，所以指针占4个字节。DataResult结构体第一个属性dArr是一个指针，那么就是地址偏移量0，然后以32位无符号整型取得dArr指针，通过这个指针去读取wasm中memoryBuffer中的数据，就可以得到dArr属性对应的值了。同理，通过地址偏移量+4来得到propCount属性，以32位整数读取数据即可。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 456
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值