【目錄】

一、 仿函式 2
１、 仿函式， 2
二、 轉義字元 2
１、 去掉轉義字元R”()” 2
三、 using 別名 （與c的typedef相同） 3
四、 模板超程式設計 3
五、 智慧指標 4
１、 auto_ptr—–依賴於原生的指標 4
２、 C11新型智慧指標（推薦使用）—unique_ptr 5
六、 多執行緒 5
七、 靜態斷言 6

一、仿函式

  １、仿函式：：就是使一個類的使用看上去像一個函式。其實現就是類中實現一個operator()，這個類就有了類似函式的行為，就是一個仿函式類了。
    ①．建立一個函式指標，引用一個結構體內部或者一個類內部的公有函式using namespace std::placeholders;

#include<iostream>
#include<functional>//處理函式

using namespace std::placeholders;

struct MyStruct {

    void add(int a) {
        std::cout<<a<<std::endl ;
    }
    void add1(int a,int b) {
        std::cout<<a+b<<std::endl ;
    }
    void add2(int a,int b,int
 
 c) {
        std::cout<<a+b+c<<std::endl ;
    }
} ;
int main( int argc , char** argv ) {

    MyStruct my ;
    /*仿函式，建立一個函式指標，引用一個結構體內部或者一個類內部的公有函式*/
    /*auto自動變數，地址，函式指標，bind繫結
    **第一個引數引用內部函式，繫結一個實體物件*/
    auto fun1 = bind( &MyStruct::add , &my , _1 ) ;
    fun1(2) ;
    auto
 
 fun2 = bind( &MyStruct::add1 , &my , _1 ,_2 ) ;
    fun2( 5 , 10 ) ;
    auto fun3 = bind( &MyStruct::add2 , &my , _1 ,_2 , _3 ) ;
    fun3( 6 , 7 ,8 ) ;
    /*---------------------------------*/
    MyStruct struct1;
    /*建立函式指標，類結構體，資料私有，程式碼共享*/
    /*函式通過呼叫，呼叫需要傳遞物件名進行區分*/
    void(MyStruct::*p)(int a) = &MyStruct::add;
    (my.add)(3) ;
     (my.*p)(3) ;

    std::cin.get() ;
    return 0 ;
}

二、轉義字元

  １、去掉轉義字元R()
    ①．注：放在括號中的內容將被去掉轉義字元

R“（E:\Langue\C++\2014傳智播客C++\02_C++就業\20140816\vedio）”

三、using 別名 （與c的typedef相同）

#include <iostream>

namespace space   //隔離模板，避免衝突
{
    template<class T> using ptr = T*; //模板的簡寫
}

int add(int a, int b)
{

    return a + b;
}
typedef  int(*ADD)(int a, int b);
using  FUNC = int (*)(int a, int b);
//別名
using  co = std::ios_base::fmtflags;
//using只可以用於簡寫資料型別

void main()
{
    ADD p=add;
    std::cout<<p(1, 2)<<std::endl;
    FUNC func = add;
    std::cout << func(1, 2) << std::endl;
    //space::ptr<int> pint(new int(15));
/*指向int型別的指標*/
    //std::cout << *pint << "   " << pint << std::endl;

    std::cin.get();
}

四、模板超程式設計

#include<iostream>
//模板元吧執行時消耗的時間，在編譯期間優化

template<int N>
struct data {
    enum a{ res = data<N - 1>::a::res + data<N - 2>::a::res };
};

template<>
struct data<1> {
    enum a{res =1};
};

template<>
struct data<2> {
    enum a{res= 1 };
};

//1  1  2  3  5  7

int getdata(int n) {
    if (n==1 || n==2)   {
        return 1;
    } 
    else    {
        return getdata(n - 1) + getdata(n - 2);
    }
}

void main() {
    const int myint = 40;
    int num = data<myint>::res ; //<>內部不可以有變數
    std::cout << num << std::endl;

    std::cout << getdata(40) << std::endl;

    std::cin.get();
}
//主要思想
//
//利用模板特化機制實現編譯期條件選擇結構，利用遞迴模板實現編譯期迴圈結構，模板元程式則由編譯器在編譯期解釋執行。
//
//優劣及適用情況
//
//通過將計算從執行期轉移至編譯期，在結果程式啟動之前做盡可能多的工作，最終獲得速度更快的程式。也就是說模板超程式設計的優勢在於：
//
//1.以編譯耗時為代價換來卓越的執行期效能（一般用於為效能要求嚴格的數值計算換取更高的效能）。通常來說，一個有意義的程式的執行次數（或服役時間）總是遠遠超過編譯次數（或編譯時間）。
//
//2.提供編譯期型別計算，通常這才是模板超程式設計大放異彩的地方。
//
//模板超程式設計技術並非都是優點：
//
//1.程式碼可讀性差，以類模板的方式描述演算法也許有點抽象。
//
//2.除錯困難，元程式執行於編譯期，沒有用於單步跟蹤元程式執行的偵錯程式（用於設定斷點、察看資料等）。程式設計師可做的只能是等待編譯過程失敗，然後人工破譯編譯器傾瀉到螢幕上的錯誤資訊。
//
//3.編譯時間長，通常帶有模板元程式的程式生成的程式碼尺寸要比普通程式的大，
//
//4.可移植性較差，對於模板超程式設計使用的高階模板特性，不同的編譯器的支援度不同。

五、智慧指標（自動釋放記憶體）

  １、auto_ptr—–依賴於原生的指標

#include <iostream>

void main1() {

    for (int i = 0; i < 10000000; i++) {
        double *p = new double;//為指標分配記憶體
        std::auto_ptr<double> autop(p);
        //建立智慧指標管理指標p指向記憶體
        //智慧指標 
        //delete p;
    }
    std::cin.get();
}

  ２、C11新型智慧指標（推薦使用）—unique_ptr

#include<iostream>
#include<memory>   //記憶體

void main() {
    for (int i = 0; i < 10000000;i++) {
        //新型指標，新型的陣列

        std::unique_ptr<double> pdb(new double);

        //double *p = new double;
    }
    std::cin.get();
}

六、多執行緒

#include <thread>
#include<iostream>
#include<windows.h>
#include<vector>

using namespace std;
using namespace std::this_thread;

void msg() {
    MessageBoxA(0, "12345", "678910", 0);
}
void msgA(int num) {
    std::cout << get_id() << "  num=   " << num << std::endl;
}

void main1() {

    // thread::hardware_concurrency檢視計算機執行緒
    auto n = thread::hardware_concurrency();
    std::cout << n << std::endl;
    //獲取當前執行緒編號
    std::cout << "thread=" << get_id() << std::endl;


   thread thread1(msg);//建立多執行緒
   thread thread2(msg);
   thread1.join();//開始執行
   thread2.join();

    std::cin.get();
}

void main2() {

    vector<thread *> threads;
    for (int i = 0; i < 10; i++)    {
        threads.push_back(new thread(msg));//建立執行緒
    }

    for (auto th : threads)     {
        th->join();
    }

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

    vector<thread *> threads;
    for (int i = 0; i < 10; i++)    {
        threads.push_back(new thread(msgA,i));//建立執行緒
    }

    for (auto th : threads)     {
        th->join();
    }

    std::cin.get();
}

七、靜態斷言

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

using namespace std;
#define  N 10

void main() {
    int num = 100;
    cout << num << endl;
    cout << __FILE__ << endl;
    cout << __LINE__ << endl;
    cout << __DATE__ << endl;
    cout << __TIME__ << endl;
    cout << __FUNCTION__ << endl;

    cin.get();
}
#define M
void main1() {
   char  num = 10;
    //位元組>4
#ifdef  M
  // static_assert(sizeof(num) >= 4, "yincheng error");
#endif

    //除錯程式碼，迅速程式碼錯誤在哪一行

}

//regex pattern("[[:digit:]]",regex_constants::extended);
    //std::locale::global(std::locale("Chinese"));
    //setlocale(LC_ALL, "chs");
    /*
    std::string s ("我是你爹，你把");  
    std::smatch m;  
    std::regex e ("你");   // matches words beginning by "sub" 

    while (std::regex_search (s,m,e)) {  
        for (auto x=m.begin();x!=m.end();x++)   
            std::cout << x->str() << ":: ";  
            std::cout << "--> ([^ ]*) match " << m.format("$0") <<std::endl;  
            s = m.suffix().str();  
    }  
    */