C++学习第十三天（多态）

最新推荐文章于 2024-08-15 13:54:22 发布
最新推荐文章于 2024-08-15 13:54:22 发布
阅读量701 收藏 10
点赞数 22
文章标签： 学习 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx_web_c/article/details/138588037
版权

1、多态的概念

概念

就是指多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生不同的状态

2、多态的定义及实现

多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。

要在继承中构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

 虚函数

虚函数：即被virtual修饰的类成员函数

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "apple" << endl;
	}
};

虚函数的重写

虚函数的重写：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称子类的虚函数重写了基类的虚函数。

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "apple" << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "banana" << endl;
	}
};

void Func(Person& p)
{
	p.BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(ps);
	Func(st);
	return 0;
}

需要注意的是：在重写基类虚函数时，派生类的虚函数不加virtual关键字时，虽然也可以构成重写，但是不建议这样写（因为继承后基类的虚函数被继承下来类在派生类依旧保持虚函数属性），但是这种写法不是规范的写法，不建议这样子使用


虚函数重写的两个例外：

  1. 协变（基类与派生类虚函数返回值类型不同）
    派生类重写虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变 
    class A{};
class B : public A {};

class Person
{
public:
	virtual A* f() { return new A; }
};

class Student : public Person
{
public:
	virtual B* f() { return new B; }
};

  2. 析构函数的重写（基类与派生类析构函数的名字不同）
    如果基类的析构函数为虚函数此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后的析构函数的名称统一处理为destructor
     

    class Person
{
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};

class Student : public Person
{
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};

int main()
{
	Person* p1 = new Person;
	Person* p2 = new Student;
	delete p1;
	delete p2;
	return 0;
}

C++11 override 和 final

C++提供了override和final来帮助用户检测是否重写

  1. final：修饰虚函数，表示该虚函数不能再被重写 
    class Car
{
public:
	virtual void Drive() final{}
};

class Benz : public Car
{
public:
	virtual void Drive() { cout << "Benz" << endl; }
};

  2. override：检查派生类虚函数是否重写了基类某个基函数，如果没有重写就错 
    class Car
{
public:
	virtual void Drive() {}
};

class Benz : public Car
{
public:
	virtual void Drive() override { cout << "Benz" << endl; }
};

 重载、覆盖（重写）、隐藏（重定义）的对比

三个概念的对比重载两个函数在同一作用域
函数名/参数相同
重写（覆盖）两个函数分别在基类和派生类的作用域
函数名/参数/返回值都必须相同（协变除外）
两个函数必须是虚函数
重定义（隐藏）两个函数分别在基类和派生类的作用域
函数名相同
两个基类和派生类的同名函数不构成重写就是重定义

 3、抽象类

 概念

在虚函数的后面写上 = 0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫做抽象类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范类派生类必须重写，另外纯虚函数更体现出了接口继承

class Car
{
public:
	virtual void Drive() = 0;
};

class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

class BMW : public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW" << endl;
	}
};

void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();

	Car* pBMW = new BMW;
	pBMW->Drive();
}

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

 接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，就不要把函数定义为虚函数

 4、多态的原理

虚函数表

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}

private:
	int _b = 1;
};

在x86环境下运行出来是sizeof(Base)是8个字节，除了_b成员，还多了一个_vfptr放在对象的最后面，和这个平台有关，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要放在虚函数表中，虚函数表也简称虚表，那么派生类中的这个表中放

了些什么？

针对上面的代码我们可以做出以下改造：

  1. 我们增加一个派生类Derive继承Base
  2. Derive中重写Func1
  3. Base再增加一个虚函数Func2和一个普通函数Func3
class Base
{
public:
	virtual void Func1() 
	{
		cout << "Base::Func1()" << endl;
	}

	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}

	virtual void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;

};

class Derive : public Base
{
public:
	virtual void func1()
	{
		cout << "Derive::func1()" << endl;
	}

private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

我们可以发现一下问题：

  1. 派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在部分的另一部分是自己的成员
  2. 基类b对象个派生类d对象虚表式不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数重写也叫做覆盖，覆盖就是指虚表中虚函数的覆盖，重写的是语法的叫法，覆盖是原理层的叫法
  3. 另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表
  4. 虚函数表本质是一个存虚函数指针的指针数组，一般情况下这个数组最后放了一个nullptr。
  5. 总结派生类的虚表构成：先将基类中的虚表内容拷贝一份到派生类虚表中；如果派生类重写了基类中的某个虚函数，用派生类自己的虚函数覆盖虚表中的基类的虚函数；派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。
  6. 这里还有一个问题：虚函数存放在哪里？虚表存在哪里？一般会说：虚函数存放在虚表，虚表存在对象中。但这个是错误的回答。正确答案是：虚表存的是虚函数指针，而不是虚函数，虚函数和普通函数是一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存放的不是虚表，存的是虚表指针。那么虚表存在哪里的呢？实际上在vs环境下是存在代码段的

 多态的原理

我们在本篇的最开始写了一段代码，那里的Func函数传Person调用的Person::BuyTicket()，传Student调用的是Student::BuyTicket()

  1. 观察此图的红色箭头我们可以知道，p指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是Person::BuyTicket
  2. 观察此图的蓝色箭头我们可以知道，p指向johnson对象时，p->BuyTicket在johnson的虚表中找到虚函数是Student::BuyTicket
  3. 这样就实现了不同对象去完成同一行为时，展现出不同的形态
  4. 反过来要达到多态，要达到两个条件，一个是虚函数覆盖，一个是对象的指针或引用调用虚函数，为什么？
  5. 通过以下的汇编代码分析，可以看出多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中去找的。不满足多态的函数调用时编译器确认好的
void Func(Person* p)
{
    p->BuyTicket();
}
int main()
{
    Person mike;
    Func(&mike);
    mike.BuyTicket();
    
    return 0;
}
// 以下汇编代码中跟你这个问题不相关的都被去掉了
void Func(Person* p)
{
...
    p->BuyTicket();
    // p中存的是mike对象的指针，将p移动到eax中
    001940DE  mov         eax,dword ptr [p]
    // [eax]就是取eax值指向的内容，这里相当于把mike对象头4个字节(虚表指针)移动到了edx
    001940E1  mov         edx,dword ptr [eax]
    // [edx]就是取edx值指向的内容，这里相当于把虚表中的头4字节存的虚函数指针移动到了eax
    00B823EE  mov         eax,dword ptr [edx]
    // call eax中存虚函数的指针。这里可以看出满足多态的调用，不是在编译时确定的，是运行起来
    以后到对象的中取找的。
    001940EA  call        eax  
    00头1940EC  cmp         esi,esp  
}
int main()
{
... 
// 首先BuyTicket虽然是虚函数，但是mike是对象，不满足多态的条件，所以这里是普通函数的调
用转换成地址时，是在编译时已经从符号表确认了函数的地址，直接call 地址
    mike.BuyTicket();
    00195182  lea         ecx,[mike]
    00195185  call        Person::BuyTicket (01914F6h)  
... 
}

 动态绑定和静态绑定

  1. 静态绑定又称为前期绑定，在程序编译期间确定了程序的行为，也称为静态多态，比如函数重载
  2. 动态绑定又称为后期绑定，实在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态

5、单继承和多继承关系的虚函数表

单继承中的虚函数表

class Base
{
public:
	virtual void func1() { cout << "Base::func1()" << endl; }
	virtual void func2() { cout << "Base::func2()" << endl; }
private:
	int a;
};

class Derive : public Base
{
public:
	virtual void func1() { cout << "Derive::func1()" << endl; }
	virtual void func3() { cout << "Derive::func3()" << endl; }
	virtual void func4() { cout << "Derive::func4()" << endl; }
private:
	int b;
};

在监视窗口中，我们发现看不见func3和func4。这里是编译器的监视窗口故意隐藏了这两个函数，相当于是编译器的一个bug。如何查看d中的虚表呢，我们可以用代码查看虚表中的函数

typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
{
	// 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}
int main()
{
	Base b;
	Derive d;
	VFPTR* vTableb = (VFPTR*)(*(int*)&b);
	PrintVTable(vTableb);
	VFPTR* vTabled = (VFPTR*)(*(int*)&d);
	PrintVTable(vTabled);
	return 0;
}

代码思路：取出b、d对象的头四个字节，就是虚表的指针，前面我们说了虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个nullptr

  1. 先取出b的地址，强转成int*的指针
  2. 再解引用取值，就取到了b对象头4字节的值，这个值就是指向虚表的指针
  3. 再强壮成VFPTR*，因为虚表就是一个存VFPTR类型（虚函数指针类型）的数组
  4. 虚表指针传递给PrintVTable进行打印虚表
  5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器对虚表的处理不干净，虚表最后面没有放nullptr，导致越界，这是编译器的问题。我们只需要清理解决方案就可以了

 

多继承中的虚函数表 

class Base1
{
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2
{
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2
{
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func2" << endl; }
private:
	int d1;
};

typedef void(*VFPTR)();
void PrintVTable(VFPTR VTable[])
{
	cout << " 虚表地址>" << VTable << endl;
	for (int i = 0; VTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址：0x%x，->", i, VTable[i]);
		VFPTR f = VTable[i];
		f();
	}
	cout << endl;
}

int main()
{
	Derive d;

	VFPTR* VTableb1 = (VFPTR*)(*(int*)&d);
	PrintVTable(VTableb1);

	VFPTR* VTableb2 = (VFPTR*)(*(int*)((char*)&d+sizeof(Base1)));
	PrintVTable(VTableb2);
	return 0;
}

我们可以看出来：多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中

一些问题

1. 下面哪种面向对象的方法可以让你变得富有( a ) A: 继承 B: 封装 C: 多态 D: 抽象

2. ( d )是面向对象程序设计语言中的一种机制。这种机制实现了方法的定义与具体的对象无关，而对方法的调用则可以关联于具体的对象。

A: 继承 B: 模板 C: 对象的自身引用 D: 动态绑定

3. 面向对象设计中的继承和组合，下面说法错误的是？（c）

A：继承允许我们覆盖重写父类的实现细节，父类的实现对于子类是可见的，是一种静态复用，也称为白盒复用

B：组合的对象不需要关心各自的实现细节，之间的关系是在运行时候才确定的，是一种动态复用，也称为黑盒复用

C：优先使用继承，而不是组合，是面向对象设计的第二原则

D：继承可以使子类能自动继承父类的接口，但在设计模式中认为这是一种破坏了父类的封装性的表现

4. 以下关于纯虚函数的说法,正确的是(a )

A：声明纯虚函数的类不能实例化对象 B：声明纯虚函数的类是虚基类

C：子类必须实现基类的纯虚函数 D：纯虚函数必须是空函数

5. 关于虚函数的描述正确的是(b )

A：派生类的虚函数与基类的虚函数具有不同的参数个数和类型 B：内联函数不能是虚函数

C：派生类必须重新定义基类的虚函数 D：虚函数可以是一个static型的函数

6. 关于虚表说法正确的是（ d）

A：一个类只能有一张虚表

B：基类中有虚函数，如果子类中没有重写基类的虚函数，此时子类与基类共用同一张虚表

C：虚表是在运行期间动态生成的

D：一个类的不同对象共享该类的虚表

7. 假设A类中有虚函数，B继承自A，B重写A中的虚函数，也没有定义任何虚函数，则（d ）

A：A类对象的前4个字节存储虚表地址，B类对象前4个字节不是虚表地址

B：A类对象和B类对象前4个字节存储的都是虚基表的地址

C：A类对象和B类对象前4个字节存储的虚表地址相同

D：A类和B类虚表中虚函数个数相同，但A类和B类使用的不是同一张虚表

8. 下面程序输出结果是什么? （a）

菱形虚拟继承之中，A的代码只有一份

using namespace std;
class A {
public:
	A(char* s) { cout << s << endl; }
	~A() {}
};
class B :virtual public A
{
public:
	B(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};
class C :virtual public A
{
public:
	C(char* s1, char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:
	D(char* s1, char* s2, char* s3, char* s4) :B(s1, s2), C(s1, s3), A(s1)
	{
		cout << s4 << endl;
	}
};
int main() {
	D* p = new D("class A", "class B", "class C", "class D");
	delete p;
	return 0;
}

A：class A class B class C class D B：class D class B class C class A

C：class D class C class B class A D：class A class C class B class D

9. 多继承中指针偏移问题？下面说法正确的是(c )

class Base1 {  public:  int _b1; };
class Base2 {  public:  int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main(){
 Derive d;
 Base1* p1 = &d;
 Base2* p2 = &d;
 Derive* p3 = &d;
 return 0;
}

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

10. 以下程序输出结果是什么（b）

using namespace std;
class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}

A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

  1. inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是 inline，因为虚函数要放到虚表中去。
  2. 静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针，使用类型::成员函数 的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
  3. 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表 阶段才初始化的。
  4. 析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。参考本节课件内容
  5. 对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
  6. 虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
  7. C++菱形继承的问题？虚继承的原理？答：注意这里不要把虚函数表和虚基表搞混了。
  8. 什么是抽象类？抽象类的作用？答：参考（3.抽象类）。抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。
滴落的星子。
关注
  • 22
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ 学习文档
05-02
理论学习只是掌握C++的第一步，通过编写实际项目和使用调试工具（如gdb）进行调试是深化理解的关键。 以上只是C++学习中的一小部分内容，这份"C++学习文档"可能涵盖了更深入的专题，例如设计模式、并发编程、模板元...
c++学习0524-13
05-24
可能你在学习如何使用C++的套接字库，比如Berkeley套接字接口，或者一个第三方库如Boost.Asio，来构建TCP或UDP的网络应用程序。 在实际的socklite项目中，你可能会学习如何创建套接字，绑定到特定端口，监听连接...
C++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
VTK-vtkStructuredGrid学习
weixin_69505365的博客
08-14 342
可以理解为单元格顺序沿着坐标轴排列，但是每个单元格可以不一样。维度理解为X/Y/Z方向的点数，如草图所示分别是4，3，1。此时只提供了12个点，只能构造一层，5.点图、线图、面图如下，对应行的代码改一下出现不同效果图。7.增加Z方向维度，点也要增加，点序保持一致。6.点可以不在同一个平面，随机改变点Z数值。2.获取这些点信息，点顺序要严格按照图示。直接赋值第一层的12个点，改一下Z值。所以Z方向维度是1，不能是其他数据。1.使用CAD随意绘制个网格草图。4.将上面的网格显示出来。
fme处理空间数据入门v0
weixin_43229258的博客
08-13 712
本教程是最最最基本的fme处理空间数据内容，给新同事介绍我以前是怎么干活用的，基本啥有用的东西。本教程主要说如何在 FME Workbench中创建模板文件（一般我们把fme写的工作空间就叫模板），教程里面主要是利用GIS数据。按照分步说明操作，1.了解如何从读取数据；2.添加转换器以在空间上过滤数据；3.将过滤后的数据写入 Esri Shapefile;4.如何运行模板文件。
VBA学习(26)：引用单元格/单元格区域的方法
nianfen的博客
08-13 454
实际上也可以将这些属性组合在一起，例如要选择数据底部的下一个新行，可以使用Range(“A1”).End(xlDown).Offset(1,0)，首先转到A1，向下到数据的底部，然后将结果向下偏移一行，以选择下一个空白行。引用连续单元格区域中最底部的单元格（即该单元格下方的单元格为空）。引用目标单元格的所有相关单元格，包括相关单元格的相关单元格。引用目标单元格的所有从属单元格，包括从属单元格的从属单元格。在VBA中，可以通过多种不同的方式来引用工作表中的单元格/单元格区域。引用目标单元格的从属单元格。
【Python】python中抽象类学习笔记
qq_42761751的博客
08-12 400
抽象类是一个不能被实例化的类，通常作为其他类的基类抽象方法是一个没有具体实现的方法一个抽象类可以有或者没有抽象方法, 但是一般来说定义抽象类的时候总会在类中定义抽象方法Python并没有直接支持抽象类，但是提供了一个模块（abc）来允许定义抽象类通过继承abc.ABC类定义一个抽象类pass上述代码中类虽然继承了ABC但是没有定义抽象方法，仍然可以被实例化。"""使用@abstractmethod来定义抽象方法"""passmain()代码报错：不能实例化一个带有抽象方法的抽象类。
后端学习笔记（6）--添加删除
qwsadsdga的博客
08-11 315
1.编写接口方法：Mapper接口​ *参数：除了id之外的所有数据​ *结果：void2.编写SQL语句：SQL映射文件3.执行方法，测试​ *MyBatis事务：*openSession():默认开启事务，进行增删改操作后需要使用sqlSession.commit();手动提交事务*openSession(true):可以设置为自动提交事务(关闭实物)4.主键返回​ *在数据添加成功后，需要获取插入数据库数据的主键的值​ *比如：添加订单和订单项1.添加订单。
如何学习Kubernetes？
CloudJourney的博客
08-13 647
在云计算和容器化技术日新月异的今天，Kubernetes（简称K8s）作为容器编排领域的领头羊，已经成为现代应用部署和管理的标准工具。本文旨在为有志于学习Kubernetes的读者提供一条清晰的学习路径，从基础概念到高级特性，再到实战应用，帮助大家逐步掌握这门强大的技术。通过本文提供的学习路径和实战建议，希望能够帮助你逐步掌握这门强大的技术，并在实际项目中灵活应用。同时，Kubernetes还提供了强大的社区支持和丰富的生态系统，使得开发者可以轻松地找到适合自己的解决方案。
如何高效记录并整理编程学习笔记
vvvae1234的博客
08-13 1234
在编程学习的旅程中，好的笔记记录和整理方法不仅能帮助我们更有效地吸收知识，还能在复习时提供清晰的参考。下面，我将为您提供一些建立高效笔记系统的建议，以帮助您在繁忙学习中保持笔记的条理性，从而打造属于自己的编程学习“知识宝库”。方向一：笔记工具选择方向二：笔记结构设计方向三：实践与复习策略
最长的一帧学习 part1
qq_42491346的博客
08-12 894
最长的一帧学习
新手学习华为HCIE，会遇到哪些“坑”？
HCIE_SPOTO的博客
08-12 428
相信大部分一开始了解HCIE的朋友们都会被考试费用所震惊，确实相对IA、IP，HCEI的考试费用是比较高的，毕竟还有实验嘛。在这个过程中，你可能会遇到资料选择的迷茫、实验操作搞不清楚，很难、考试报名的繁琐，甚至是费用管理的压力。很多朋友会说，既然都那么多可以选择的了，那随便找几本书，几个视频，难道不能开始学习吗？上找找，有的论坛，比如说思博的雏鹰部落论坛就会有一些题库，大家找到之后可以多加练习。的小伙伴，想要找华为HCIE实验题库，可以去一些。另外，HCIE考试的费用，其实是可以“打折”的，
学习量化交易怎么入门，怎样才能利用好量化交易？
V_ZQKHJL98的博客
08-12 174
1、要明确自己的投资目标和风险承受能力，量化交易在开通前也会签署风险揭示书，虽然是基于数据和算法进行决策，但也需要风险匹配。2、量化交易策略要合适，策略是多种多样的，包括多因子策略、均值回归策略、动量效应策略、二八轮动策略、海龟交易策略、机器学习策略、高频交易策略以及套利交易策略等。每个人要根据自己的情况选择适合自己的策略并深入研究和回测，不要贪多，贪多嚼不烂。
EmguCV学习笔记 VB.Net 2.2 Matrix类
最新发布
UruseiBest 的技术专栏
08-15 567
Matrix类是EmguCV中的一个矩阵类，它可以用来存储和处理矩阵数据，可以处理任意维度的矩阵。与Mat类相比，Matrix类提供了更多的矩阵运算方法，如矩阵加减、乘法、逆矩阵等，也更加灵活，而且底层实现也更加高效。例如，当均值为0，标准差为1时，生成的随机矩阵的像素值符合标准正态分布。当均值为0，标准差为0.5时，生成的随机矩阵的像素值分布更加集中，更接近于均值。该控件位于【工具箱】|【Emgu.CV】下面。SetRandNormal方法只能生成正态分布的随机矩阵，不能生成其他分布的随机矩阵。
详细学习PyQt5的样式表与界面美化
weixin_49520696的博客
08-13 1078
在实战练习和学习的过程中,记得总结和反思自己的样式表编写经验。养成良好的命名习惯,使用有意义的选择器名称和注释,提高样式表的可读性。将常用的样式提取为通用样式类,促进样式的重用和一致性。合理使用继承和层叠,避免不必要的样式重复和冲突。注意样式表的性能影响,避免过于复杂的选择器和过多的样式规则。定期重构和优化样式表,保持样式表的整洁和可维护性。与团队成员分享和交流样式表的最佳实践,促进知识共享和代码质量提升。/* 通用样式 */QWidget {/* 按钮样式 */
【Qt】QPluginLoader 类学习
油炸自行车的博客
08-13 721
QPluginLoader类在运行时加载插件。提供对Qt插件的访问。Qt插件存储在共享库（如 DLL 文件）中，相比于QLibrary访问的共享库，会检查插件是否与应用程序使用的Qt版本一致；提供对根组件对象 (instance())的直接访问，而无需动手解析C函数。对象的实例操作单个共享库文件，这个共享库文件被称为插件。它以独立于平台的方式提供对插件中功能的访问。要指定要加载的插件，请在构造函数中传递文件名，或者使用方法进行设置。使用类一旦加载成功，插件会保留在内存中，直到所有实例都被卸载
第二十四天学习笔记2024.8.8
shenxiaode的博客
08-12 893
list.remove(list[index]) #删除序列号为index的元素。[root@localhost ~]# yum list installed |grep python （查看是否安装python以及版本）4){"name":"张三","age":"20","gender":"male",}[root@localhost ~]# yum list installed |grep epel （查看是否安装epel ）list.pop() #删除list中的最后一个元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值