註釋的使用

1. /* / 是從一個（/ ）開始到 （ */）結束的。
2. 重置輸入流的錯誤標誌，需要呼叫cin.clear()。
3. int x=static_cast(0.0); ==型別轉換==
4. 從不建議在表示式中組合==有==符號整數和無符號整數。因為無符號整數unsigned int x=-1;在輸出的時候會變成65535，因為-1的二進位制是全1。
5. wchat_c wide_str[]=L”\x10ff”; 兩個位元組的十六進位制必須用寬字元。
6. R “C：\windows” 在C++11中可以原樣輸出反斜線。
7. decltype來確定表示式的型別，e.g. decltype(x+y) z=0;
8. typeid是C++的關鍵字之一，等同於sizeof這類的操作符。

int x=0;
if(typeid(x+x)==typeid(int)){
    cout<<12<<endl;
   } 

1. & 按位與　　| 按位或　　^按位異或
2. 字首遞增是應當鼓勵的，因為字尾遞增需要建立被遞增的物件的副本。

++n; //單獨的字首遞增 
n++; //單獨的字尾遞增

1. << 和 >>都補得是0。
2. C++的型別轉換運算子

13. C++11中，基於範圍的for語句。

//可以訪問但不能修改
for(int i:array){
    cout<< i <<endl;
}
//可以訪問，也可以修改
for(int &i:array
 
){
    i=0;
}

14.異常處理

C++庫中定義的基本異常類

邏輯錯誤異常

15. break 只退出當前迴圈，如巢狀迴圈，可通過設定標記使外側while迴圈達到推出條件。
16. lambda 函式

//lambda in STL
#include <algorithm> 
int arr[5]={5,10,15,20,25};
int sum=0;
for_each(arr,arr+5,[&sum] (int n) {sum+=n;})

//按值捕獲的只會捕獲一次。
int i =10;
auto f=[ i ](int n ){return n>i;};
cout<<"Is 5>i?"<<f(5)<<endl;//print false(0)
i=1;
cout<<"Is 5>i?"<<f(5)<<endl;//print false(0)
//[&] 
int i =10;
auto f=[ &i ](int n ){return n>i;};
cout<<"Is 5>i?"<<f(5)<<endl;//print false(0)
i=1;
cout<<"Is 5>i?"<<f(5)<<endl;//print true(1)

//返回一個lambda的函式
#include<functional>
#include <iostream>
using namespace std;
function<int(int,int)> get_fun(){
    int n=10;
    return [n](int a,int b){return a+b+n;};
    //[&n] 會導致垃圾指標，因為n是區域性非靜態變數。
}
int main(){
    auto f = get_fun();
    cout<<f(1,2)<<endl;//print 13
}

1. constexpr關鍵字應用於函式時，會使編譯器儘可能把對該函式的呼叫當作編譯時常量。

int &j=i;//j是 i 的別名。

void funtion(const int &a);//儘量把引用引數宣告為 const 型別。

1. 關於陣列

int array1[10]={};//把元素都初始化為0. 假設只有{1}只給第一個元素賦值。
int array2[10];//如果這是區域性變數，則元素包含垃圾，此刻的垃圾指的是隨機的無意義的值。

在C++11中，基於範圍的for只能與全域性陣列連用，因為他們的長度是已知的，不能用在函式中。

int i=0;
for(auto &x:arr){
    x=i++;//為陣列arr賦值1，2，3，.......
}

字尾自增運算子（++）比 “at” 運算子（*）具有更高的優先順序。

*P++=0;//等同於
*(p++)=0; //先賦值在自增
//對於一個拷貝函式
//指標版
void copy_array(int *p1,int *p2,int n){
    for(int i=0;i<n;i++){
        *p1++ = *p2++;
    }
}
//陣列索引版
void copy_array(int *p1,int *p2,int n){
    for(int i=0;i<n;i++){
        p1[i] = p2[i];
    }
}

指標版更 有效，因為它避免了陣列索引版不得不反覆計算索引並和重新計算元素位置的操作。（指標版只在順序訪問有效，隨機訪問不節省，也就是當我們要遍歷的時候選擇指標版）

在多維的情況下，指標版的增益很顯著。

double array_2D[10][10];
reset_2D_dbl_array(array_2D,10,10);
//對於array_2D[10][10]陣列傳遞失敗  型別不匹配
void reset_2D_dbl_array(double **p,int numberOfRows,int numberOfColumns){
    int n = numberOfRows * numberOfColumns;
    while(n-- > 0){
        **p++ = 0.0;
    }
} 

----變成一維陣列來算
void reset_2D_dbl_array_P(double *p,int numberOfRows,int numberOfColumns){
    int n = numberOfRows * numberOfColumns;
    while(n-- > 0){
        *p++ = 0.0;
    }
}
void reset_2D_dbl_array(double p[][10],int numberOfRows,int numberOfColumns){
    for(int i=0;i < numberOfRows;i++){
        for(int j=0; j < numberOfColumns; j++){
            p[i][j]=i*j;
        }
    }
}

int a[2][3]; int**p=&a; //這裡我用&a來賦值行不行呢。是不行的。 這裡為什麼是錯誤的，原因就是因為&a的型別不是int**型別。所以型別不相容，導致不能賦值，同時這兩種型別是不可以相互轉換的。 那麼&a到底是一個什麼樣的型別呢。 我們說&a去的是整個陣列的地址，那麼&a自然就是指向整個陣列的指標了。 int (*p)[2][3]=&a; 此時這樣賦值才是正確的。如果我們要用a直接賦值，那該定義一個什麼樣的變數來接受它呢，首先要明白，陣列名代表的地址型別是指向陣列的第一個元素的指標，例如： int a[10]; int *p=a; 實際上這裡與 int *p=&a[0];是等價的。因為指向a[0]的指標型別就是int*型別。 那麼&a的是去陣列的地址，其型別是指向陣列的指標，而不是指向陣列第一個元素的指標，整個是要區別的，他們的型別就不一樣。 int(*p)[10]=&a; 所以說這裡的a和&a絕對不是同一個東西，雖然本質上他們的地址值是一樣的，但是他們的型別不一樣。就決定他們代表不同的意義。 那麼剛剛說了對於下面的例子： int a[2][3]; int (*p)[2][3]=&a; // 我們可以定義這樣的一個變數p來接受&a的值。 那麼我們要接受a應該定義一個什麼樣的變數呢。a[2][3]是一個二維陣列，可以看成是這樣的a是一個數組，具有兩個元素，分別為a[0],a[1]其中這兩個元素的值a[0],a[1]他們的值又是一個具有3個元素的陣列。此時我們可以將a[0],a[1]看成是陣列名，那麼a[0][0]就是陣列a[0]的第0個元素了。對應關係如下： a[0] —-> a[0][0],a[0][1],a[0][2] a[1] —-> a[1][0],a[1][1],a[1][2] 那麼a到底是什麼，其實a陣列有兩個元素，a[0],a[1]，那麼a的值自然就是其第一個元素的地址了，也就是&a[0]了。這是一個什麼型別？ 我們知道如果我們將a[0]看成一個整體，例如我們用A來代替a[0],那麼A[0],A[1]就相當於a[0][0],a[0][1] 。 此時A就是一個int型別的陣列，&A，的型別實際上就是 int(*p)[3]這個型別。 所以下面的程式碼也是正確的： int a[2][3]; int(*p)[3]=a;
閱讀原文

19.

 void set_array(double arr[],int n){
     double *p=arr;
     while(n-- >0){
        *p++=1.0;
     }
 }
 void set_array_P(double *arr,int n){
      for(int i=0;i < 10;i++){
        arr[i]=1.0;
    }
 }
 //也可以
 void set_array_P(double arr[],int n){
      for(int i=0;i < 10;i++){
        arr[i]=1.0;
    }
 }
 //陣列用指標來操作，或者直接傳遞可操作型別的
double array1[10];
set_array(array1,10);
set_array1(array1,10);
// 對於不需要修改的傳遞可以用const修飾
//const修飾的可以接收const和非const型別的值，反之不可。
void display(const double arr[],int n){
        for(int i=0;i < 10;i++){
         cout<< arr[i];
    }
 }

1. [const] 型別 * [const] 變數名
   第一個const指定基本型別是常量，第二個const保護指標免受更改。

2. 資料宣告— 宣告變數的更完整的語法是\
   [修飾符]　型別　變數宣告 　

3. void指標

適用於void*指標的規則如下
- 你可以把任意地址賦值給一個void*指標或一個void*指標引數。
- 但是，你不能反方向取值，一個void*不能不經過轉換型別就賦值給具體型別的指標。
- 如果對一個void*地址進行指標運算，則不執行按比例放大。

int integer = *(reinterpret_cast<const int*>(p1));//p1 是 void* 型別的

23.指標函式

typedef int (* FPTR)(int);
int fun(int n){
    return n*2;
}
FPTR getFunction(){
    return fun;
}
 int main()
{
   FPTR fp = getFunction();
   cout<<(fp)(10);//print 20

    return 0;
} 

1. 智慧指標

包含這個標頭檔案

- 共享指標.reset（）；刪除共享指標與當前指向記憶體物件之間的關聯。
- 共享指標.reset（新指標）；刪除共享指標與當前指向記憶體物件之間的關聯。

//埃拉托色尼篩
#include <iostream>
#include <math.h>
using namespace std;
void process_prime(bool *p,int max_n, int n);
void display(bool *p,int max_n);
 int main()
{
   int max_n=0;
   cout<<"Calculate primes up to what number?\n";//計算質數到什麼數？
   cin>>max_n;
   bool *p = new bool[max_n + 1];//分配陣列
   for(int i=2;i<max_n;i++){//初始化陣列
        p[i]=true;
   }
   for(int i=2;i<sqrt(max_n);i++){//查詢質數   //查到平方根就夠了
        if(p[i]){
            process_prime(p,max_n,i);
        }
   }
   display(p,max_n);//print
   cout<<endl;
   delete [] p;//不是絕對必要的，但卻是一個好主意。
   cin.ignore();//
    return 0;
}
/* 處理質數函式
列印傳遞給函式的數n，然後把布林陣列（p）的所有元素中，
對應於n的倍數的元素被標記為false。  */
void process_prime(bool *p,int max_n, int n){
    for(int i=n+n;i<=max_n;i+=n){
        p[i]=false;
    }
}
//輸出結果
void display(bool *p,int max_n){
    for(int i=2;i<max_n;i++){
        if(p[i]){
            cout<<i<<"\t";
        }
   }
}