c++ 虚函数

最新推荐文章于 2024-11-17 16:56:14 发布
最新推荐文章于 2024-11-17 16:56:14 发布
阅读量357 收藏
点赞数
分类专栏： c++ 文章标签： c++ fun class 编译器 c 算法

我们先来讨论一个类(Class)的存储配置。首先来写一个类，这个类没有任何数据成员，然后来看看他的内存结构。

程序1:
#include <iostream>

using namespace std;

class Class{
};

int main()
{
 Class objClass;
 
 cout << \"Size of object is = \" << sizeof(Class) << endl;
 cout << \"Address of object is = \" << &objClass << endl;

 return 0;
}

程序输出：
Size of object is = 1
Address of object is = 0012FF7C

现在，如果我们往类里添加数据成员，他的大小会将等于所有数据成员所占内存的和。在模版类(template class)中，也是这样。现在，让我

们来看看模版类Point。

程序2:
#include <iostream>

using namespace std;

template <typename T>
class CPoint{
 T m_x;
 T m_y;
};

int main()
{
 CPoint<int> objPoint;
 
 cout << \"Size of object is = \" << sizeof(objPoint) << endl;
 cout << \"Address of object is = \" << &objPoint << endl;

 return 0;
}
程序输出：
Size of object is = 8
Address of object is = 0012FF78

现在，我们也添加一个继承类到这个程序，我们用Point3D类来继承Point类，同时来看看程序的内存结构。

程序3:
#include <iostream>

using namespace std;

template <typename T>
class CPoint{
 T m_x;
 T m_y;
};

template <typename T>
class CPoint3D : public CPoint<T>
{
 T m_z;
};
int main()
{
 CPoint<int> objPoint;
 
 cout << \"Size of Point is = \" << sizeof(objPoint) << endl;
 cout << \"Address of Point is = \" << &objPoint << endl;

 CPoint3D<int> objPoint3D;

 cout << \"Size of Point3D is = \" << sizeof(objPoint3D) << endl;
 cout << \"Address of Point3D is = \" << &objPoint3D << endl;
 
 return 0;
}
程序输出:
Size of Point is = 8
Address of Point is = 0012FF78
Size of Point3D is = 12
Address of Point3D is = 0012FF6C

这个程序说明了派生类的内存结构。派生类所占用的内存总数是基类的所有数据成员和该派生类所有数据成员所占内存的和。


如果把虚函数也添加进来，那这个问题就更有趣了。我们来看看这个程序。
程序4:
#include <iostream>

using namespace std;

class Class
{
 virtual void fun()
 {
  cout << \"Class::fun\" << endl;
 }
};

void main()
{
 Class objClass;
 cout << \"size of class = \" << sizeof(objClass) << endl;[Page]
 cout << \"Address of class = \" << & objClass << endl;
}
程序输出:
size of class = 4
Address of class = 0012FF7C

如果我们添加一个以上的需函数，那么情况会变得更有去。

程序5:
#include <iostream>

using namespace std;

class Class
{
 virtual void fun1()
 {
  cout << \"Class::fun\" << endl;
 }
 virtual void fun2()
 {
  cout << \"Class::fun2\" << endl;
 }
 virtual void fun3()
 {
  cout << \"Class::fun3\" << endl;
 }
};

void main()
{
 Class objClass;
 cout << \"size of class = \" << sizeof(objClass) << endl;
 cout << \"Address of class = \" << & objClass << endl;
}
程序的输出和上面一样。我们来做多点实验，使我们能更好地理解他。

程序6:
#include <iostream>

using namespace std;

class CPoint
{
 int m_x;
 int m_y;
public:
 virtual ~CPoint(){
 };
};

void main()
{
 CPoint objPoint;
 cout << \"size of Point = \" << sizeof(objPoint) << endl;
 cout << \"Address of Point = \" << &objPoint << endl;
}

程序输出:
size of Point = 12
Address of Point = 0012FF68

这个程序的输出告诉我们，无论你在类里添加多少个虚函数，他的大小只增加一个int数据类型所占的内存空间，例如在Visual C++ 他增加4字

节。他表示有三块内存给这个类的整数，一个给m_x,一个给m_y,还有一个用来处理被调用的虚函数的虚指针。首先来看一看新的一块内存，也

就是虚函数指针所占内存，在该对象的最开始头（或者最后）。我们可以通过直接访问对象所占的内存块来调用虚函数。只要把对象的地址保

存到一个int类型指针，然后使用指针算法的魔术(The magic of pointer arithmetic)就能够调用他了。

程序7:
#include <iostream>

using namespace std;

class CPoint {
 
public:
 
 int m_ix;
 int m_iy;
 CPoint(const int p_ix = 0, const int p_iy = 0) :

[NextPage]

m_ix(p_ix), m_iy(p_iy) {
 }
 int getX() const {
  return m_ix;
 }
 int getY() const {
  return m_iy;
 }
 virtual ~CPoint() { };
};
int main() {
 
 CPoint objPoint(5, 10);

 int* pInt = (int*)&objPoint;
 *(pInt+0) = 100; // 打算改变 x 的值
 *(pInt+1) = 200; // 打算改变 y 的值

 cout << \"X = \" << objPoint.getX() << endl;
 cout << \"Y = \" << objPoint.getY() << endl;

 return 0;
}
这个程序最重要的地方是:
int* pInt = (int*)&objPoint;
*(pInt+0) = 100; // 打算改变 x 的值
*(pInt+1) = 200; // 打算改变 y 的值

这里我们把对象的地址保存到一个int类型的指针，然后把它当成整型指针。[Page]
程序输出:
X = 200
Y = 10
当然，这不是我们想要的结果！程序说明，这时的200是保存到x_ix,而不是x_iy。也就是说对象第一个数据成员是从内存的第二个地址开始的

，而不是第一个。换句话说，第一个内存地址保存的是虚函数的地址，然后其他保存的都是类的数据成员。我们来改一下下面两行代码。
int* pInt = (int*)&objPoint;
*(pInt+1) = 100; // 打算改变 x 的值
*(pInt+2) = 200; // 打算改变 y 的值

这时我们得到了所期待的结果。

程序8:
#include <iostream>

using namespace std;

class CPoint {
public:
         int m_ix;
         int m_iy;

         CPoint(const int p_ix = 0, const int p_iy = 0) :
                 m_ix(p_ix), m_iy(p_iy) {
         }

         int getX() const {
                 return m_ix;
         }
         int getY() const {
                 return m_iy;
         }

         virtual ~CPoint() { };

};

int main() {

         CPoint objPoint(5, 10);

         int* pInt = (int*)&objPoint;
         *(pInt+1) = 100; // 想要改变 x 的值
         *(pInt+2) = 200; // 想要改变 y 的值

         cout << \"X = \" << objPoint.getX() << endl;
         cout << \"Y = \" << objPoint.getY() << endl;

         return 0;

}

程序的输出:
X = 100
Y = 200

这里很明确的告诉我们，无论什么时候我们添加虚函数到类里面，虚指针都存放在内存的第一个位置。

现在问题出现了:虚指针里存放的是什么?来看看以下程序，我们就能知道它是什么概念。
程序9:
#include <iostream>

using namespace std;

class Class {

         virtual void fun() { cout << \"Class::fun\" << endl; }

};

int main() {

         Class objClass;

         cout << \"Address of virtual pointer \" << (int*)(&objClass+0) << endl;[Page]
         cout << \"Value at virtual pointer \" << (int*)*(int*)(&objClass+0) << endl;

         return 0;

}
程序输出:

Address of virtual pointer 0012FF7C
Value at virtual pointer 0046C060

虚指针保存一张叫做虚表的地址。而虚表保存着整个类的虚函数地址。换句话说，虚表是一个存放虚函数地址的数组。让我们看一下下面的程

序来理解这种思想。

程序10:
#include <iostream>

using namespace std;

 

class Class {

         virtual void fun() { cout << \"Class::fun\" << endl; }

};

 

typedef void (*Fun)(void);

 

int main() {

         Class objClass;

 

         cout << \"Address of virtual pointer \" << (int*)(&objClass+0) << endl;

         cout << \"Value at virtual pointer i.e. Address of virtual table \"

                  << (int*)*(int*)(&objClass+0) << endl;

         cout << \"Value at first entry of virtual table \"

[NextPage]

             << (int*)*(int*)*(int*)(&objClass+0) << endl;

 

         cout << endl << \"Executing virtual function\" << endl << endl;

         Fun pFun = (Fun)*(int*)*(int*)(&objClass+0);
         pFun();
         return 0;

}
这个程序有些不常用的间接类型转换。这个程序最重要的地方是

Fun pFun = (Fun)*(int*)*(int*)(&objClass+0);

这里 Fun 是一个typeded 函数指针。

typdef void (*Fun)(void):

我们来详细研究这种不常用的间接转换。
(int*)(&objClass+0)给出类第一个入口的虚函数的指针然后把他类型转换成int*.我们使用间接操作符（也就是 *)来获取这个地址的值然后再

次类型转换成 int* 也就是(int*)*(int*)(&objClass+0).这将会给出虚函数地址表的入口地址.获得这个位置的值，也就是得到类的第一个虚

函数的指针,再次使用间接操作符再类型转换成相应的函数指针类型。像这样：
Fun pFun = (Fun)*(int*)*(int*)(&objClass+0);
表示获取虚函数地址表第一个入口的值然后类换成Fun类型后保存到pFun.

添加多一个虚函数到类里面会怎么样。我们现在想要访问虚函数地址表里第二个成员。查看以下程序，看看虚函数地址表里的值。[Page]

程序11:
#include <iostream>

using namespace std;
class Class {
         virtual void f() { cout << \"Class::f\" << endl; }
         virtual void g() { cout << \"Class::g\" << endl; }
};

int main() {

         Class objClass;
         cout << \"Address of virtual pointer \" << (int*)(&objClass+0) << endl;
         cout << \"Value at virtual pointer i.e. Address of virtual table \"
                 << (int*)*(int*)(&objClass+0) << endl;

         cout << endl << \"Information about VTable\" << endl << endl;
         cout << \"Value at 1st entry of VTable \"
                 << (int*)*((int*)*(int*)(&objClass+0)+0) << endl;

         cout << \"Value at 2nd entry of VTable \"
                 << (int*)*((int*)*(int*)(&objClass+0)+1) << endl;

         return 0;
}
程序输出:
Address of virtual pointer 0012FF7C
Value at virtual pointer i.e. Address of virtual table 0046C0EC
Information about VTable
Value at 1st entry of VTable 0040100A
Value at 2nd entry of VTable 0040129E

现在我们心理产生一个问题。编译器怎么知道虚函数地址表的长度呢？答案是：虚函数地址表最后的入口等于NULL。把程序做些小改动来理解

它。

程序12:
#include <iostream>

using namespace std;

class Class {
         virtual void f() { cout << \"Class::f\" << endl; }
         virtual void g() { cout << \"Class::g\" << endl; }
};

int main() {
         Class objClass;

         cout << \"Address of virtual pointer \" << (int*)(&objClass+0) << endl;
         cout << \"Value at virtual pointer i.e. Address of virtual table \"
                  << (int*)*(int*)(&objClass+0) << endl;[Page]
         cout << endl << \"Information about VTable\" << endl << endl;
         cout << \"Value at 1st entry of VTable \"
                  << (int*)*((int*)*(int*)(&objClass+0)+0) << endl;
         cout << \"Value at 2nd entry of VTable \"
                  << (int*)*((int*)*(int*)(&objClass+0)+1) << endl;
         cout << \"Value at 3rd entry of VTable \"
                  << (int*)*((int*)*(int*)(&objClass+0)+2) << endl;

[NextPage]


         cout << \"Value at 4th entry of VTable \"
                  << (int*)*((int*)*(int*)(&objClass+0)+3) << endl;
         return 0;
}

程序输出:
Address of virtual pointer 0012FF7C
Value at virtual pointer i.e. Address of virtual table 0046C134

Information about VTable

Value at 1st entry of VTable 0040100A
Value at 2nd entry of VTable 0040129E
Value at 3rd entry of VTable 00000000
Value at 4th entry of VTable 73616C43

这个程序的输出显示了虚函数地址表的最后一个入口等于NULL.我们用我们所了解的知识来调用虚函数

程序13:
#include <iostream>

using namespace std;

class Class {
         virtual void f() { cout << \"Class::f\" << endl; }
         virtual void g() { cout << \"Class::g\" << endl; }
};

typedef void(*Fun)(void);

int main() {

         Class objClass;

         Fun pFun = NULL;

         // calling 1st virtual function

         pFun = (Fun)*((int*)*(int*)(&objClass+0)+0);

         pFun();

         // calling 2nd virtual function

         pFun = (Fun)*((int*)*(int*)(&objClass+0)+1);[Page]

         pFun();

         return 0;
}

这个程序的输出是:

Class::f
Class::g

现在我们来看一下多层继承的情况。以下是个简单的多层继承的情况。

程序14:
#include <iostream>
using namespace std;
class Base1 {
public:
         virtual void f() { }

};
class Base2 {
public:
         virtual void f() { }
};
class Base3 {
public:
         virtual void f() { }
};
class Drive : public Base1, public Base2, public Base3 {
};
int main() {

         Drive objDrive;
         cout << \"Size is = \" << sizeof(objDrive) << endl;

         return 0;
}

程序输出:
Size is = 12

程序表明，当你的 drive 类具有一个以上的基类时，drive 类就具有所有基类的虚函数指针。
如果 drive 类也具有虚函数那会怎么样呢。我们来看看这个程序以便更好的了解多继承虚函数的概念。

程序15:
#include <iostream>

using namespace std;

 

class Base1 {

         virtual void f() { cout << \"Base1::f\" << endl; }

         virtual void g() { cout << \"Base1::g\" << endl; }

};

 

class Base2 {

         virtual void f() { cout << \"Base2::f\" << endl; }

         virtual void g() { cout << \"Base2::g\" << endl; }

};

 

class Base3 {

         virtual void f() { cout << \"Base3::f\" << endl; }

         virtual void g() { cout << \"Base3::g\" << endl; }

};

 

class Drive : public Base1, public Base2, public Base3 {

public:

         virtual void fd() { cout << \"Drive::fd\" << endl; }

         virtual void gd() { cout << \"Drive::gd\" << endl; }

};

 

typedef void(*Fun)(void);

 

int main() {

         Drive objDrive;

 

         Fun pFun = NULL;

 

         // calling 1st virtual function of Base1

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+0)+0);[Page]

         pFun();

        

         // calling 2nd virtual function of Base1

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+0)+1);

         pFun();

[NextPage]

       // calling 1st virtual function of Base2

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+1)+0);

         pFun();

 

         // calling 2nd virtual function of Base2

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+1)+1);

         pFun();

 

         // calling 1st virtual function of Base3

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+2)+0);

         pFun();

 

         // calling 2nd virtual function of Base3

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+2)+1);

         pFun();

 

         // calling 1st virtual function of Drive

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+0)+2);

         pFun();

 

         // calling 2nd virtual function of Drive

         pFun = (Fun)*((int*)*(int*)((int*)&objDrive+0)+3);

         pFun();

 

         return 0;

}

程序输出:
Base1::f

Base1::g

Base2::f

Base2::f

Base3::f

Base3::f

Drive::fd

Drive::gd

这个程序显示 drive 的虚函数保存在 vptr 的第一个 虚函数地址表.
我们在 static_cast 的帮助下我门能够获取 Drive 类 vptr 的偏移量.我们看一下以下的程序来更好地理解他。

程序16:
#include <iostream>

using namespace std;

 

class Base1 {

public:

         virtual void f() { }

};

 

class Base2 {

public:

         virtual void f() { }

};

 

class Base3 {

public:

         virtual void f() { }

};

 

class Drive : public Base1, public Base2, public Base3 {

};

 

// any non zero value because multiply zero with any no is zero

#define SOME_VALUE        1

 

int main() {

         cout << (DWORD)static_cast<Base1*>((Drive*)SOME_VALUE)-SOME_VALUE << endl;

         cout << (DWORD)static_cast<Base2*>((Drive*)SOME_VALUE)-SOME_VALUE << endl;

         cout << (DWORD)static_cast<Base3*>((Drive*)SOME_VALUE)-SOME_VALUE << endl;

         return 0;

}

ATL 使用一个叫做offsetofclass 的宏来这么做，该宏定义在 ATLDEF.h 里。宏的定义是：
#define offsetofclass(base, derived) \\
       ((DWORD)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)
这个宏返回在 drive 类对象模型里的基类的vptr的偏移量。我们来看一个例子了解这个概念。
程序17:
#include <windows.h>

#include <iostream>

using namespace std;

 

class Base1 {

public:

         virtual void f() { }

};

 

class Base2 {

public:

         virtual void f() { }

};

 

class Base3 {

public:

         virtual void f() { }

};

 

class Drive : public Base1, public Base2, public Base3 {

};

 

#define _ATL_PACKING 8

 

#define offsetofclass(base, derived) \\

         ((DWORD)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)

 

int main() {

         cout << offsetofclass(Base1, Drive) << endl;

         cout << offsetofclass(Base2, Drive) << endl;

         cout << offsetofclass(Base3, Drive) << endl;

         return 0;

}

[NextPage]

这是 drive 类的内存层次
程序输出是：
0
4
8
程序的输出显示，这个宏返回了所要的基类vptr的偏移量。在 Don Box 的《Essential COM》，他使用一个类似的宏来这么做。把程序做些小改动来用Box的宏取代ATL 的宏。
程序18:
#include <windows.h>

#include <iostream>

using namespace std; 

class Base1 {

public:

         virtual void f() { }

};

 

class Base2 {

public:

         virtual void f() { }

};

 

class Base3 {

public:

         virtual void f() { }

};

 

class Drive : public Base1, public Base2, public Base3 {

};

 

#define BASE_OFFSET(ClassName, BaseName) \\

         (DWORD(static_cast<BaseName*>(reinterpret_cast<ClassName*>\\

         (0x10000000))) - 0x10000000)

 

int main() {

         cout << BASE_OFFSET(Drive, Base1) << endl;

         cout << BASE_OFFSET(Drive, Base2) << endl;

         cout << BASE_OFFSET(Drive, Base3) << endl;

         return 0;

}

程序的目的很输出和前面的程序一样。
我们用这个宏在我们的程序做些实用的事。事实上，我们可以通过获取在 drive的内存结构里基类的vptr来调用所要的基类的虚函数。

程序19:
#include <windows.h>

#include <iostream>

using namespace std;

 

class Base1 {

public:

         virtual void f() { cout << \"Base1::f()\" << endl; }

};

 

class Base2 {

public:

         virtual void f() { cout << \"Base2::f()\" << endl; }

};

 

class Base3 {

public:

         virtual void f() { cout << \"Base3::f()\" << endl; }

};

 

class Drive : public Base1, public Base2, public Base3 {

};

 

#define _ATL_PACKING 8

 

#define offsetofclass(base, derived) \\

         ((DWORD)(static_cast<base*>((derived*)_ATL_PACKING))-_ATL_PACKING)

 

int main() {

         Drive d;

 

         void* pVoid = NULL;

       // call function of Base1

         pVoid = (char*)&d + offsetofclass(Base1, Drive);

         ((Base1*)(pVoid))->f();

 

         // call function of Base2

         pVoid = (char*)&d + offsetofclass(Base2, Drive);

         ((Base2*)(pVoid))->f();

 

         // call function of Base1

         pVoid = (char*)&d + offsetofclass(Base3, Drive);

         ((Base3*)(pVoid))->f();

 

         return 0;

}

这个程序的输出:

Base1::f()

Base2::f()

Base3::f()



hy0736
关注
专栏目录
C++虚函数表解析
03-03
前言C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型...
C++虚函数
小码农的csdn博客
03-19 1218
1、指向子对象的父类指针 这个例子遇到的问题，用虚函数就可以解决 class Father { public: ~Father(){cout<<"Father析构"<<endl;} void drive(){cout<<"爸爸会开车"<<endl;} void Occupation(){cout<<"爸爸是工人"<<endl;} }; class Son:public Fath
虚函数的工作原理--虚函数表
q__y__L的博客
04-10 694
请看下面的Base类，它申明了N个虚函数：class：Base { public: virtual void func1() { //Func1 implementation } virtual void func2() { //Func2 implemetation } //..so on and so for
typedef函数指针用法
热门推荐
Liam Q的专栏
10-20 20万+
1.简单的函数指针的应用 形式1：返回类型(*函数名)(参数表)  char (*pFun)(int); char glFun(int a){ return;} void main() { pFun = glFun; (*pFun)(2); }          第一行定义了一个指针变量pFun。首先我们根据前面提到的“形式1”认识
C++ 虚函数的详解及简单实例
01-01
C++ 虚函数的详解 虚函数的使用和纯虚函数的使用。 虚函数是在基类定义，然后子类重写这个函数后，基类的指针指向子类的对象，可以调用这个函数，这个函数同时保留这子类重写的功能。 纯虚函数是可以不用在基类定义...
C++虚函数实现原理
10-24
### C++虚函数实现原理 #### 一、引言 在C++中，虚函数机制是面向对象编程中实现多态的重要方式之一。通过虚函数，可以在基类中定义一个接口，并由派生类来具体实现该接口的功能，进而允许在运行时根据对象的实际...
2411C++,C++26反射示例
个人进步之路
11-13 976
2411C++,C++26反射示例
C++ 中的string类
2201_75357870的博客
11-15 808
end获得的不是最后一个字符的位置，而是最后一个字符的下一个位置！end()-1才是最后一个字符的位置。
C++中的 std::optional
万里归来少年心
11-17 95
std::optional是C++17中的一个标准库组件，optional 对象默认是空的，也就是处于无效状态，给它赋值后因为里面有了元素，就变成了有效状态。
快速上手STL中list的使用
知其然 知其所以然
11-13 765
【代码】快速上手STL中list的使用。
C/C++基础知识复习（23）
m0_72883750的博客
11-17 364
某些类型转换可能会引发未定义行为，尤其是使用或const_cast时。如果转换不合理或对原数据结构产生不正确的操作，可能会导致程序崩溃或者出现奇怪的运行时错误。int x = 10;// 错误的类型转换，可能导致程序崩溃或未定义行为。
c语言基础知识点（十五）C语言中的指针+1与指针的二进制表示+1的区别
qq_51519091的博客
11-13 361
给一个指针加上一个整数与给该指针的二进制表示加上同样的整数，这两者之间存在本质的区别，主要体现在操作对象、操作意义以及结果上。
Cross-Inlining Binary Function Similarity Detection
最新发布
Che_Che_的博客
11-17 438
编译器在编译时将函数调用直接替换为函数体代码，从而消除函数调用的开销。代码直接嵌入到调用点，而不是通过函数调用进行。这可以减少函数调用的开销。
lambda 表达式与mutable
王尚权 qq:2515162716
11-15 1036
通常情况下，lambda表达式捕获的变量是不可变的，使用mutable关键字可以破坏这种不可变性，允许对捕获变量进行修改。在C++中，mutable关键字和引用捕获方式（&）有不同的用途和效果，它们可以在某些情况下结合使用，但它们的基本功能和影响是不同的。在这个例子中，x既是通过引用捕获的，也是mutable关键字作用的对象。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。在这个例子中，x是被捕获的变量，mutable关键字使得lambda表达式可以修改x的值。
20241114在飞凌的OK3588-C的核心板上跑Linux R4时通过iperf3测试以太网卡的实际网速
南岭笑笑生之家
11-14 925
创建一个eth0配置文件， 配置文件的路径为：/etc/network/interfaces.d/eth0,设置动态ip的配置文件。虽然 飞凌的OK3588-C的核心板 使用的是千兆网卡RTL8211F-CG，但是只接了4根线，作为百兆网卡使用了。OK3588-C板载两个千兆网卡，插入网线连接网络的情况下，出厂时默认配置为动态IP。跑iperf3的时候，以 飞凌的OK3588-C的核心板Linux R4 为服务器，设置完后使用sync文件同步指令，重启开发板或者重启服务，配置生效。双方通过交换机连接。
【代码随想录day29】【C++复健】134. 加油站；135. 分发糖果；860.柠檬水找零；406. 根据身高重建队列
yumenohimiko的博客
11-14 691
感觉贪心的题真的很考验一个人的智商，而我，碰巧没有。134. 加油站偷看了解析思路，但依然因为一个低级失误导致被卡了很久... 并且写出来的代码也非常的麻烦，主要体现在我每到一个新节点，就必须求证似的让iter走完一整圈才算结束，但卡哥的方法一个for循环就结束了。卡哥的思路也相当的清晰：简单来说就是当你一圈下来：1 如果和小于0，那么说明无论如何无解，也不用往后再看了。
c++ conditional_variable条件变量+消费者生产者
weixin_44322824的博客
11-16 206
初始状态下，product中有一个元素，消费者1没有持有互斥量，调用wait函数：先检查lambda表达式，发现非空。初始状态下，product中有一个元素，消费者1持有互斥量，调用wait函数：先检查lambda表达式，发现非空。1、对于生产者，我们向product变量中添加数据，添加完毕后，我们调用cv.notify_once函数，告诉消费者product可能发生变化。如果先释放锁，再唤醒，很有可能出现锁一释放就被其他的消费者占用了，而被唤醒的消费者根本不可能参与到锁的竞争中。假设现在有消费者A,B。
深入理解C++虚函数表机制
"C++虚函数表解析 - 深入理解C++的多态机制" 在C++编程语言中，虚函数（Virtual Function）是实现多态性的重要机制。多态性允许程序员使用父类类型的指针或引用来调用子类重写的成员函数，从而实现更灵活的代码设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值