override,final的使用，两者都是针对虚函数，也就是说要有virtual关键字

1.override,final的使用，两者都是针对虚函数，也就是说要有virtual关键字

#include <iostream>

//C++中的final和override主要是针对虚函数

//加了final表示拒绝重写，这是为了使某些情况下，拒绝接口的重写

//override,声明重写父类的方法，前提是要有virtual关键字修饰函数。

//当父类没有接口，会提示错误

class ye

{

public:

//final修饰的函数必须是虚函数,通过这种方式避免重写了一些老的接口

virtual void print() final //加了final表示虚函数无法重写了

{

std::cout << "爷爷\n";

}

virtual void run()

{

std::cout << "爷爷run\n";

}

};

class ba :public ye

{

public:

void run() override

{

std::cout << "爸爸run\n";

}

};

void main()

{

ba ba1;

ba1.run(); //结果是：爸爸run

std::cin.get();

}

2.RTTI 实时类类型检测

#include <iostream>

//rtti,实时类类型检测

//typeid,dynamic_cat必须依赖于虚函数表

//类型不匹配转换失败，返回为空，类型安全

//成员变量的覆盖

//虚函数有虚函数表确定数据类型

class A

{

public:

int num;

static int data;

virtual void run()

{

std::cout << "A run \n";

}

};

//对A中的静态变量进行初始化

int A::data = 1;

class B :public A

{

public:

int num = 0;

static int data;

void run()

{

std::cout << "B run\n";

}

void test()

{

std::cout << num << "\n";

std::cout << "B test\n";

}

};

int B::data = 2;

void main()

{

A a1;

B b1;

A *p1 = &a1;

A *p2 = &b1;

B *p3(nullptr);

//p3 = static_cast<B *>(p1);//直接赋地址，不安全，与虚函数无关

p3 = reinterpret_cast<B *>(p2);

std::cout << p3 << "\n";

p3->test();

std::cin.get();

//此次运行结果：

//008FFE70

//0

//B test

}

3.C函数指针复习

#include <stdlib.h>

int add(int a,int b)

{

return a + b;

}

void run()

{

printf("\nrun");

}

void main()

{

int(*p)(int, int) = add;//指向add的函数指针

void(*p1)() = run;//指向run的函数指针

printf("%d\n",p(1,2));

printf("%d\n",(*p)(1,2)); //*p编译器自动将*p解释为p

printf("%d\n",(******p)(1,2));//*p编译器自动将*p解释为p

printf("%d\n", (&(**p))(1, 2)); //&没有*不可以执行，超过两个地址就不可以

//&p不能，

//printf("%d\n", (&(p))(1, 2));

printf("%p,%p,%p", &p, *p, p);

printf("\n%p,%p,%p", &p1, *p1, p1);

//取地址，就是CPU即将调用函数执行

getchar();

}

运行结果：

4.CPP函数指针

#include <iostream>

#include <stdlib.h>

void add(int a,int b)

{

std::cout << a + b << std::endl;

}

void main()

{

void(*p)(int, int) = add;

p(1, 2);

(*p)(1,2); //函数指针，会被当做指针来处理，*p与p效果一样

(*************p)(1,2);//函数指针，会被当做指针来处理，*p与p效果一样

(*&p)(1,2);

(*******&p)(1,2);

std::cout << (void *)p << " " << (void *)(*p) << std::endl;

std::cout << typeid(p).name() << std::endl;

std::cout << typeid(*p).name() << std::endl;

std::cout << typeid(&p).name() << std::endl;

std::cout << typeid(*&p).name() << std::endl;

//C++编译器会自动将*p处理为p

std::cin.get();

}

运行结果：

5.类成员函数指针数组

#include <iostream>

#include <stdio.h>

//类成员函数指针，类成员函数指针数组，类成员二级函数指针

class com

{

private:

int a;

int b;

public:

com(int x, int y) :a(x), b(y)

{

}

int jia(int a, int b)

{

return a + b;

}

int jian(int a, int b)

{

return a - b;

}

int cheng(int a, int b)

{

return a * b;

}

int chu(int a, int b)

{

return a / b;

}

};

void main()

{

com com1(100, 20);

auto fun1 = &com::jia;

int(com::*p)(int, int) = &com::jia; //注意这里要加上对象名

std::cout << (com1.*p)(10, 20) << std::endl;//引用对象，类成员函数指针

std::cout << typeid(p).name() << std::endl;

std::cout << typeid(fun1).name() << std::endl;

std::cin.get();

}

5.CPP函数指针数组

#include <iostream>

#include <stdio.h>

//类成员函数指针，类成员函数指针数组，类成员二级函数指针

class com

{

private:

int a;

int b;

public:

com(int x, int y) :a(x), b(y)

{

}

int jia(int a, int b)

{

return a + b;

}

int jian(int a, int b)

{

return a - b;

}

int cheng(int a, int b)

{

return a * b;

}

int chu(int a, int b)

{

return a / b;

}

};

typedef int(com::*P)(int, int);//为函数指针定义别名p

void main()

{

com com1(100, 200);

//下面这种方式也是没有错的

//P fun1[4] = { &com::jia, &com::jian, &com::cheng,&com::chu };

//类成员函数指针数组

int(com::*fun1[4])(int, int) = { &com::jia, &com::jian, &com::cheng, &com::chu };

for (int i = 0; i < 4; i++)

{

std::cout << (com1.*fun1[i])(10, 20) << std::endl;

}

int(com::**funp)(int, int) = fun1;//指向类成员函数指针的指针

for (; funp < fun1 + 4;funp++)

{

std::cout << (com1.**funp)(10, 20) << std::endl;

printf("%p",*funp);

}

for (int i = 0; i < 4;i++)

{

auto func = fun1[i];

std::cout << typeid(func).name() << std::endl;

printf("%p", func);

}

std::cin.get();

}

运行结果：

6.高级new对象

#include<iostream>

class myclass

{

public:

myclass()

{

std::cout << "创建\n";

}

~myclass()

{

std::cout << "销毁\n";

}

};

void main()

{

char *pcathe = new char[1024];

char *pcatheend = pcathe + 1024;

std::cout << (void*)pcathe << " " << (void*)pcatheend << std::endl;

myclass *p = new(pcathe)myclass[10];//限定区域分配内存，覆盖模式

std::cout << p << std::endl;

//delete[] p;一般不需要delete.自动覆盖

std::cout << p << std::endl;

p = new(pcathe)myclass[10];

std::cout << p << std::endl;

//delete[] p;//只能释放一次

std::cout << p << std::endl;

myclass *pclass = new myclass[10];

std::cout << pclass <<std::endl;

delete []pclass;

pclass = NULL;

std::cout << pclass <<std::endl;

pclass = new myclass[10];

std::cout << pclass <<std::endl;

delete [] pclass;

std::cout << pclass <<std::endl;

std::cin.get();

}

override,final的使用，两者都是针对虚函数，也就是说要有virtual关键字相关推荐

虚函数表对C++ 了解的人都应该知道虚函数
虚函数表对C++ 了解的人都应该知道虚函数(Virtual Function)是通过一张虚函数表(Virtual Table)来实现的.简称为V-Table.在这个表中,主是要一个类的虚函数的地址表 ...
C++11强类型枚举，override/final
C++11(一)开篇这个系列主要介绍C++11的一些新的特性,C++11问世至今已经有将近十年了.但是许多公司仍然停留在C++98上.之前在部门分享过C++11的知识,在这里分享给有需要的人. C+ ...
c++ 11 override final
C++ 11添加了两个继承控制关键字:override和final. override确保在派生类中声明的重载函数跟基类的虚函数有相同的签名.final阻止类的进一步派生和虚函数的进一步重载出处:h ...
c++ override final关键字
final: 1.一个类或结构体不希望被继承 class Base final {};class Derive : public Base {}; 报错信息如下: 1.cpp:34:7: error: ...
阿里云PyODPS 0.7.18发布，针对聚合函数进行优化同时新增对Python 3.7支持
近日,阿里云发布PyODPS 0.7.18,主要是针对聚合函数进行优化同时新增对Python 3.7支持. PyODPS是MaxCompute的Python版本的SDK,SDK的意思非常广泛,辅助开发 ...
C++ override及虚函数的讲解
胡马依北风随笔 - 46 文章 - 0 评论 - 11 博客园首页新随笔联系管理订阅 C++11 之 override 1 公有继承公有继承包含两部分:一是 &quo ...
C++ link2005 error 错误解决方法汇总（一般重复定义，如果都是不就是函数定义和实现没有分离）...
一般都是重复定义. 可以按照VS给出的信息去找相关的变量或者宏定义,还有函数. 这里需要注意include,不要重复include,不要重复定义宏. 但上述这些,都是很好理解的-- 如果大家按照上边说 ...
C++构造函数和析构函数调用虚函数时都不会使用动态联编
先看一个例子: #include <iostream> using namespace std;class A{ public:A() {show();}virtual void show ...
把接口作为函数的参数，那么任何实现了接口的类的实例都可以作为此函数的参数传递...
把接口作为函数的参数,那么任何实现了接口的类的实例都可以作为此函数的参数传递转载于:https://www.cnblogs.com/xiaodangshan/p/9784315.html

override,final的使用，两者都是针对虚函数，也就是说要有virtual关键字

override,final的使用，两者都是针对虚函数，也就是说要有virtual关键字相关推荐

最新文章

热门文章