量化交易之C++篇 - 继承（基础、虚基类、继承方式、构造与析构的调用顺序、同名处理、静态成员的处理、多继承、菱形继承）

最新推荐文章于 2023-10-20 09:38:53 发布
最新推荐文章于 2023-10-20 09:38:53 发布
阅读量230 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Michael_234198652/article/details/115831636
版权 
// 继承的基础
#include <iostream>

using namespace std;

class BaseWeb {

public:
	void header() {
		cout << "公共头部" << endl;
	}

	void footer() {
		cout << "公共底部" << endl;
	}

	void left() {
		cout << "左侧列表" << endl;
	}

};

class News: public BaseWeb { // 继承

public:

	void content() {
		cout << "新闻播放" << endl;
	}

};

class Entertainment: public BaseWeb {

public:

	void content() {
		cout << "白百合..." << endl;
	}

};

class Game : public BaseWeb {

public:
	void content() {
		cout << "KPL 直播" << endl;
	}
};

void test01() {

	News news;
	news.header();
	news.footer();
	news.content();

	Entertainment entertainment;
	entertainment.header();
	entertainment.footer();
	entertainment.content();
}

int main() {

	test01();

	return EXIT_SUCCESS;
}
// 虚基类
#include <iostream>
#include <string>

using namespace std;


class Animal {
public:
	int age;
};

class Sheep : virtual public Animal { // 虚基类
	
};

class Tuo : virtual public Animal {

};

class SheepTuo : public Sheep, public Tuo {

};


// 菱形继承的解决方案 利用虚基类
// 操作的是共享的一份数据
void test01() {

	SheepTuo sheepTuo;
	sheepTuo.Sheep::age = 10;
	sheepTuo.Tuo::age = 20;

	cout << sheepTuo.Sheep::age << endl;
	cout << sheepTuo.Tuo::age << endl;
	cout << sheepTuo.age << endl; // 可以直接访问了
}


int main() {

	test01();

	return EXIT_SUCCESS;
}
// 继承方式
#include <iostream>

using namespace std;

class Base1 {
public:
	int a;
protected:
	int b;
private:
	int c;
};

class Son1: public Base1 {

public:
	void publicFunction() {
		cout << this->a << endl; // 父类中 共有的属性 可继承, 继承后是 public;
		cout << this->b << endl; // 父类中 保护的属性 可继承, 继承后是 protected;
		//cout << this->c << endl; // 父类中私有的属性 不可继承;
	}
};

void test01() {

	Son1 son1;

	son1.a = 10;

	cout << son1.a << endl;
}


class Base2 {
public:
	int a = 0;
protected:
	int b = 0;
private:
	int c = 0;
};

class Son2 : protected Base2 {

public:
	void func() {
		cout << this->a << endl; // 父类中 共有的属性 可继承, 继承后是 protected
		cout << this->b << endl; // 父类中 保护的属性 可继承, 继承后是 protected
		//cout << this->c << endl; // 父类中私有的属性 不可继承;
	}
};

class GrandSon2 : public Son2 {

public:
	void publicFunction() {
		cout << this->a << endl;
		cout << this->b << endl;
	}
protected:
	void protectedFunction() {
		cout << this->a << endl;
		cout << this->b << endl;
	}
private:
	void privateFunction() {
		cout << this->a << endl;
		cout << this->b << endl;
	}
};
void test02() {
	Son2 son2;

	GrandSon2 grandSon2;

	//son1.a = 10; // 继承后的 a 是保护属性, 外部不可以访问
	//cout << son1.a << endl;
	//grandSon2.a = 10; // 再次继承后的 a 也是保护属性, 外部不可以访问
}


class Base3 {
public:
	int a;
protected:
	int b;
private:
	int c;
};

class Son3 : private Base3 {

public:
	void publicFunction() {
		cout << this->a << endl; // 父类中 共有的属性 可继承, 继承后是 private;
		cout << this->b << endl; // 父类中 保护的属性 可继承, 继承后是 private;
		//cout << this->c << endl; // 父类中私有的属性 不可继承;
	}
};

class GrandSon3 : public Son3 {

public:
	void publicFunction() {
		//cout << this->a << endl; // 父类中 私有的属性 不可继承;
		//cout << this->b << endl; // 父类中 私有的属性 不可继承;
		//cout << this->c << endl; // 父类中 私有的属性 不可继承;
	}

};

void test03() {
	Son3 son3;

	son3.publicFunction();
}

int main() {

	test03();

	return EXIT_SUCCESS;
}
// 析构与构造函数的调用顺序
#include <iostream>

using namespace std;


class Base {

public:
	int a;
protected:
	int b;
private:
	int c;

};

// 实际上 子类中会继承父类的 private 成员变量, 只是被编译器给隐藏起来了, 所以访问不到私有成员;
class Son : public Base {

public:
	int d;

};

void test01() {
	cout << sizeof(Base) << endl;
	cout << sizeof(Son) << endl;
}


class Base2 {

public:
	Base2(int a) {
		cout << "Base2 有参构造函数 调用" << endl;
		this->a = a;
	}

	~Base2() {
		cout << "Base2 析构函数 调用" << endl;
	}

	int a;
};


class Son2 : public Base2 {
public:
	Son2(int a): Base2(a) { // 利用初始化列表方式 显示调用 有参构造
		cout << "Son2 有参构造函数 调用" << endl;
	}

	~Son2() {
		cout << "Son2 析构函数 调用" << endl;
	}
};

void test02() {
	Son2 son2(1000); // 构造函数先调用父类, 后调用子类; 析构函数先调用父类, 后调用子类; 另外 子类不会继承父类的构造函数和析构函数;
}

int main() {

	test02();

	return EXIT_SUCCESS;
}
// 继承中的同名处理
#include <iostream>

using namespace std;

class Base {

public:
	Base() {
		this->a = 100;
	}

	void publicFunction() {
		cout << "Base public function" << endl;
	}

	void publicFunction(int a) {
		cout << "Base public function(int a)" << endl;
	}

	int a;
};

class Son : public Base {

public:
	Son() {
		this->a = 200;
	}

	void publicFunction() {
		cout << "Son public function" << endl;
	}

	void publicFunction(int a) {
		cout << "Son public function(int a)" << endl;
	}

	int a;
};

void test01() {
	Son son1;

	// 成员属性
	cout << son1.a << endl; // 如无特殊声明, 子类对象会直接调用本类的属性;
	cout << son1.Base::a << endl; // 子类对象 调用父类的 a 属性;
	
	// 成员函数
	son1.publicFunction(); // 直接调用时, 会先调用子类; 
	son1.Base::publicFunction(); // 父类的同名函数会被隐藏, 除非用作用域运算符去调用;

	son1.publicFunction(10);
	son1.Base::publicFunction(10);
}

int main() {

	test01();

	return EXIT_SUCCESS;
}
// 继承中静态成员的处理
#include <iostream>

using namespace std;

class Base {
public:
	static int a;

	static void publicFunction() {
		cout << "Base public function: " << endl;
	}

	static void publicFunction(int a) {
		cout << "Base public function(int a): " << a << endl;
	}

};
int Base::a = 10;


class Son : public Base {

public:
	static int a;

	static void publicFunction() {
		cout << "Son public function: " << endl;
	}

	static void publicFunction(int a) {
		cout << "Son public function(int a): " << a << endl;
	}

};
int Son::a = 20;


void test01() {

	cout << "Son::a : " << Son::a << endl; // 静态成员属性, 子类可以继承
	cout << "Son::Base::a : " << Son::Base::a << endl;

}

void test02() {
	Son::publicFunction(100);
	Son::Base::publicFunction(1000);

	Son::publicFunction();
	Son::Base::publicFunction();
}


int main() {
	
	test02();

	return EXIT_SUCCESS;
}
// 多继承
#include <iostream>
#include <string>

using namespace std;


class Animal {
public:
	int age;
};

class Sheep : virtual public Animal { // 虚基类
	
};

class Tuo : virtual public Animal {

};

class SheepTuo : public Sheep, public Tuo {

};


// 菱形继承的解决方案 利用虚基类
// 操作的是共享的一份数据
void test01() {

	SheepTuo sheepTuo;
	sheepTuo.Sheep::age = 10;
	sheepTuo.Tuo::age = 20;

	cout << sheepTuo.Sheep::age << endl;
	cout << sheepTuo.Tuo::age << endl;
	cout << sheepTuo.age << endl; // 可以直接访问了
}

int main() {

	test01();

	return EXIT_SUCCESS;
}
// 菱形继承的概念以及问题
#include <iostream>
#include <string>

using namespace std;


class Animal {
public:
	int age;
};

class Sheep : virtual public Animal { // 虚基类
	
};

class Tuo : virtual public Animal {

};

class SheepTuo : public Sheep, public Tuo {

};


// 菱形继承的解决方案 利用虚基类
// 操作的是共享的一份数据
void test01() {

	SheepTuo sheepTuo;
	sheepTuo.Sheep::age = 10;
	sheepTuo.Tuo::age = 20;

	cout << sheepTuo.Sheep::age << endl;
	cout << sheepTuo.Tuo::age << endl;
	cout << sheepTuo.age << endl; // 可以直接访问了
}


int main() {

	test01();

	return EXIT_SUCCESS;
}

 

_Erwin_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
如何使用C++实现你的量化交易策略
塞尔达的传说
04-30 5833
原 如何使用C++实现你的量化交易策略 编者按语：本文通过基于掘金量化交易平台支持C++编程语言的金融量化模型开发，介绍使用C++语言实现您的量化交易策略模型。 一、C++  SDK 文档指引 1.快速新建策略 ◆打开终端后，登陆掘金账号点击研究策略，新建策略 或者点击右上角新建策略 ◆新建一个典型默认账号交易策略 新建C++的默认账号交易策略   2、编译策略 ◆打开新...
C++继承，多重继承，同名函数继承，菱形继承
m0_72647108的博客
08-09 81
cout
C++连接CTP接口实现简单量化交易（行情、交易、k线、策略）
热门推荐
踏莎行的博客
04-18 11万+
本文章和相关代码已不再更新，在行业合规的范围内，进一步的量化金融技术交流，可以扫码咨询 对于量化交易来说，量化策略和技术系统缺一不可，为了知其所以然，本文实现了一个C++连接CTP接口进行仿真交易的demo，从接收行情、下订单、数据处理到添加策略、挂载运行交易等多个环节来看一下量化交易的最简单流程，管中窥豹，一探究竟。 准备工作 交易所接口 这里使用上期所提供的CTP接口API，通过...
量化交易之C++篇 - 函数模板的基本用法
04-20 320
// 函数模板的基本用法 #include <iostream> using namespace std; void swapInt(int& a, int& b) { int temp = a; a = b; b = temp; } void test01() { int a = 1; int b = 2; cout << "a: " << a << " b: " << b << en.
量化交易之C++篇 - STL三大组件
04-24 229
#include <iostream> #include <string> using namespace std; #include <vector> // 容器 vector #include <algorithm> // 使用系统算法的头文件 // 迭代器 遍历功能 用指针理解; // 普通指针也算一种迭代器; void test01() { int array[5] = { 1, 3, 5, 6, 8 }; int* p = arra.
C++继承，多继承，菱形继承等超详细讲解
qq_44819750的博客
07-20 578
继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 class A { public: A(int a) :_a(a) {} void print() { cout<<"i am son"<<endl; } privat
C++ 虚继承对基类构造函数调用顺序的影响
01-20
可见性继承比较简单，而虚拟继承对学习c++的难度较大。 　首先，虚拟继承与普通继承的区别有： 　假设derived 继承自base类，那么derived与base是一种“is a”的关系，即derived类是base类，而反之错误； 　...
C++ 课程作业 继承与派生 （motorcycle类设计（虚基类））
04-18
声名一个基类vehicle,有私有成员maxspeed和weight，公有成员run()和stop(),以及构造和析构函数。 从vehicle派生bicycle和motorcar, bicycle有私有成员height， motorcar有私有成员seatnum,以及各自的构造函数和析构...
类的继承第二次作业（多重继承与虚基类）参考答案_C++_teacher_
09-29
定义一个Person 类，...Person 类以Public方式派生出一个Teacher类，数据成员包括：int gh(工号)；char* title(职称)，为该类添加输入输出流运算符重载，完成有参、无参、拷贝构造函数的定义，在主函数测试Teacher类
量化金融完整C++代码
04-07
包含客服端数据库风险控制等模块的C++量化代码
C++多重继承与虚继承分析
01-01
本文以实例形式较为全面的讲述了C++的多重继承与虚继承，是大家深入学习C++面向对象程序设计所必须要掌握的知识点，具体内容如下： 一、多重继承 我们知道，在单继承中，派生类的对象中包含了基类部分 和 派生类...
C++类成员构造函数和析构函数顺序示例详细讲解
01-20
即构造类时，会先构造其父类，然后创建类成员，最后调用本身的构造函数。 下面看一个例子吧 代码如下:class c{public: c(){ printf(“c\n”); }protected:private:}; class b {public: b(){ printf(“b\n”);}...
量化交易之C++篇 - rapidjson - demo示例
05-30 125
【代码】量化交易之C++篇 - rapidjson - demo示例。
量化C++国产框架千星+ WonderTrader
人工智能曾小健
09-24 5114
一些策略计算量会非常惊人，比较典型的就是选股策略，不管是用多因子也好，还是基本面也好，都会从数千只股票中，逐步筛选，从而得到最后的目标股池。）开发核心模块的量化交易平台，在标的数不多的情况下，能够胜任各种不同的应用场景。引擎采用异步时间驱动的模式，通过向引擎注册重算时间调度（支持日内，每日、每周、每月的等多种周期），定时触发重算，然后调整多标的的目标仓位，从而输出信号。用户在使用的时候，通过设置指定标的的目标头寸，算法执行单元就可以按照预设的算法进行交易下单。，会考虑更多的兼容性问题以及应用层对接的问题，
量化交易领域，C++ vs. Python，你的最佳选择是什么？
最新发布
wly55690的博客
10-20 532
如果你对量化交易感兴趣，那么你一定会面临一个问题：到底应该用哪种编程语言来实现你的策略呢？你可能听说过C++和Python是两种很流行的选择，但是它们各有什么优缺点呢？哪一种更适合你的需求呢？今天，大家和小编就来一起探讨一下这个话题。
量化交易之C++篇 - 异常基本处理、异常变量的生命周期、异常的多态使用、使用系统提供的标准异常、自己编写异常类
04-24 238
// 异常基本处理 #include <iostream> #include <string> using namespace std; class MyException { // 自定义异常类 public: void printError() { cout << "自定义的异常" << endl; } }; class Person { public: Person(string name) { this->name =.
量化
C++菜鸟之C++之旅
06-09 2467
量化交易之C++篇 - 多线程（future、share_future）
02-08 1137
#include <iostream> #include <map> #include <utility> #include <list> #include <future> #include <thread> using namespace std; void threadIdTest() { // 获取当前线程id std::thread::id threadId = std::this_thread::get_id(.
c++虚继承之后没有调用基类的构造函数
04-26
在虚继承中，由于虚基类并没有被直接继承，所以派生类需要先调用虚基类的构造函数，再调用自身的构造函数。如果派生类没有显式地调用虚基类的构造函数，那么编译器会自动生成一份默认的构造函数，用于调用虚基类的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值