轻松搞定C++ 3、C++对C语言的扩展

inline 内联函数

c 语言中有宏函数的概念。宏函数的特点是内嵌到调用代码中去,避免了函数调用  的开销。但是由于宏函数的处理发生在预处理阶段,缺失了语法检测和有可能带来的语意差错。

1 内联函数的基本概念

C++提供了  inline 关键字,实现了真正的内嵌。

#include  <iostream> 
using  namespace  std; 
inline  void  func(int  a) 
{ 
    a  =  20; 
    cout  <<  a  <<endl; 
} 
int  main(void) 
{ 
    func(10); 
    /* 
       //编译器将内联函数的函数体直接展开 
    { 
        a  =  20; 
        cout  <<  a  <<endl; 
    } 
     
    */ 
    
    return  0; 
} 

特点：
1）内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。 
2）C++编译器直接将函数体插入在函数调用的地方  。 
3）内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)。 
4）内联函数是一种特殊的函数，具有普通函数的特征（参数检查，返回类型等）。 
5）内联函数由  编译器处理，直接将编译后的函数体插入调用的地方， 
   宏代码片段  由预处理器处理，进行简单的文本替换，没有任何编译过程。
6）C++中内联编译的限制： 
  不能存在任何形式的循环语句     
  不能存在过多的条件判断语句 
  函数体不能过于庞大 
  不能对函数进行取址操作 
  函数内联声明必须在调用语句之前 
7）编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。因此，当函数体的执行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义。

2 内联函数VS宏函数

#include  <iostream> 
#include  <string.h> 
using  namespace  std; 
#if  0 
优点:    内嵌代码,辟免压栈与出栈的开销 
缺点:    代码替换,易使⽣生成代码体积变⼤大,易产⽣生逻辑错误。  
#endif 
#define  SQR(x)  ((x)*(x)) 
#if  0 
优点:    ⾼高度抽象,避免重复开发  
缺点:    压栈与出栈,带来开销  
#endif 
inline  int  sqr(int  x) 
{ 
    return  x*x; 
} 
int  main() 
{ 
    int  i=0; 
    while(i<5) 
    { 
        //  printf("%d\n",SQR(i++)); 
        printf("%d\n",sqr(i++)); 
    } 
    return  0;  
}

3 内联函数总结

优点:避免调用时的额外开销(入栈与出栈操作)
代价:由于内联函数的函数体在代码段中会出现多个“副本”,因此会增加代码段的空间。
本质:以牺牲代码段空间为代价,提高程序的运行时间的效率。
适用场景:函数体很“小”,且被“频繁”调用。

默认参数和占位参数

通常情况下,函数在调用时,形参从实参那里取得值。对于多次调用用一函数同一实参时,C++给出了更简单的处理办法。给形参以默认值,这样就不用从实参那里取值了。

1 默认参数

//1  若你填写参数,使用你填写的,不填写默认 
void  myPrint(int  x  =  3) 
{ 
    cout<<"x:  “<<x<<  endl; 
} 

//2  在默认参数规则  ，如果默认参数出现，那么右边的都必须有默认参数 
float  volume(float  length,  float  weight  =  4,float  high  =  5) 
{ 
    return  length*weight*high; 
} 
int  main() 
{ 
    float  v  =  volume(10);  
    float  v1  =  volume(10,20); 
    float  v2  =  volume(10,20,30); 
    cout<<v<<endl; 
    cout<<v1<<endl; 
    cout<<v2<<endl; 
    return  0; 
} 

只有参数列表后面部分的参数才可以提供默认参数值一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值 

2 占位参数

#include  <iostream> 
/* 
   函数占位参数   
   占位参数只有参数类型声明，而没有参数名声明 
   一般情况下，在函数体内部无法使用占位参数 
 */ 
int  func(int  a,  int  b,  int) 
{ 
    return  a  +  b; 
} 
int  main() 
{ 
    func(1,  2);  //error,  必须把最后⼀一个占位参数补上。 
                //好悲剧的语法  -­‐_-­‐! 
    printf("func(1,  2,  3)  =  %d\n",  func(1,  2,  3)); 
    return  0; 
} 

#include  <iostream> 
/* 
   可以将占位参数与默认参数结合起来使⽤用 
   意义 
   为以后程序的扩展留下线索   
   兼容C语⾔言程序中可能出现的不规范写法 
 */ 
//C++可以声明占位符参数，占位符参⼀一般用于程序扩展和对C代码的兼容 
int  func2(int  a,  int  b,  int  =  0) 
{ 
    return  a  +  b; 
} 
int  main() 
{ 
    //如果默认参数和占位参数在⼀一起，都能调⽤用起来 
    func2(1,  2);  
    func2(1,  2,  3); 
    return  0; 
} 
/* 
结论：如果默认参数和占位参数在⼀一起，都能调用起来 
*/ 

函数重载

函数重载(Function  Overload)：用同一个函数名定义不同的函数，当函数名和不同的参数搭配时函数的含义不同。 

1 重载规则

1,函数名相同。
2,参数个数不同,参数的类型不同,参数顺序不同,均可构成重载。
3,返回值类型不同则不可以构成重载。

2 调用准则

1,严格匹配,找到则调用。
2,通过隐式转换寻求一个匹配,找到则调用。

#include  <iostream> 
using  namespace  std; 
void  print(double  a){ 
    cout<<a<<endl; 
} 
void  print(int  a){ 
    cout<<a<<endl; 
} 
int  main() 
{ 
    print(1);  //  print(int) 
    print(1.1);  //  print(double) 
    print('a');  //  print(int) 
    print(1.11f);  //  print(double) 
    return  0; 
} 

编译器调用重载函数的准则: 
 1.将所有同名函数作为候选者 
 2.尝试寻找可行的候选函数 
 3.精确匹配实参 
 4.通过默认参数能够匹配实参 
 5.通过默认类型转换匹配实参 
 6.匹配失败 
 7.最终寻找到的可行候选函数不唯一，则出现二义性，编译失败。 
 8.无法匹配所有候选者，函数未定义，编译失败。

3 重载底层实现（name mangling）

C++利用  name  mangling(倾轧)技术,来改名函数名,区分参数不同的同
名函数。  
 实现原理:用  v  c  i  f  l  d  表示  void  char  int  float  long  double  及其引
用。  

void  func(char  a);                   //  func_c(char  a)  
void  func(char  a,  int  b,  double  c);  //func_cid(char  a,  int  b,  double  c) 

4 函数重载与函数默认参数

一个函数,不能既作重载,又作默认参数的函数。当你少写一个参数时,系统 无法确认是重载还是默认参数。 

#include  <iostream> 
using  namespace  std; 
int  func(int  a,  int  b,  int  c  =  0) 
{ 
    return  a  *  b  *  c; 
} 
int  func(int  a,  int  b) 
{ 
    return  a  +  b; 
} 
int  func(int  a) 
{ 
    return  a; 
} 
int  main() 
{ 
    int  c  =  0; 
    c  =  func(1,  2);  //error.  存在⼆二义性，调⽤用失败，编译不能通过  
    printf("c  =  %d\n",  c); 
    return  0; 
} 

5 函数重载和函数指针结合

/* 
   函数重载与函数指针 
   当使用重载函数名对函数指针进⾏行赋值时 
   根据重载规则挑选与函数指针参数列表一致的候选者 
   严格匹配候选者的函数类型与函数指针的函数类型 
 */ 
#include  <iostream> 
using  namespace  std; 
int  func(int  x)  //  int(int  a) 
{ 
    return  x; 
} 
int  func(int  a,  int  b) 
{ 
    return  a  +  b; 
} 
int  func(const  char*  s) 
{ 
    return  strlen(s); 
} 
typedef  int(*PFUNC)(int  a);  //  int(*)(int  a) 
typedef  int(*PFUNC2)(int  a,  int  b);  //  int(*)(int  a,  int  b) 
int  main() 
{ 
    int  c  =  0; 
    PFUNC  p  =  func; 
    c  =  p(1); 
    printf("c  =  %d\n",  c); 
    PFUNC2  p2  =  func; 
    c  =  p2(1,  2); 
    printf("c  =  %d\n",  c); 
    return  0; 
} 

函数指针声明方法:

//方法一： 
//声明一个函数类型 
typedef  void  (myTypeFunc)(int  a,int  b); 
//定义一个函数指针 
myTypeFunc  *myfuncp  =  NULL;  //定义一个函数指针  这个指针指向函数的⼊入口地址 
//方法⼆： 
//声明一个函数指针类型  
typedef  void  (*myPTypeFunc)(int  a,int  b)  ;   //声明了一个指针的数据类型  
//定义一个函数指针 
myPTypeFunc  fp  =  NULL;   //通过函数指针类型  定义了一个函数指针  , 
//方法三： 
//定义一个函数指针  变量 
void  (*myVarPFunc)(int  a,  int  b); 

6 函数重载总结

重载函数在本质上是相互独立的不同函数。
函数的函数类型是不同的
函数返回值不能作为函数重载的依据
函数重载是由函数名和参数列表决定的。