函数2（五）

前面学习了一些函数基本使用，下面更深入的学习函数有关的内容。

内联函数：要理解内联函数有普通函数的不同，就应该知道函数的调用过程，下面就分析下函数的调用过程。如：

void fun1() ;
void fun2() ;

void fun1(){
     fun2()  ;
　　 cout << "fun1 method " << endl ;
}

void fun2(){
    cout << "fun2 method " << endl ;
}

　　在fun1函数中，当执行到fun2();时，则会跳出fun1函数，找到fun2函数的位置执行，执行完fun2函数再返回fun1函数中fun2的位置继续往下面执行。但内联函数与普通函数不同。如：

void fun1() ;
inline void fun2() ;
       
void fun1(){
     fun2()  ;
　　 cout << "fun1 method " << endl ;}

inline void fun2(){
    cout << "fun2 method " << endl ;
}

　fun2()为内联函数，则在编译时就会用fun2的函数代码替换fun1中fun2的函数调用，在执行fun1时，无需跳转，代价是占用更多的内存。如果内联函数小，则速度会增快，但如果函数大的话，执行速度会变慢。

　　内联函数是在函数声明和定义前加inline关键字。　内联函数与宏替换还是不同的，宏替换时文本替换，内联函数不是简单的文本替换。

引用变量：引用是已定义变量的别名(另一个名称)，如twain是element变量的别名，则可以通过twain和element来修改element的值。别名的主要作用是作为函数的参数。通过引用函数使用参数的原始数据，而不是实参数的副本。省去了参数的复制等过程。

　　1：创建引用变量

　　　　　　int rats ;

　　　　　　int & rodents = rats ;  

　　　　　　上面就定义了rodents引用变量，rodents和rats使用同一块内存单元，可以通过rodents引用来修改rats的值。

　　　　　　注意：引用在创建时必须进行初始化，初始化后，就不能将该引用变量作为其他变量的引用了。如：

int a = 23 ;
int b = 344 ;
int &i ;        //error 必须初始化
i = age ;      //error     初始化后不能再改变了

　　2：引用作为函数的参数，使函数中的变量名是调用函数中的变量的别名，称为引用传递，可以通过引用修改调用函数中的值。值传递不能修改，要修改液可以使用指针参数。

#include<iostream>

using namespace std ;

void swapr(int & , int &) ;
void swapv(int , int ) ;
void swapp(int * , int * ) ;
int main(){
    int x = 4 ,y = 5 ;
    swapr(x , y) ;
    swapv(x , y) ;     //值传递   并不能交换两个值
    swapp(&x ,&y ) ;   
    return 0 ;
}

void swapr(int &x ,int & y) {         //引用传递   
    int temp = 0 ;
    temp  = x ;
    x = y ;
    y = temp ;
}

void swapv(int x , int y) {         //值传递
    int temp = 0 ;
    temp = x ;
    x = y ;
    y = temp ;
}

void swapp(int *px , int *py) {      //使用指针
    int *p_temp = px ;
    px = py ;
    py = p_temp ;
}

　　使用引用能够修改调用函数的数据，若我们不希望这样呢，可以用const修饰引用形参，如：void cube(const int& x) ;这样我们在cube函数中就不能通过x引用来修改了，另外如果我们不使用const修饰，void fcube(int &x ) ;  我们就不能使用常量参数。

　　我们尽量应使用const修改参数引用：

　　　　1：使用const可以避免无意中修改数据

　　　　2：使用const，使函数能够处理const和非const实参，否则只能处理非const参数。

对于使用复合类型（结构、类等）作为参数的函数，我们更应该使用引用了，因为使用引用能够避免对象的复制等操作。

void fun(person p) {

}

void fun2(person &p ){

}

　当调用函数fun时，会调用person类的复制构造函数创建临时变量p,     调用fun2函数时，会创建临时引用，该引用指向实参。

　传统返回值和返回引用的区别：

int fun1(int x ) {
    return x ;
}

int& fun2(const int &x) {
    return x ;
}

　　传统返回值与按值传递过程一样，如：int m = fun1(4) ;  过程是将x复制到一个临时位置，然后再复制该变量m。则返回引用是：直接将x复制到m中，省去复制到临时变量中。

我们应避免返回函数中局部变量的引用或指针，因为到函数执行完，局部变量就不存在了，引用或指针的位置也就不存在了。为避免，我们应返回参数的引用或使用new创建指针。

默认参数：我们可以在声明函数时给形参提供默认值，这样我们在调用时，如果我们没有提供实参，就会使用默认值来调用函数。如：

#include<iostream>

using namespace std ;

const int ArSize = 80 ;

char * left(const char* str , int n = 1) ;
int main(){
    
    char simple[ArSize] ;
    cout << "Enter a string : "  << endl ;

    cin.get(simple , ArSize) ;
    
    char *pr = left(simple) ;      // n 使用默认值       

    cout << pr << endl ;

    delete [] pr ;

    return 0 ;
}

char * left(const char* str , int n) {
    if(n < 0 )
        n = 0 ;
    char * pr = new char[n+1] ;

    int i = 0 ; 
    for( ; i < n && str[i] ; i++ ) {
        pr[i] = str[i] ;
    }

    while(i <= n ) {
        pr[i] = '' ;
    }

    return pr ;
}

　　对于带参数列表的函数，必须从右向左添加默认参数，就是说，要为某个参数添加默认参数，则它右边的所有参数都有默认参数。如：

　　int harpo(int n , int m = 4 , int j = 5) ;        //可以使用

　　int chico(int n , int m = 5 , int j) ;               //不可以使用

函数重载：

　　c++允许定义函数名相同的函数，条件是参数类型或个数不相同。如我们定义计算总值的函数sum:

int sum(int x , int y) {
    return x + y ;
}

int sum(float x , float y ) {
    return x + y ;
}

int sum(double x , double y ) {
    return x + y ;
}

则上面的三个函数就是重载，编译器将根据传入的参数来决定使用哪个函数。

int cube(int x ) ;
int cube(int &x ) ; 

void dribble(char * bits ) ;
void dirbble(const char* bits) ;

上面的各对函数不能共存，因为在调用的使用不能区分该调用哪个函数。

函数模板：函数是通用的函数描述，使用泛型来定义函数，其中泛型能够使用类型来进行替换，通过将类型作为参数传递给模板，编译器能够生成该类型的函数。

如：我们要定义交换的函数，可以使用int类型，也可以使用double类型，则我们可以使用函数重载，但这里我们使用函数模板：

#include<iostream>

using namespace std ;

template<typename T>      //函数模板声明
    void swap(T& , T& ) ;
int main(){
    int i = 20 , j = 10 ;
    cout << "before : i , j = " << i << " , " << j << endl ;
    swap(i , j ) ;                 //调用函数模板
   cout << "now : i , j = " << i << " , " << j << endl ;
    
    double a = 30.0 , b = 40.0 ;
    cout << "before : a , b = " << a << " , " << b << endl ;
    swap(a , b) ;                //调用函数模板
   cout << "now : a , b = " << a << " , " << b << endl ;
    
    return 0 ;
}

template<typename T>      //定义函数模板
void swap(T &a , T &b ) {
    T temp = a ;
    a = b ;
    b = temp ;
}

函数模板的使用方式同函数相同，在使用前要进行定义、声明。

 template<typename T>   void swap(T& , T& )       使用关键字template定义模板 ， typename定义类型，可以使用class来替换，T是类型名，类型名可以在函数中使用，作为泛型定义的类型，在使用时会根据实参的类型来创建出特殊的函数。使用时， swap(a , b) ;   编译器将生成double版本：

void swap(double &a , double &b ){
    double temp = a ;
    a = b ;
    b = temp ;
}

函数模板不能缩短可执行程序，如上面，最终将有两个独立的函数定义，像手动定义他们一样，最终的代码不含有任何模板，只包含了为程序生成的实际函数，使用模板的好处是，它是生成多个函数更简单、更可靠。

常用的方式是，将模板定义在头文件中，在使用它的程序中包含该头文件。

 模板重载：模板也可以像函数那个重载，只要参数类型或个数不同就行了，如我们要定义一个交换数组的模板，则swap(T *a , T *b , int n ) ; 在函数模板中不是必须使用泛型类型，也可以使用特定的类型。

#include<iostream>

using namespace std ;

template<typename T>
        void Swap(T &, T &) ;
template<typename T>
        void Swap(T *, T *, int) ;
void show(int[] ,int ) ;

int main(){
        int i = 10 , j = 20 ;
        cout << "before : i , j = " << i << " , " << j << endl ;
        Swap(i , j) ;               //调用Swap(int &, int &) ;
        cout << "now : i , j = " << i << " , " << j << endl ;

        double a = 20.0 , b = 30.0 ;
        cout << "before : a , b = " << a << " , " << b << endl ;
        Swap(a , b) ;           //调用Swap(double & , double &) ;
        cout << "now : a , b = " << a << " , " << b << endl ;

        int arr1[] = {1, 2, 3, 4, 5} ;
        int arr2[] = {6, 7, 8, 9, 10} ;
        cout << "before : " << endl ;
        show(arr1, 5) ;
        show(arr2, 5) ;

        Swap(arr1 , arr2 , 5) ;    //调用Swap(int [] , int [] , int ) ;
        cout << "now : " << endl ;
          show(arr1, 5) ;
        show(arr2, 5) ;

        return 0 ;
}

template<typename T>
        void Swap(T &a , T &b) {
        T temp = a ;
        a = b ;
        b = temp ;
}

template<typename T>
     void Swap(T *a , T *b , int n ) {
        T temp ;
        for(int i = 0 ; i < n ; i++ ) {
                temp = a[i] ;
                a[i] = b[i] ;
                b[i] = temp ;
        }
}

void show(int a[] , int n) {

        for(int i = 0 ; i < n ; i++) {
                cout << a[i] << "  ," ;
        }
        cout << endl ;
}
                        

　　显性具体化模板函数：如果存在一个结构体Job，我们使用Swap模板函数，也能够交换两个Job的数据，但是现在我们只希望交换对象的一个元素salary,其他元素不变，则这时Swap模板函数就不行了。我们可以使用具体化模板函数：

　　

#include<iostream>
using namespace std ;

template<typename T>
        void Swap(T &a , T &b );

struct Job {
        char name[40] ;
        double salary ;
        int floor ;
};

template<> void Swap<Job>(Job &a , Job &b ) ;

void Swap(Job &a , Job &b ) ；

void show(Job &j) ;

int main(){
        int i = 20 , j = 40 ;
        cout << "before : i , j = " << i << " , " << j << endl ;
        Swap(i , j ) ;
        cout << "now : i , j = " << i << " , " << j << endl ;

        Job xu = {"xushuangzhi" , 3500.0 , 4} ;
        Job sue = {"sue" , 2000.0 , 7} ;

        cout << "before : " << endl ;
        show(xu) ;
        show(sue) ;
        Swap(xu , sue) ;                   //这里将调用非模板函数
        cout << "now : " << endl ;
        show(xu) ;
        show(sue) ;

        return 0 ;
}
//函数模板
template<typename T>
        void Swap(T &a , T &b ){
        T temp = a ;
        a = b ;
        b = temp ;
}
//具体化函数模板
template<> void Swap<Job>(Job &a , Job &b ) {
        double sal_temp = a.salary ;
        a.salary = b.salary ;
        b.salary = sal_temp ;

        int floor_temp = a.floor ;
        a.floor = b.floor ;
        b.floor = floor_temp ;
}
//非模板函数
void Swap(Job &a , Job &b ) {
         double sal_temp = a.salary ;
        a.salary = b.salary ;
        b.salary = sal_temp ;

        int floor_temp = a.floor ;
        a.floor = b.floor ;
        b.floor = floor_temp ;

}
void show(Job &j) {
        cout << j.name << " : $ " << j.salary << " on floor :" << j.floor << endl ;
}

　　上面有三个函数都符合Swap(xu , sue)的函数调用，非模板函数，具体化函数模板，常规函数模板，他们的优先级是非模板函数> 具体化函数模板 > 常规函数模板