07_类类型转换、继承、虚基类、 静态联编 与 动态联编、父子类指针、虚函数、类模板

最新推荐文章于 2022-11-22 12:00:00 发布
最新推荐文章于 2022-11-22 12:00:00 发布
阅读量671 收藏 1
点赞数
分类专栏： C++

【目录】

一、 类类型转换 3
１、 方法一：构造函数 3
２、 方法二：转换函数（注：只能是成员函数，不能是友元函数） 3
３、 转换函数 —> 类与类之间转换 3
二、 继承——public、private、protected 4
１、 多继承 ：C++支持多继承，单继承； 5
２、 多态所能访问的是父类的函数； 5
３、 :public 类 ——公有继承可以访问除了私有以外的成员属性，且继承后保持父类的公有与保护属性不变； 5
４、 :private 类 ——私有继承可以访问除了私有以外的成员属性，但是继承后父类的公有和私有属性都变为子类的私有属性，所以不能继续继承下去。 5
５、 :protected 类 ——保护继承可以访问除了私有以外的成员属性，但是继承后父类的公有和私有属性都变为子类的保护属性，外部不能访问，所以可以无限继承下去。 5
６、 Static 公有成员变量 可以继承下去； 5
７、 Static 函数； 5
８、 基类初始化 ： 5
９、 单继承函数重载： 6
１０、 多继承简介： 6
三、 虚基类 7
１、 定义： 7
四、 静态联编 与 动态联编 9
１、 联编： 9
２、 静态联编 9
３、 动态联编 9
五、 父类指针与子类指针 9
１、 父类指针引用父类对象，完全正常引用； 9
２、 子类指针引用子类对象，覆盖父类的同名函数； 10
３、 父类指针引用子类对象，只能引用父类中的函数； 10
４、 子类指针，引用父类对象，子类不涉及内部数据的函数会调用成功（主要是没初始化）。 10
５、 注意： 10
六、 父类与子类指针释放 12
１、 父类引用子类–>内存泄漏 13
２、 子类引用父类–>内存越界 13
３、 解决：智能指针、虚析构函数 13
七、 虚函数（虚基类）——多态 13
１、 虚函数的作用： 13
２、 纯虚函数 15
３、 构造函数不能是虚函数 15
４、 虚析构函数—-解决内存泄漏 15
５、 抽象类不可以用于函数的参数以及返回值类型，抽象类指针是可以； 15
６、 抽象类叠加 16
八、 异质链表 16
１、 定义： 16
九、 类模板 16
１、 说明及构成： 16
２、 例子： 16
３、 两种数据类的的函数模板： 17
４、 C++的数组array也是类模板 17
５、 类模板做函数参数 20
６、 类模板做类模板参数 20
７、 C++11 final 与 override 21
８、 类模板的继承与多态 22
９、 类模板友元函数 24
１０、 友元类类模板 25
１１、 Static 与 类模板 26
１２、 类嵌套以及类模板嵌套 27
十、 位运算算法 28
１、 加法： 28
２、 计位数： 29
十一、 Rtti（实时类型检测） 29
１、 成员变量覆盖： 29
十二、 高级new —对象 31
十三、 类包装器与函数包装器 32
十四、 类成员函数指针 33
１、 P与*p等价 33
２、 Cpp的函数指针 34
３、 Cpp的类成员函数指针 34

一、类类型转换

  １、方法一：构造函数（转换构造函数，三种情况下发生）
  ２、方法二：转换函数（注：1、只能是成员函数，不能是友元函数；2、与操作符重载不同）
    ①．格式：

Operator T(){
    /*伪码：执行自己的操作*/
    Return T ;
}
/*--------------------------------------------------*/
#include<iostream>
using namespace std ;

class mianji{
    private :
        int x ;
        int y ;
    public :

        mianji( int x , int y ) { 
            this->x = x ; 
            this->y = y ;
        }
        operator int(){ /*转换函数*/
            return this->x + this->y ;
        }
        friend ostream & operator <<( ostream & out , mianji & mm ) ;
};
ostream & operator <<( ostream & out , mianji & mm ) {
    out<<"output : "<< mm.x  <<"+"<<mm.y<<"i"<<endl ;
    return out ;
}
int main( int argc , char** argv ) {

    mianji m1( 2 , 3 ) ;/*利用构造函数转换类型*/
    cout<< m1 <<endl ;

    int x = m1 ; /*利用转换函数，将自己定义的类转化为基本类型*/
    cout<< x <<endl ;

    system("pause") ;
    return 0 ;
}

  ３、转换函数 —> 类与类之间转换

#include<iostream>
using namespace std ;

class mianji{
    private :
        int x ;
        int y ;
    public :

        mianji( int x , int y ) { 
            this->x = x ; 
            this->y = y ;
        }
        operator int(){
            return this->x + this->y ;
        }
        friend ostream & operator <<( ostream & out , mianji & mm ) ;
        friend class fushu ;
};
class fushu {
    private :
        int cx ;
        int cy ;
    public :
        fushu( int x , int y ):cx(x),cy(y){}
        operator mianji(){
            mianji temp(0,0) ;
            temp.x = this->cx ;
            temp.y = this->cy ;
            return temp ;
        }
} ;
ostream & operator <<( ostream & out , mianji & mm ) {
    out<<"output : "<< mm.x  <<"+"<<mm.y<<"i"<<endl ;
    return out ;
}
int main( int argc , char** argv ) {

    mianji m1( 2 , 3 ) ;/*利用构造函数转换类型*/
    cout<< m1 <<endl ;

    int x = m1 ; /*利用转换函数，将自己定义的类转化为基本类型*/
    cout<< x <<endl ;

    /*类与类之间的转换*/
    fushu f1( 22 , 33 ) ;
    mianji mm(11,11) ;
    cout<< mm << endl ;
    /*以下是三种转化写法*/
    mm = (mianji)f1 ;
    mm = f1 ;
    mm = mianji(f1) ;
    cout<< mm <<endl ;


    system("pause") ;
    return 0 ;
}

二、继承——public、private、protected

  １、多继承 ：C++支持多继承，单继承；
  ２、多态所能访问的是父类的函数；

fu *p = new son ;
p->show() ; /*这里调用的是父类的show函数*/
p->boy() ;/*这是子类特有的公有函数，多态父类指针不能访问*/
/*-------------------------------------------------------*/
    fu *p = new son ;
    p->show() ;
    son *ps = reinterpret_cast<son *>(p) ;
    ps->show() ;/*这里调用的是子类的show函数*/
    ps->fu::show() ;/*这里调用的是父类的show函数*/
    ps->boy() ;

  ３、:public 类 ——公有继承可以访问除了私有以外的成员属性，且继承后保持父类的公有与保护属性不变；
  ４、:private 类 ——私有继承可以访问除了私有以外的成员属性，但是继承后父类的公有和私有属性都变为子类的私有属性，所以不能继续继承下去。
  ５、:protected 类 ——保护继承可以访问除了私有以外的成员属性，但是继承后父类的公有和私有属性都变为子类的保护属性，外部不能访问，所以可以无限继承下去。
  ６、Static 公有成员变量 可以继承下去；
  ７、Static 函数；
  ８、基类初始化 ：

#include<iostream>
using namespace std ;

class fu {
    public :
        fu(){
            cout<<"b fu"<<endl ;
        }
        fu( int x ) : x(x) {
            cout<<"b fu num "<< this->x <<endl ;
        }
        ~fu(){
            cout<<"e fu"<<endl ;
        }
        int x ;
};
class son : public fu {
    public :
        son(){
            cout<<"b son"<<endl ;
        }
/*
  1、这里初始化必须用父类的带参数的构造函数，不然会直接调用父类的无惨构造函数；
  2、可以去掉下面:fu(x) ，然后执行看下结果
*/
        son( int x ):fu(x) {
            cout<<"b son num "<<this->x<<endl ;
        }
        ~son(){
            cout<<"e son"<<endl ;
        }
};

int main( int argc , char** argv ) {

    son s(3)  ;

    system("pause") ;
    return 0 ;
}

  ９、单继承函数重载：
      ①．子类的同名函数会覆盖父类的函数，即使参数类型不一样；（即使父类有很多同名的重载函数，只要子类有一个同名函数，就会全部覆盖父类的同名函数）
  １０、多继承简介：
      ①．多继承子类的构造函数会根据继承的先后顺序调用

#include<iostream>
using namespace std ;

class fu {
    public :
        fu(){
            cout<<"b fu"<<endl ;
        }
        fu( int x ) : x(x) {
            cout<<"b fu num "<< this->x <<endl ;
        }
        ~fu(){
            cout<<"e fu"<<endl ;
        }
        void show( void ){
            cout<<"fu"<<endl ;
        }
        int x ;
};
class  son  {
    public :
        son(){
            cout<<"b son"<<endl ;
        }
        son( int x ): y(x) {
            cout<<"b son num "<<this->y<<endl ;
        }
        ~son(){
            cout<<"e son"<<endl ;
        }
        int y ;
        void show( void ){
            cout<<"show"<<endl ;
        }
};
class chen : public fu , public son {
    public :
        chen(){
            cout<<"b chen"<<endl ;
        }
        chen( int x ) : son(x) , fu(x) {
            cout<<"b chen num "<<this->x<<endl ;
        }
        ~chen(){
            cout<<"e chen"<<endl ;
        }
        /*void show( void ){
            cout<<"chen"<<endl ;
        }*/
};

int main( int argc , char** argv ) {

    fu *c = new chen(2) ;
    c->show() ;

    delete c ;

    system("pause") ;
    return 0 ;
}

      ②．多继承所继承的类中如果有同名函数，必须指明调用是所继承的类中哪个类的函数：

    chen *c = new chen(2) ;
    c->fu::show() ;

三、虚基类

  １、定义：
      ①．对C++虚基类的描述曰“共享继承”，名曰“各派生类的对象共享基类的的一个拷贝”，其实说白了就是解决多重多级继承造成的二义性问题。例如有基类B，从B派生出C和D，然后类F又同时继承了C和D，现在类F的一个对象里面包含了两个基类B的对象，如果F访问自己的从基类B那里继承过来的的数据成员或者函数成员那么编译器就不知道你指的到底是从C那里继承过来的B对象呢还是从D那里继承过来的B对象。
      ②．于是虚基类诞生了，将C和D的继承方式改为虚继承，那么F访问自己从B那里继承过来的成员就不会有二义性问题了，也就是将F对象里的B对象统一为一个，只有一个基类B对象，下面是一段代码说明了对虚基类的使用。（注【己】：感觉要自己理解）

#include<iostream>
using namespace std ;

class A {
public :
    A(){
        cout<< " A creat " << endl ;
    };
    A( int a ) : x(a) {
        cout<< " A creat num -->" << this->x << endl ;
        };
    ~A(){
        cout<< " A delete " << endl ;
    }
    int x ;
    int y ;
};
class B : virtual public A{
    public :
        B(){
            cout<< " B creat " << endl ;
        };
        B( int a ) : A(a){
            cout<< " B creat num --> " << this->x << endl ;
        };
        ~B(){
            cout<< " B delete " << endl ;
        }
};
class C : virtual public A {
    public :
        C(){
            cout<< " C creat " << endl ;
        };
        C( int a ) : A(a){
                cout<< " C creat num --> " << this->x << endl ;
        };
        ~C(){
            cout<< " C delete " << endl ;
        }
};
class BC : public B , public C {
    public :
        BC(){
            cout<< " BC creat " << endl ;
        };
        BC( int a , int b ) : B(a) , C(b) 
        BC( int a , int b ) : A( a+b ) 
        BC( int a , int b ) : A( a+b ) , B(a) , C(b){
            cout<< " BC creat A num --> " << this->A::x  ;
            cout<< " BC creat B num --> " << this->B::x  ;
            cout<< " BC creat C num --> " << this->C::x << endl ;
        };
        ~BC(){
            cout<< " BC delete " << endl ;
        }
};

int main( int argc , char** argv ) {

    BC aaa(2,3)  ; /*去了virtual后看输出结果*/
    aaa.y = 4 ; /*如果不采用virtual，则编译不能通过*/

    system("pause") ;
    return 0 ;
}

四、静态联编 与 动态联编

  １、联编：
      ①．定义 ：联编就是将模块或者函数合并在一起生成可执行代码的处理过程，同时对每个模块或者函数调用分配内存地址，并且对外部访问也分配正确的内存地址，它是计算机程序彼此关联的过程。按照联编所进行的阶段不同，可分为两种不同的联编方法：静态联编和动态联编。
  ２、静态联编
      ①．定义：是指在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于指向对象的指针（或者引用）的类型，C语言中，所有的联编都是静态联编,据我所知道的，任何一种编译器都支持静态联编（废话）。函数重载也是一种。
  ３、动态联编
      ①．定义：是指在程序执行的时候才将函数实现和函数调用关联，因此也叫运行时绑定或者晚绑定，动态联编对函数的选择不是基于指针或者引用，而是基于对象类型，不同的对象类型将做出不同的编译结果。C++中一般情况下联编也是静态联编，但是一旦涉及到多态和虚拟函数就必须要使用动态联编了。If ,switch语句就是。

五、父类指针与子类指针

  １、父类指针引用父类对象，完全正常引用；
  ２、子类指针引用子类对象，覆盖父类的同名函数；
  ３、父类指针引用子类对象，只能引用父类中的函数；
  ４、子类指针，引用父类对象，子类不涉及内部数据的函数会调用成功（主要是没初始化）。（使用dynamic_cast

#include <iostream>
using namespace std ;

class fu {
    private :
        int age ;
    public :
        fu(){
            age = 10 ;
            cout<<"fu"<<endl ;
        }
        ~fu(){}
        void fufu(){
            cout<<"fufu"<<this->age<<endl ;
        }
        void printc(){
            cout<<"fu--print"<<endl ;
        }
} ;
class zi : public fu {
    private :
        char *strzi ;
    public :
        zi(){ 
            strzi = "son" ;
            cout<<"zi"<<endl ;
        }
        ~zi(){}
        void zizi(){
            cout<<"zizi" << this->strzi <<endl ;
        }
        void printc(){
            cout<<"zizi" << this->strzi <<endl ;
            cout<<"zi--print"<<endl ;
        }
} ;
void main()
{
    {
        //fu *pfu = new fu;
        //delete pfu;
    }
    {
       ///  zi  *pzi = new zi;
        // delete pzi;

}
    {
        //fu *pfu = new zi;
        //delete pfu;//内存泄漏
    }
    {
        //fu *pfu = new fu;
        zi *pzi = static_cast<zi *>(new fu);
        delete pzi;//内存越界,超过界限释放内存，有时出错，有时无措

    }

    std::cin.get();

}



void main3()
{
    zi *pzi(nullptr);
    pzi->zizi();

    std::cin.get();


}
void main4()
{
    fu *pfu = new fu;
    zi *pzi = static_cast<zi *>(pfu);
    pzi->fufu();

    pzi->zizi();
    pzi->fu::print();

    //pzi->print();

    //std::cout << pzi->strzi << std::endl;




    //pzi->print();




    std::cin.get();



}
void main2()
{
    fu *pfu = new zi;
    pfu->print();
    pfu->fufu();


    std::cin.get();


}

void main1()
{
    fu *pfu = new fu;
    pfu->print();
    pfu->fufu();

    zi *pzi = new zi;
    pzi->print();//子类覆盖父类
    pzi->zizi();
    pzi->fufu();

    /*
    fu fu1;
    fu1.print();
    fu1.fufu();
    */




    std::cin.get();
}

六、父类与子类指针释放

  １、父类指针引用子类对象–>内存泄漏
  ２、子类指针引用父类对象–>内存越界

{
        //fu *pfu = new zi;
        //delete pfu;//内存泄漏
    }
    {
        //fu *pfu = new fu;
        zi *pzi = static_cast<zi *>(new fu);
        delete pzi;//内存越界,超过界限释放内存，有时出错，有时无措

    }

  ３、解决：智能指针、虚析构函数（内存泄露）

七、虚函数（虚基类）——多态

  １、虚函数的作用：
      ①．是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。——-（己：这才是继承所要实现的真正目的，没有虚函数的基类指针（不经过类型转换）访问基类的同名函数，不能访问派生类中的同名函数，这个才和Java学习的继承一样）。

#include<iostream>

//没有virtual,会一直调用基类的方法
//virtual的

//虚函数现代编译器会直接分配一个指针存储虚函数表的位置，

class fu{
public:
    /*这里的virtual可以去掉后看输出结果*/
    virtual void name()     {
        std::cout << "父类";
        std::cout << "x=" << x << "\n"; }
    int x;
    fu(int a) :x(a) {

    }
} ;

class zi :public fu{
public:
    void name()
    {
        std::cout << "子类";
        std::cout << "x=" << x << ",y="<<y<<"\n";
    }
    int y;
    zi(int a, int b) :fu(a), y(b)   {

    }
};
class sun :public zi{
public:
    void name()
    {
        std::cout << "孙类";
        std::cout << "x=" << x << ",y=" << y <<",z="<<z<< "\n";
    }
    int z;
    sun(int a, int b, int c) :zi(a, b), z(c)    {

    }

void main(){

    std::cout << sizeof(fu) << std::endl;
    fu fu1(1);
    zi zi1(2,3);
    sun sun1(4,5,6);
    fu *pfu;
    pfu = &fu1;
    pfu->name();//1

    pfu = &zi1;
    pfu->name();//2

    pfu = &sun1;
    pfu->name();//4

    //((zi*)pfu)->name();
    //((sun*)pfu)->name();

    std::cin.get();
}

void main1()
{

    /*
    fu *pfu = new fu;
    pfu->name();
    zi *pzi = new zi;
    pzi->name();
    sun *psun = new sun;
    psun->name();

    zi *pzifu = static_cast<zi *>(pfu);
    pzifu->name();

    sun *psunfu = static_cast<sun *>(pfu);
    psunfu->name();


    std::cin.get();
    */
}

      ②．重载基类中的虚函数必须函数名，参数，返回值都一样，即绝对匹配。
  ２、纯虚函数
      ①．在基类中没有定义，必须在子类中实现，跟Java中的接口一样；
      ②．带了纯虚函数的类是抽象类，不能实例化；
      ③．纯虚函数的说明：
      第一种：

Virtual void show () = 0
{ cout << “good” << endl ;}

      第二种：

Virtual void show () = 0 ；

      其实，实不实现都是没问题的，派生类都必须重写。
  ３、构造函数不能是虚函数
      ①．原因：不会再构造，没有办法创建子类中的父类对象
  ４、虚析构函数—-解决内存泄漏
      ①．虚析构函数，让父类指针正确的释放子类对象的内存；
      ②．解决上面内存泄漏的情况，在基类指针引用派生类对象释放内存时，会自动调用基类的析构函数。虚析构函数就是这个作用。
  ５、抽象类不可以用于函数的参数以及返回值类型，抽象类指针是可以；

class base
{
public:
    //纯虚函数，有无定义都可以
    //有一个纯虚函数，都是抽象类，无法实例化
    virtual void  run()=0 //限定一个类不能实例化，专门的接口
    {
        std::cout << "base run\n";
    }

    virtual ~base()    {

    }
};
//抽象类不可以用于函数的参数以及返回值类型
//抽象类指针是可以
base * test( base *p)
{
    base *pbase(nullptr);
    return pbase;
}

  ６、抽象类叠加
      ①．抽象类中还有抽象类，软件迭代式开发拓展接口；

八、异质链表

  １、定义：
      ①．程序中，用基类类型指针可以生成一个连接不同派生类对象的动态链表，即每个节点指针可以指向类层次中不同的派生类对象。这个节点类型不同的链表称为异质链表。

九、类模板

  １、说明及构成：
  ２、例子：

#include<iostream>

using namespace std ;

template<class T>
class comx{
    public :
        T a,b ;
        T add(){
            return a+b ;
        }
};

int main(){
    comx<int> com1 ;
    com1.a = 5 ;
    com1.b = 6 ;
    cout<< com1.add() << endl ;

    cin.get() ;
    return 0 ;
}

  ３、两种数据类的函数模板：

#include<iostream>
using namespace std ;
#include<string>
/*定义两种数据类的的函数模板*/
template<class T1 , class T2>
class my{
    public :
        T1 t1 ;
        T2 t2 ;
        my( T1 a , T2 b ):t1(a),t2(b){

        }
        void show(){
            cout<<t1<<"::"<<t2<<endl ;
        }   
};

int main( int argc , char **argv ){

    my<int , string> m( 1 ,"55dd" ) ;
    m.show() ;

    system("pause") ;
    return 0 ;
}

  ４、C++的数组array也是类模板

/*main.cpp*/
#include <iostream>
#include <string>
#include "Array.h"
#include"Array.cpp"/*必须两个都包含，在没明确类型之前，编译器也不知道用哪个函数*/

using namespace std;

void main11()
{
    /*
    string str = "calc";
    Array<string> myarray(5);//构造五个元素数组
    for (int i = 0; i < myarray.size();i++)
    {

        str += "X";
        myarray.set(str, i);
        std::cout << myarray.get(i) << std::endl;
    }
    */

    std::cin.get();
}

void main22()
{
    Array<int,5 > myarray;
    for (int i = 0; i < myarray.size(); i++)
    {
        myarray.set(i, i);

        std::cout << myarray[i] << std::endl;

    }

    std::cin.get();

}
template<class T, int n>//类模板作为参数，类型无比明确
void print(Array<T,n> &myarray)
{
    for (int i = 0; i < myarray.size();i++)
    {
        std::cout << myarray[i] << std::endl;
    }

}
void main()
{
    Array<int, 5 > myarray;
    for (int i = 0; i < myarray.size(); i++)
    {
        myarray.set(i, i);
    }
    print(myarray);

    std::cin.get();
}
/***Array.h***/
#pragma once


template<class T,int n>
class Array
{
public:
    Array();
    Array(int length);
    ~Array();
    int size();
    T get(int num);
    T& operator [](int num);//重载【】
    void set(T data, int  num);
public:
    T *pt;
    //int n;//长度

};
/****Array.cpp***/
#include "Array.h"

template<class T, int n>//int n不可以修改，不是类的内部成员
Array<T,n>::Array()
{
    //this->pt = nullptr;//空指针
    //this->n = 0;
    this->pt = new T[n];
}
template<class T, int n>//每一个函数都必须模板
Array<T,n>::Array(int length)
{
    this->pt = new T[length];
    //n = length;
}

template<class T, int n>//每一个函数都必须模板
Array<T,n>::~Array()
{
    //n = 0;
    delete[] this->pt;
}

template<class T, int n>//每一个函数都必须模板
int  Array<T,n>::size()
{
    return n;
}
template<class T, int n>//每一个函数都必须模板
T Array<T,n>::get(int num)//num是数组的下标
{
    if (num >= n ||num <0)//报错
    {
        //异常
    }
    else
    {
        return *(this->pt + num);
    }
}
template<class T, int n>//每一个函数都必须模板
void Array<T,n>::set(T data, int  num)
{
    if (num<0 || num>=n)
    {
    } 
    else
    {
        *(pt + num) = data;
    }
}
template<class T, int n>//每一个函数都必须模板
T& Array<T,n>::operator [](int num)
{
    if (num < 0 || num>=n)
    {

    }
    else
    {
        return  *(pt + num);
    }
}

  ５、类模板做函数参数
      ①．当一个函数拥有类模板参数时，这个函数必定为函数模板；

template<class T, int n>//类模板作为参数，类型特别明确
void print(Array<T,n> &myarray)
{
    for (int i = 0; i < myarray.size();i++)
    {
        std::cout << myarray[i] << std::endl;
    }

}

  ６、类模板做类模板参数

#include<iostream>
#include<string>
using namespace  std;

//类模板当作一个类的参数
//设计STL时候用到
//面试，类模板当作参数

template<class T>
class ren      //一个通用的类的类模板
{

public:
    T name;
    ren(T t) :name(t)
    {

    }
};

template< template<class T> class T1 >  //使用类模板当作模板参数的类
class people
{
public:
    T1<string> t1x="123123";//T1必须实例化 。必须结合
    T1<string>  num = "ABC"; //等价于ren类型
    //T1 x;
    people(T1<string> t1) 
    {
        std::cout << typeid(t1).name() << std::endl;
        std::cout << typeid(T1).name() << std::endl;
        std::cout << t1.name << std::endl;
        /*t1x = t1;
        num = t1;*/

    }
};

void main()
{
    ren<string> ren1("hello8848"); //基本数据类型

    people<ren> people1(ren1);//嵌套的类模板

    //std::cout << people1.t1x.name << std::endl;
    //std::cout << people1.num.name << std::endl;
    //std::cout << people1.str << std::endl;

    std::cout << people1.t1x.name << std::endl;
    std::cout << people1.num.name << std::endl;
    std::cout << ren1.name << std::endl;
    std::cin.get();
}

  ７、C++11 final 与 override 

#include<iostream>
//C++11  final  override针对虚函数
//final拒绝重载,某些情况下，接口拒绝被重写
//加了final关键字的虚函数，无法被重写，预留接口
//override，警示符，声明我重写父类的方法，父类没有接口，会提示出错

class ye
{
public: 
    //final”函数必须是虚函数
    virtual void print() final  //虚函数无法重写
    {
        std::cout << "爷爷\n";
    }
    virtual void run()
    {
        std::cout << "爷爷run\n";
    }

};
class  ba:public ye
{
public:
    //警示作用，强调我覆盖了父类的方法,必须是虚函数
    void runa () override 
    {
        std::cout << "爸爸run\n";
    }
};

void main1()
{
    ba ba1;
    ba1.run();

    std::cin.get();
}

  ８、类模板的继承与多态
      ①．模板类：是类模板的实例；类模板：是模板，不能直接生成类对象。
      ②．类模板可以从模板类派生 ；
      ③．类模板可以从非类模板派生 ；
      ④．模板类可以从类模板派生 ；
      ⑤．非模板类可以从类模板派生 ；

#include <iostream>
#include <string>
//模板类之间继承
//类模板可以直接继承类模板，类型必须传递
//普通类继承类模板，需要明确类型实例化类模板
//类模板继承普通类，常规的操作方式
//类模板当作普通哦类，需要模板参数对类进行实例化

template<class T>  //抽象模板类
class myclass
{
public:
    T  x;
    myclass(T t) :x(t)
    {
    }
    virtual  void print() = 0;
};
template<class T>
class newclass :public myclass<T>  //继承必须明确类型
{
public:
    T y;
    newclass(T t1, T t2) :myclass(t1), y(t2)
    {
    }
    void print()
    {
        std::cout << x <<"     " <<y<< std::endl;
    }
};

void main()
{
    myclass<int >  *p=new newclass<int>(10,9);
    p->print();


    std::cin.get();


}
void mainyz()
{
    myclass<int> *p = new newclass<int>(10,9);
    p->print();
    std::cin.get();
}
void main1()
{
    //newclass<double> my1(10.9, 2.3);
    //my1.print();

    newclass<std::string> my1("abc", "xyz");
    my1.print();

    std::cin.get();

}
/*-----------------------------------------------------------------------------------------------------------------*/
class xyz
{
public:
    int x;
    int y;
    int z;
    xyz(int a, int b, int c) :x(a), y(b), z(c)
    {
        }
    void  print()
    {
        std::cout << x << y << z;
    }
};

template<class T>
class  newxyz :public xyz
{
public:
    T a;
    newxyz(T t1,int a1,int b1,int c1) :xyz(a1,b1,c1),a(t1)
    {

    }
    void print()
    {
        std::cout << "Ta=" << a << std::endl;
        std::cout << x << y << z << std::endl;
    }
};

class classrun:public newxyz<int >//普通类继承模板类需要实例化
{
public:
    int d = 1000;
    classrun(int a2, int b2, int c2, int d2) :newxyz<int>(a2,b2,c2,d2)
    {

    }
    void print()
    {
        std::cout << d << x << y << z << a;
    }

};

void mainy()
{

    classrun  run1(1, 2, 3, 4);
    run1.print();

    std::cin.get();

}
void mainx()
{
    std::string  str1 = "china";
    newxyz<std::string> new1(str1,10,90,89);
    new1.print();

    std::cin.get();
}

  ９、类模板友元函数
      ①．类模板重载：
      ②．类模板友元函数
          条件1：友元函数如果在外部，第一声明要加类型T如：printA
          条件2：必须要声明类还有函数

#include <iostream>
#include <string>
#include <vector>

template<class T> class myclass;
template<class T> void print(myclass<T> & my, T t1);

template<class T> 
class myclass
{

public:
    //friend  void print(myclass<T> & my, T t1);
    //友元函数放在模板类的内部，实现重载

    friend void print<T>(myclass<T> & my, T t1);/*就是这个红色的T忘记加了，搞了半天*/
    friend  myclass  *  operator+(const myclass<T> & my1,
        const myclass<T> &my2)  {
        //myclass class1  栈，用完了马上释放

        //堆上申请一个
        myclass<T> * p = new myclass<T>(my1.x + my2.x, my1.y + my2.y);
        return p;
    }

    myclass(T t1, T t2) :x(t1), y(t2)   {

    }
    //访问私有需要友元，
    private:
        T  x;
        T  y;
};
template<class T>
void print(myclass<T> & my, T t1)
{
    std::cout << typeid(t1).name() << std::endl;
    std::cout << my.x << "   " << my.y << std::endl;
}
void main()
{
    myclass<int> my1(19, 29);
    myclass<int> my2(11, 1);


    print(my1, 10);
    //printA(my1);
    myclass<int> *pclass = my1 + my2;
    print(*pclass,10);

    std::cin.get();
}

  １０、友元类类模板

#include<iostream>

template <class T> class myclass;
template<class T> class runclass;
//友元类必须声明类的存在，
//需要声明友元类，必须要与类型相关

template <class T>
class myclass
{
public:
    myclass(T t) :x(t)
    {

    }
    friend class runclass<T>;//声明友元类
private:
    T x;  //模板友元类
    //int y;访问与T无关的类型，普通友元类
};

template<class T>
class runclass
{
public:
    void print(const myclass<T> & my)
    {
        std::cout << my.x << std::endl;
    }
};

void main()
{
    myclass<double> my1(19.8);
    runclass<double> run1;
    run1.print(my1);
    std::cin.get();
}

  １１、Static 与 类模板

#include <iostream>
#include<string>

//类模板的static成员，对象，类名《类型》
//不同类型的静态成员变量，地址不一样
//相同类型的静态成员变量，地址一样
template<class T>
class myclass
{

    static int data;
public:
    static int num;//声明
    T a;
    myclass(T t) :a(t)
    {
        num++;
        data++;
    }
    static void run()
    {
        //this->a;
        std::cout << data << std::endl;
        std::cout << typeid(T).name() << "\n";
    }


};

template<class T>
int  myclass<T>::num = 0;
template<class T>
int  myclass<T>::data = 0;

//静态变量，静态函数，同类，共享的
//类型不同，不是共享
void main()
{
    myclass<int > my1(10);
    myclass<double > my2(10.9);
    myclass<int > my4(10);
    myclass<int>::run();
    myclass<int>::run();
    myclass<int>::run();
    my1.run();
    myclass<double>::run();
    //myclass<int>::data;



    std::cin.get();
}

void mainA()
{

    myclass<int > my1(10);
    myclass<double > my2(10.9);
    myclass<std::string > my3("1234");
    myclass<int > my4(10);
    std::cout << &my1.num << std::endl;
    std::cout << &my2.num << std::endl;
    std::cout << &my3.num << std::endl;
    std::cout <<&my4.num << std::endl;
    std::cout << &myclass<int >::num << std::endl;
    std::cout << &myclass<float >::num << std::endl;
    std::cin.get();

}

  １２、类嵌套以及类模板嵌套
      ①．类嵌套

#include <iostream>


class myclass
{
public:
    class newclass
    {
    public:
        int num;
    }new1;//类的嵌套
};
class newnewclass :public myclass
{
};

void main()
{
    newnewclass newx;
    newx.myclass::new1.num=10;

    std::cout << newx.new1.num;
    std::cin.get();
}

void main1()
{
    myclass myclass1;
    myclass1.new1.num = 19;
    std::cout << myclass1.new1.num;
    std::cin.get();
}

      ②．模板类嵌套

#include<iostream>

template<class T>
class myclass
{
public:
    class newclass
    {
    public:
        int num;
    }new1;//定义的方式
    newclass new2;

    template<class V>
    class  runclass
    {
    public:
        V v1;
    };//类模板后面不可以直接初始化
    runclass<T> t1;
    runclass<double> t2;
};

void main()
{
    myclass<int > my1;
    my1.new1.num = 10;
    my1.t1.v1 = 12;
    my1.t2.v1 = 12.9;
    std::cout << my1.t1.v1 << "\n" << my1.t2.v1;

    std::cin.get();
}

十、位运算算法

    １、加法：

void add( int a , int b ){
    if( 0==b ){
        cout << a << ":::" << b << endl ;
    }else{
        int res = a^b ; 
        int wei = (a&b)<<1 ; 
        cout<<"1"<<endl ;
        add( res , wei ) ;
    }
}

    ２、计位数（计算1的位数）：
        ①．第一种：

while (num)
    {
        i++;
        num &= num - 1;//让数据趋向于0
    }

    std::cout << i << std::endl;

        ②．第二种：

int get1(int num)
{
    int count = 0;//表示位数
    unsigned int  flag = 1;
    while (flag)
    {
        if (num & flag) //不为0就自增
        {
            count++;
        }
        flag = flag << 1;
    }
    return count ;
}

十一、Rtti（实时类型检测）

  １、成员变量覆盖：

#include <iostream>
//rtti,实时类类型检测，
//typeid().name()
//dynamic_cast必须依赖于虚函数表
//类型不匹配转换失败，返回为空。类型安全


//成员变量的覆盖
//虚函数有虚函数表确定数据类型

class A
{
public:
    int num;
    static int data;
   virtual  void run()
    {
        std::cout << "Arun\n" ;
    }
};
int A::data=1 ;
class B:public A
{
 public:
     int num=0;
     static int data;
     void run()
     {
         std::cout << "Brun\n";
     }
     void test()
     {
         std::cout << num<<"\n";
         std::cout << "Btest\n";
     }
};
int B::data = 2;

void main4()
{

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

void main3()
{

    A a1;
    B b1;
    A *p1 = &a1;
    A *p2 = &b1;
    B *p3(nullptr);
    //p3 = dynamic_cast<B*>(p2);
    //dynamic必须要有虚函数，根据虚函数表转换，不能转换
    //转换失败为空
    //类的空指针可以调用不调用数据的函数
    //转换成功就是地址
    std::cout << p3 << "\n";
    p3->test();

    std::cin.get();
}
void main2()
{

    //A *p1 = new A;
    //A *p2 = new B;
    A a1;
    B b1;
    A *p1 = &a1;
    A *p2 = &b1;
    std::cout << typeid(p1).name() <<"  "<< typeid(p2).name() << std::endl;
    std::cout <<( typeid(p1) == typeid(p2))<<"\n";

    std::cout << typeid(*p1).name() << "  " << typeid(*p2).name() << std::endl;
    std::cout << (typeid(*p1) == typeid(*p2)) << "\n";//重载的方式判定类型是否一致

    std::cin.get();

}

void main1()
{
    B b1;
    b1.num = 10;//覆盖现象
    b1.A::num = 20;
    std::cout << b1.num << "\n" << b1.A::num
        << std::endl;
    std::cout << b1.data <<"   "<< b1.A::data << "\n";
    std::cout << &b1.data << "   " << &b1.A::data << "\n";

    std::cin.get();

}

十二、高级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();

十三、类包装器与函数包装器

#include<iostream>
template<typename T,typename F>
T run(T t, F f) //包装器，实现一个操作接口，操作多个类的方法
{
     return  f(t);
}

int add(int num)
{
    return num + 10;
}

class myclass
{
public:
    int  num;
    myclass(int data) :num(data)
    {

    }
    int operator ()(int X)
    {
        return X*num;
    }

};
class myclassA
{
public:
    int  num;
    myclassA(int data) :num(data)
    {

    }
    int operator ()(int X)
    {
        std::cout << "A\n";
        return X-num;
    }

};

void main()
{

    myclass my1(5);
    std::cout << run(101,my1) << std::endl;
    std::cout << run(101, myclassA(51)) << std::endl;
    std::cin.get();

}
void main1()
{
    auto  num = 100;
    auto  func = add;
    std::cout << run(num, add) << std::endl;


    std::cin.get();
}

十四、类成员函数指针

  １、P与*p等价

#include<stdio.h>

int addC(int a, int b)
{
    return a + b;
}

void  run()
{
    printf("\nrun");
}
void main1()
{

    int(*p)(int, int) = addC;
    void(*p1)() = 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);
    //printf("%d\n", (&p)(1, 2));
    //取地址，取就是CPU即将调用函数执行，C语言内嵌ASM
    //老版本，*p,p,&p

    getchar();
}

  ２、Cpp的函数指针

#include <stdio.h>
#include<iostream>

void add(int a, int b)
{
    std::cout << a + b << std::endl;
}

void mainA()
{
    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();

}

  ３、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;
    }
};
void main1x()
{
    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();
}
typedef int(com::*P)(int, int);
void main()
{
    com com1(100, 20);
    //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();
}
a2604539133
关注
专栏目录
详解C++中基类与派生类的转换以及虚基类
01-20
在公用继承、私有继承和保护继承中，只有公用继承能较好地保留基类的特征，它保留了除构造函数和析构函数以外的基类所有成员，基类的公用或保护成员的访问权限在派生类中全部都按原样保留下来了，在派生类外可以调用...
C++虚函数、虚继承、虚基类、多态、智能指针
Hello Word!
07-26 539
1，什么是虚函数 2，虚继承在什么情况下使用 子类继承来自于同一个公共祖先的多个父类的时候？
c++中的虚函数、虚基类、类模板
zyazky
08-15 5244
一、虚函数 首先要明白C++为什么要引进虚函数这个机制， 虚函数就是在基类中被关键字virtual说明，并在派生类中重新定义的函数。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。 从以上的定义来看，需函数简单的说就是为了让基类指针能够指向派生类中与基类同名的函数而引进的，举个简单的例子，1：你定义了一个“图形类”这样的基类，然
C++11、17、20的内存管理-指针、智能指针和内存池从基础到实战（中）
最新发布
zhaopeng01zp的博客
11-22 867
C++内存管理-指针、智能指针和内存池从基础到实战
虚基类 和多态性c++
Duihanhan的博客
10-14 710
面向对象程序设计重要概念之一就是多态性 同一个名字定义若干个功能相近的函数 同样的消息被不同对象接受 导致不同的行为 又称为 同一接口 多种方法 即使操作功能有区别 仍可以用同样的接口访问 多态性分为两类 编译时多态行 和运行时多态性 操作符重载 函数重载 就是编译时多态 通过派生类和虚函数实现的多态 是运行时多态 核心虚函数 纯虚函数 抽象类的概念 虚函数 概念 编译时的多态是通过静态联编 实现的 运行时的多态性则是通过动态联编实现的 动态联编核心是虚函数 虚函数是一种在基类中定义为 virt
C++静态联编、动态联编
dongguojun的专栏
02-16 223
静态联编是在编译阶段进行绑定，例如重载函数(同一类体内的同名重载函数)，运算符重载，都属于静态联编；动态联编是在运行阶段绑定的，在派生类继承基类的访问方式不受影响下，在继承层级关系中的同名函数，在基类中定义为虚函数时，可实现动态联编。 虚函数为非静态成员函数。 如果同名函数是虚函数，基类指针指向派生类对象时，调用的是派生类的同名函数，否则基类指针访问基类同名函数，派生类...
C++基类指针和派生类指针之间的转换方法讲解
12-31
函数隐藏是指派生类中函数与基类中的函数同名，但是这个函数在基类中并没有被定义为虚函数，这种情况就是函数的隐藏。 所谓隐藏是指使用常规的调用方法，派生类对象访问这个函数时，会优先访问派生类中的这个函数，...
详谈C++中虚基类在派生类中的内存布局
01-20
今天重温C++的知识，当看到虚基类这点的时候，那时候也没有太过追究，就是知道虚基类是消除了类继承之间的二义性问题而已，可是很是好奇，它是怎么消除的，内存布局是怎么分配的呢？于是就深入研究了一下，具体的...
类继承与虚函数.ppt
02-15
4类类型之间的强制转换;5嵌套类 1.封装: 把对象的属性和方法结合成一个独立的系统单位，并尽可能隐藏对象的内部细节。 2.继承: 子类对象拥有与其基类相同的全部属性和方法。 例如人都共有的一些属性：鼻子、眼睛...
C++的静态联编和动态联编
09-02
4. 虚函数表（vtbl）是C++实现动态联编的一种技术，它存储了类中虚函数的地址，调用虚函数时会通过vtbl找到对应的函数地址。 理解静态联编和动态联编以及它们在C++中的实现机制，对于编写高效、灵活的面向对象程序...
静态联编和动态联编
小憩一下
03-21 750
联编是指一个计算机程序自身彼此关联的过程,在这个联编过程中,需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系;按照联编所进行的阶段不同,可分为静态联编和动态联编; 静态联编: 是指联编工作是在程序编译连接阶段进行的,这种联编又称为早期联编;因为这种联编是在程序开始运行之前完成的; 在程序编译阶段进行的这种联编又称静态束定;在编译时就解决了程序中的操作调用与执行该
c++中的虚特性（虚基类、虚函数、纯虚函数）
zack_liu的博客
06-25 3623
1. 虚基类 1.1 虚基类作用 为了解决多继承时的命名冲突和冗余数据问题，使得派生类中只保留一份间接基类的成员。 其本质是是让某个类做出声明，承诺愿意共享它的基类。其中，这个被共享的基类就称为虚基类（Virtual Base Class） 换个角度讲，虚派生只影响从指定了虚基类的派生类中进一步派生出来的类，它不会影响派生类本身。 建立对象时所指定的类称为最远派生类。 虚基类的成员是由最远派生类的构造函数通过调用虚基类的构造函数进行初始化的。 在整个继承结构中，直接或间接继承虚基类的所有派生
C++虚函数与动态联编
weixin_40775703的博客
03-17 973
C++虚函数与多态1.动态联编与静态联编 1.动态联编与静态联编 联编就是将模块或者函数合并在一起生成可执行代码的处理过程，同时对每个模块或者函数调用分配内存地址，并且对外部访问也分配正确的内存地址，它是计算机程序彼此关联的过程。 静态联编是指在编译阶段就将函数实现和函数调用关联起来，因此静态联编也叫早绑定，在编译阶段就必须了解所有的函数或模块执行所需要检测的信息，它对函数的选择是基于==指向对...
C++之virtual（虚）关键字：虚基类（虚继承）；虚函数和纯虚函数
qq_43148810的博客
10-29 3610
@著作权归作者所有：来自CSDN博客作者大胡子的艾娃的原创作品，如需转载，请注明出处https://blog.csdn.net/qq_43148810，否则将追究法律责任。 如有错误的地方欢迎指正，谢谢! 一、虚基类 1、为什么要虚基类或者说虚继承： a、直接二义性可以用作用域与同名覆盖的方法来消除（看程序注释），但是间接二义性(同名数据成员在内存中同时拥有多个拷贝，同一个成员函数会有多个映射,多...
C++(13)——虚基类和C++四种类型转换
青布衫白少年的博客
08-13 424
继承方式 1、单继承（一个派生类只有一个直接基类） 2、多继承（派生类有两个或以上的直接基类） 3、菱形继承 虚基类 virtual修饰成员方法时叫虚函数，virtual修饰修饰继承方式时叫虚继承。 class A { public: private: int ma; }; class B:virtual public A**加粗样式** { public: private: int mb; }; 有虚基类的内存存储： 当有虚继承的时候，基类的数据放到代码的最后面，在派生类数据前面加一个指向虚基类表
C++ 类继承与虚函数详解：类型转换与友元
"类型转换函数-类继承与虚函数" 在C++编程中，类型转换函数是一种特殊的方法，它允许我们自定义对象向其他基础类型的转换。通过定义`operator int()`这样的函数，我们可以使得一个自定义类的对象能够被当作整型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值