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();

}