[C++知识库]关于C++中的一些特殊函数inline，virtual等等

预处理 编译 汇编 链接
预处理: 宏替换，删掉注释，头文件的添加到一个文件中等等
编译: 将预处理后的 .i 文件进行一系列语法分析，词义分析，语义分析等等生策划那个.s 文件

inline内联函数

1. 作用：内联函数是为了解决c语言中表达式形式的宏定义来解决程序中函数调用的效率问题，
2. 产生的原因：c语言中表达式形式用宏来定义，但是宏是在预处理阶段被处理的，就只是简单的替代，并没有替换类型的检查，等等一系列操作，调用宏并不会产生额外的空间和时间的操作，效率会更高一点，但是宏 不能访问类的私有成员 宏也非常容易产生二义性 宏在预处理阶段不会进行参数的检查 。所以C++就使用了inline函数来解决这个事情，让编译器处理这个inline函数，编译器可以对语法语义等进行分析
3. 内联函数与普通函数的区别
   普通函数: 如果main函数调用一个a函数，系统会先跳到a函数入口地址 -> 执行函数体 再返回到原函数调用的地方继续执行
   内联函数: 如果函数调用一个内联函数， 函数不需要进行寻址的过程，会直接将函数copy过来，执行函数体
   所以内敛函数的使用不需要寻址，进而提高了函数的效率
   但是这个拷贝阶段是在什么时候进行的呢，在编译阶段直接进行拷贝(内联)
4. 内联函数与宏的区别，除了处理阶段不同外，内联函数实际上是一个函数，有返回值，参数列表，函数体，而宏只是一般的表达式
5. 内联函数可以是虚函数么？虚函数可以是内联函数，内联可以修饰虚函数，当虚函数表现多态性的时候不能内联
   内联函数是在编译器阶段进行函数内联，但是虚函数的多态性是在运行期间，编译器并不能直到运行期间运行哪个代码，因此虚函数表现是多态的时候不可以内联
6. C++中，类中的函数体默认是inline函数(隐式定义内敛函数)
7. 一般小于十行的时候使用内联函数

虚函数

virtual 虚函数

1. 为了实现C++的多态，C++使用了一种动态绑定的技术，这个技术的核心就是虚函数表(虚表)
   每个虚函数的类都有自己的虚拟表vptr（一个包含虚函数的基类有自己的虚表，继承了这个基类的派生类也拥有自己的虚表，因为派生类也需要实现这些虚函数），是在编译阶段编译器设置的静态指针数组（只有虚函数才拥有虚表，抽象类中的一般函数不拥有虚表），需要注意的是，同一个类的所有对象只需要一个虚表，继承了拥有虚函数的类的类也拥有自己的虚表

2. 虚函数的参数默认值
   基类默认覆盖子类的默认值。参数并不是动态绑定的，而是根据调用者的类型决定的，虚函数调用的是子类的方法，方式参数默认的是基类的

class Base{
    public:
    virtual void fun(int x=10)
    {
        cout<<"Base::fun(),x="<<x<<endl;
    }
};

class Derived: public Base{
    public:
    virtual void fun(int x=20)
    {
        cout<<"Derived::fun(),x="<<x<<endl;
    }
};

int main()
{
    Derived d1;  
    //d1.fun();
    Base *bp=&d1;
    bp->fun();   //Derived::fun(),x=10
    return 0;

}

bp是基类Base* 类型，参数调用的是Base的参数，静态绑定，但是因为指向的是d1 也就是Derived派生类，由于动态绑定的原因，会直接调用Derived::fun()
虚函数还是不要写默认参数比较好
3. 构造函数不可以是虚函数，构造函数的目的是用于初始化实例的，创建一个对象是需要明确对象的类型的，如果构造函数时虚函数，虚函数是在运行时确定对象的类型的，在编译阶段，编译器如果不知道对象的类型对象是无法被创建成功的。
4. 基类的虚函数可以是私有的，但要把main函数设置成是友元函数
当基类的虚函数是公有的，继承类实现的虚函数是私有的也是可以的

class Base{
    private:
    virtual void fun()   //虚拟类
    {
        cout<<"Base Fun"<<endl;
    }
    friend int main();   //友元函数
}; 

class Derived: public Base{
    public:
    void fun()    //虚拟类的实现   但是虚拟类是私有的
    {
        cout<<"Derived Fun"<<endl;
    }
};

int main()    
{
    Base *ptr=new Derived;
    ptr->fun();
    return 0;
}

virtual 纯虚函数和抽象类

虚函数: virtual
纯虚函数：声明赋值为0
抽象类：包含纯虚函数的类
1.抽象是没有实现的类， 所以抽象类不能直接创建对象(Base bp是错的)，只能作为基类来产生派生类, 这个派生类必须要实现所有纯虚函数才能成为非抽象类(但是派生类可以不用实现所有的虚函数，纯虚函数一定要是实现)

1.定义抽象类
2.定义派生类：抽象类{实现抽象类中的纯虚函数}
3.定义派生类的对象

2.抽象类定义的指针和引用指向由抽象类派生出来的类的对象

Base *bp = new Derived();   //抽象类Base的指针变量bp指向他派生出来的类Derived
bp->show();

3. 如果派生类没有实现抽象类中的纯虚函数，那么派生类也也会变成抽象类
4. 抽象类可以有构造函数，构造函数不能是虚函数，但是析构函数可以是虚函数
   当基类指针指向派生类对象并删除对象时，我们可能希望调用适当的析构函数。 如果析构函数不是虚拟的，则只能调用基类析构函数，这会导致派生类的对象析构不完全
   使用delete调用析构函数

class Base {
    public:
    Base()   //构造函数
    {
        cout<<"constructor: Base"<<endl;}
        virtual ~Base()    //虚析构函数
        {
            cout<<"Destructor: Base"<<endl;
        }
        virtual void func()=0;   //纯虚函数
    
};

class Derived: public Base{
    public: 
    Derived()
    {
        cout<<"Constructor:Derived"<<endl;
    }
    ~Derived(){   
        cout<<"Destructor:Derived"<<endl;
    }

    void func()   //实现纯虚函数
    {
        cout<<"In Derived.func()"<<endl;
    }
};

int main()
{
    Base *var=new Derived();
    delete var;
    return 0;
}

3. 构造函数时初始化的，不能被对象调用

c++ 中的struct

1. 可以在struct中定义数据，函数，使用访问修饰符（public, protected, private），还有继承
2. 使用结构体的时候可以不带struct
3. 如果结构体的名字与函数名相同，可以正常调用与运行，但在定义结构体的变量时候只能用带struct的
   但如果一个名字A被用于一个结构体的别名，是不能定义名字为A的函数的
4. struct与class
   class可以看成一个对象的实现体，struct是一个数据结构的实现体
   class默认是private的，struct默认是public的

explicit （显式）

作用:
修饰构造函数，可以防止隐式转换和复制初始化
修饰转换函数，可以防止隐式转换，但是按语境转换除外

friend 友元函数与友元类

友元 提供了一种 普通函数（友元函数）与类的成员函数（友元类）
作用: 可以访问一个类中的私有private或者protect
注意: 友元关系没有继承性，没有传递性

enum枚举

template 模板

模板: 是具有相同特性的函数或者类的再抽象，模板是一种参数多态性的工具，模板并不是一个实实在在的函数或者类，仅仅是一个函数或者类的描述，是参数化的函数和类，分为函数模板和类模板

1.class表示T是一个类型参数，可以表示任意类型，例如int，double，struct， enum, class之类的数据类型，class也可以使用typename替代
2.但某些场合下，模板是不适用于特定的场合的，所以需要将模板特化
template<> 是模板特化的关键字 <>中不需要任何关键字

template <class/typename T1, class/typename T2,...> 返回类型 函数表 （参数表）
{
函数模板定定义体
}

//example
template<class T>
T Max(T a, T b)
{
    return (a>b)?a:b;
}

//模板特化    将T使用特定的类型代替
template<> char * Max <char *>(char *a, char *b)
{
    return (strcmp(a,b)>=0)?a:b;
}

3. 在同一个程序中，还有同名的普通函数，普通函数可以进行隐式的类型转换，模板以及特化函数不能够进行任何形式的类型转换
4. 调用顺序：完全匹配的给模板函数 完全匹配的模板函数 类型相容的非模板函数

const int Size=5;

template<class T>
void Array<T>::Sort()
{
    int p;
    for(int i=0;i<Size-1;i++)
    {
        p=i;
        for(int j=i;j<Size;j++)
        {
            if (a[p]<a[j])
            p=j;
        }
        T t=a[p];
        a[p]=a[i];
        a[i]=t;
    }
}

//类模板的实例化  就是把class替换成具体的类型
template<> 
void Array<char *>::Sort()
{
     int p;
    for(int i=0;i<Size-1;i++)
    {
        p=i;
        for(int j=i;j<Size;j++)
        {
            if (a[p]<a[j])
            p=j;
        }
        T t=a[p];
        a[p]=a[i];
        a[i]=t;
    }
}

try throw catch 异常

异常是程序在执行期间产生的问题，C++是指在程序运行时发生的特殊情况
异常提供了一种转移程序控制权的方式
throw：当问题出现时，程序会抛出异常
catch：在想要处理问题的地方，通过异常处理程序捕获异常
try：try是包括了一个或多个可能引发异常的语句

void temperature(int t)
{
     if(t==100)
        throw "It is at the boiling point.";
     else if(t==0)
        throw "It reached the freezing point.";
     else
        cout<<"the temperature is OK..."<<endl;
}

int main()
{
    try{
        temperature(0);
        temperature(10);
        temperature(100);
    }
    catch(char const * s) {cout<<s<<endl;}
    system("pause");
    return 0;
}

//result
It reached the freezing point.
sh: 1: pause: not found

为什么答案只有It reached the freezing point

创作打卡挑战赛

赢取流量/现金/CSDN周边激励大奖