C++ template的一些高級用法（元編碼，可變參數，仿函數，using使用方法,. C++ 智能指針）

1 .  通用函數可變參數模板

     對於有些時候，我們無法確切的知道，函數的參數個數時，而又不想過多的使用所謂的函數重載，那么就可以效仿下面的例子：

#include<iostream>
#include<Array>
void showall() { return; }

template <typename R1 ,typename...  Args>

void showall(R1 var, Args...args) {

    std::cout << var << std::endl;
    showall(args...);
}

int main(int argc, char * args[]) {

    
    showall(1, 2, 3, 4, 5);
    showall("gxjun","dadw","dasds");
    showall(1.0,2.0,3.5);
    std::cin.get();
    return 0;
}

在游戲開發中，時常會用到這樣的模板，類型不確定，參數的個數不確定，所以需要用一種類似於遞歸的函數來處理。  第一個函數，表示的是在參數為0時，結束。

效果：

2.  如何使用仿函數：

     首先仿函數的定義： ，仿函數也叫函數對象（Function Object, or Functor），定義就是任何可以像函數一樣被調用的對象。一個普通的函數是函數對象，一個函數指針當然也是，廣義上說任何定義了operator()的類對象都可以看作是函數對象。 （找到文檔）

      其實，往直白的地方說，就是一個不是函數但是具有函數功能且用法和函數相同的對象（結構體或者類）。

下面舉個栗子（用結構體實現函數功能）：

  

/*關於C++仿函數*/
#include<iostream>
#include<functional>
using namespace std;
using namespace std::placeholders;  

template <typename R1 , typename R2>
struct  Calc
{
    void add(R1 a) {
        cout << a << endl;
    };
    void add_1(R1 a, R1 b) {
        cout << a + b << endl;
    }  
};

int main(int argc, char * args[]) {

    //函數指針
    void(Calc<int, double>::*fc)(int  a) = &Calc<int, double >::add;
    // fc(25);
    //顯然上面的式子比較的麻煩
    
    Calc < int, int> calc;
    auto  fun = bind(&Calc<int, int >::add, &calc, _1);
    auto  fun_2 = bind(&Calc<int, int >::add_1, &calc, _1,_2);
    fun(123);
    fun_2(12,24);
   cin.get();
 return 0;
}

    對於bind（）這個函數，開頭的是地址，函數名，后面的是第一個列子中的Args....不定參數類型、

效果圖為：

   

3. 使用using別名，函數指針，typdef來實現函數的調用

    雖然是寥寥的幾行代碼，但是功能在實際應用中，卻會發揮很大的作用。

//using別名使用用法
#include<iostream>
#include<windows.h>
int calc() {
  //當為無參數時，返回0值
    return 0;
}

template <typename R1 ,typename...Args>
int calc(R1 a, Args...args) {

    return a + calc(args...);
}

int main(int argc , char * args []) {

    //使用函數指針
    int(*fun) (int ,int ,int ,int ) = calc;
    system("echo 使用函數指針實現1~4累加");
    std::cout << fun(1,2,3,4)<<std::endl;
   //使用typedef來實現該功能
    system("echo 使用typedef實現1~4累加");
     typedef int(*Add)(int, int, int);
     Add  Gadd = calc;
     std::cout << Gadd(1, 2, 3) << std::endl;
    //使用using別名來實現這么個功能
    system("echo 使用using實現1~4累加");
    using Func = int(*) (int, int, int, int);
    Func func = calc;
    std::cout << func(1, 2, 3, 4) << std::endl;
    std::cin.get();
 return 0;
}

效果圖： 

  4. C++模板元編程:

          對於模板元編程： 我的理解是，你所要的計算，在編譯的時候，已經處理玩了，只需要在運行的時候輸出結果即可！

    當我們每每學到模板元編程的時候，就會有一個混淆的詞匯出現，噠，看------函數式編程。 到底什么是函數式編程呢？

    建議去看這篇文章，http://www.ruanyifeng.com/blog/2012/04/functional_programming.html  模板元編程用處廣泛，

    我們知道當硬件條件限制的情況下，除了優化算法，還有一種途徑，那就是用模板元編程。 現在就讓我們來看看這個金典的應用吧！

    斐波那契數列的計算......

   

#include<iostream>
#include<time.h>
#include<windows.h>
/*
  斐波那契數列
   H(1)=H(0)=1;
   H(N)= H(N-1)+H(N-2);
*/
using namespace std;

 /* 普通版普通版 */
 using _int = long  ;    //使用別名
 
 _int feibona(_int ac) {
    if (ac == 0||ac==1)  return 1;
    return feibona(ac-1) +feibona(ac-2);
}

 /* 使用元編程 完全特化版 方法如下*/
 template <_int N>
 struct data {
     //采用枚舉
     enum { res = data<N - 1>::res + data<N - 2>::res };
 };

template <>
struct data<1> {
    //采用枚舉
    enum { res = 1L };
};

template <>
struct data<0> {
    //采用枚舉
    enum { res = 1L };
};


int main(int argc, char * args[]) {

    time_t  a ,b;
    a = clock(); //開始記錄時間
    cout << data<45L>::res << endl;
    b = clock(); //開始記錄時間
    system("echo 采用元編程所消耗的時間");
    cout << (double)(b - a) / CLK_TCK<<"ms"<<endl;
    a = clock();
    cout << feibona(45L) << endl;
    b = clock();
    system("echo 采用普通的算法所消耗的時間");
    cout << (double)(b - a) / CLK_TCK << "ms" << endl;
    cin.get();
    return 0;
}

  兩者相對比的效果圖：

 

5  C++智能指針 ，關於智能指針和普通指針，的幾種行為的對比

 

/*
 智能指針：
    對於C++而言：        std::auto_ptr<double> ptr(new double);
    對於C++11新的智能指針：         std::unique_ptr<double>  ps(new double);
    通過下面幾組數據做些一點
*/
#include<iostream>
#include<memory>
#include<windows.h>
using  namespace std;
/*模式一 分配內存地址，而不手動進行回收 */
void showp() {
    system("echo 分配內存地址，而不手動進行回收");
    for (int i = 0; i < 10000000; i++) {
          double * p = new double;   //不釋放
    }
    cin.get();
}
/* 模式二，分配地址，並手動進行回收地址 */
void showp1() {
    system("echo 分配地址，並手動進行回收地址");
    for (int i = 0; i < 10000000; i++) {
        double * p = new double;   //不釋放
        delete p;
    }
    cin.get();

}
/*模式三，分配地址，采用c++通用指針*/
void showp2() {
    system("echo 分配地址，采用c++通用指針");

    for (int i = 0; i < 10000000; i++) {
        double * p = new double;   //不釋放
        auto_ptr<double> ps(p);   //采用智能指針，不會多釋放地址，舊版本vc98支持
    }
    cin.get();
}
/* 模式四，分配地址，采用C++11新型指針 */

void showp3() {

    system("echo 分配地址，采用C++11新型指針");
    for (int i = 0; i < 10000000; i++) {
        auto_ptr<double> ps(new double);   //采用智能指針，C++11新特性
    }
    cin.get();
}

int main(int argc , char * args []) {
 
    //auto_ptr
   //函數指針
    void(*p[])() = { showp,showp1,showp2,showp3 };
    //for (auto data : p) {
    //    data();
   //}
    p[1]();
    system("echo 按一下結束");
    cin.get();
  return 0;
}

模式一： 消耗內存截圖

模式二  吃掉的內存截圖：

模式三，吃掉的內存截圖：

模式四，吃掉的內存截圖：

  使用智能指針的好處：

　　　　1 、 不會對一個分配的地址，釋放兩次。如果手動釋放地址，存在着重復釋放或者漏放的情況。 避免內存泄露。

 　　　  2.  釋放及時，不會搗鼓電腦中cpu換句話說，不會吃cpu。而是電腦運緩慢....