c++基礎語法規則

1，c++存儲類：定義函數或者變量的生命周期

    auto 關鍵字用於兩種情況：聲明變量時根據初始化表達式自動推斷該變量的類型、聲明函數時函數返回值的占位符。

    register 存儲類用於定義存儲在寄存器中而不是 RAM （內存）中的局部變量，寄存器是cpu中的相關部件，具體干啥是不明。

    static 存儲類指示編譯器在程序的生命周期內保持局部變量的存在(就是cpp的整個生命進程內)，當全局變量用也是可以的。而不需要在每次它進入和離開作用域時進行創建和銷毀。這個比較常用，看個實例吧

#include <iostream>
 
// 函數聲明 
void func(void);
 
static int count = 10; /* 全局變量 */
 
int main()
{
    while(count--)
    {
       func();
    }
    return 0;
}
// 函數定義
void func( void )
{
    static int i = 5; // 函數每次被調用都會聲明局部靜態變量為5，但是這並不管用，第一次調用的時候確實為5，第二次的時候就成了6，第三次7，，，如果去掉static，那i就每次都變成5了
    i++;
    std::cout << "變量 i 為 " << i ;
    std::cout << " , 變量 count 為 " << count << std::endl;
}

    有關靜態全局變量，總結起來有三個好處：

僅對本文件內有效；類似全局變量但是變量屬於函數本身，不會隨着函數結束而被銷毀；僅僅第一次調用的時候初始化，往后再調用就跳過。具體解釋看教程：https://blog.csdn.net/majianfei1023/article/details/45290467

extern存儲類就是調用前一個文件里的全局變量，省的自己去定義了，或者自己無法初始化，所以‘繼承’一個過來。

實例：

/*first file:hello.cpp*/
#include <iostream>
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}

/*second file:hello2.cpp*/
#include <iostream>
 
extern int count;
 
void write_extern(void)
{
   std::cout << "Count is " << count << std::endl;
}

/*g++ hello.cpp hello2.cpp -o write 
bb一句，原來c++中兩個文件可以放到一塊編譯，編譯完了就是一個文件；尤其是兩個看起來沒啥關系的文件*/

mutable 說明符僅適用於類的對象，不知所以，留后。

thread_local存儲類，使用 thread_local 說明符聲明的變量僅可在它在其上創建的線程上訪問。 變量在創建線程時創建，並在銷毀線程時銷毀。 每個線程都有其自己的變量副本。

2，運算符

算數運算符：假設b為20，a為10

運算符	描述	實例
+	把兩個操作數相加	A + B 將得到 30
-	從第一個操作數中減去第二個操作數	A - B 將得到 -10
*	把兩個操作數相乘	A * B 將得到 200
/	分子除以分母	B / A 將得到 2，地板除，21/10=2
%	取模運算符，整除后的余數	B % A 將得到 0
++	自增運算符，整數值增加 1	A++ 將得到 11
--	自減運算符，整數值減少 1	A-- 將得到 9

關系運算符：

假設變量 A 的值為 10，變量 B 的值為 20，則：

運算符	描述	實例
==	檢查兩個操作數的值是否相等，如果相等則條件為真。	(A == B) 不為真。
!=	檢查兩個操作數的值是否相等，如果不相等則條件為真。	(A != B) 為真。
>	檢查左操作數的值是否大於右操作數的值，如果是則條件為真。	(A > B) 不為真。
<	檢查左操作數的值是否小於右操作數的值，如果是則條件為真。	(A < B) 為真。
>=	檢查左操作數的值是否大於或等於右操作數的值，如果是則條件為真。	(A >= B) 不為真。
<=	檢查左操作數的值是否小於或等於右操作數的值，如果是則條件為真。	(A <= B) 為真。

邏輯運算符：

假設變量 A 的值為 1，變量 B 的值為 0，則：

運算符	描述	實例
&&	稱為邏輯與運算符。如果兩個操作數都非零，則條件為真。	(A && B) 為假。
||	稱為邏輯或運算符。如果兩個操作數中有任意一個非零，則條件為真。	(A || B) 為真。
!	稱為邏輯非運算符。用來逆轉操作數的邏輯狀態。如果條件為真則邏輯非運算符將使其為假。	!(A && B) 為真。

位運算符：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

&約等於and，|約等於或，^不同為真

假設如果 A = 60，且 B = 13，現在以二進制格式表示，它們如下所示：

A = 0011 1100    

B = 0000 1101    

-----------------

A&B = 0000 1100    得到十進制12

A|B = 0011 1101    得到61

A^B = 0011 0001    得到49

~A  = 1100 0011    按位取反，得到-61

運算符	描述	實例
&	如果同時存在於兩個操作數中，二進制 AND 運算符復制一位到結果中。	(A & B) 將得到 12，即為 0000 1100
|	如果存在於任一操作數中，二進制 OR 運算符復制一位到結果中。	(A | B) 將得到 61，即為 0011 1101
^	如果存在於其中一個操作數中但不同時存在於兩個操作數中，二進制異或運算符復制一位到結果中。	(A ^ B) 將得到 49，即為 0011 0001
~	二進制補碼運算符是一元運算符，具有"翻轉"位效果，即0變成1，1變成0。	(~A ) 將得到 -61，即為 1100 0011，一個有符號二進制數的補碼形式。
<<	二進制左移運算符。左操作數的值向左移動右操作數指定的位數。	A << 2 將得到 240，即為 1111 0000
>>	二進制右移運算符。左操作數的值向右移動右操作數指定的位數。	A >> 2 將得到 15，即為 0000 1111

賦值運算符

運算符	描述	實例
=	簡單的賦值運算符，把右邊操作數的值賦給左邊操作數	C = A + B 將把 A + B 的值賦給 C
+=	加且賦值運算符，把右邊操作數加上左邊操作數的結果賦值給左邊操作數	C += A 相當於 C = C + A
-=	減且賦值運算符，把左邊操作數減去右邊操作數的結果賦值給左邊操作數	C -= A 相當於 C = C - A
*=	乘且賦值運算符，把右邊操作數乘以左邊操作數的結果賦值給左邊操作數	C *= A 相當於 C = C * A
/=	除且賦值運算符，把左邊操作數除以右邊操作數的結果賦值給左邊操作數	C /= A 相當於 C = C / A
%=	求模且賦值運算符，求兩個操作數的模賦值給左邊操作數	C %= A 相當於 C = C % A
<<=	左移且賦值運算符	C <<= 2 等同於 C = C << 2
>>=	右移且賦值運算符	C >>= 2 等同於 C = C >> 2
&=	按位與且賦值運算符	C &= 2 等同於 C = C & 2
^=	按位異或且賦值運算符	C ^= 2 等同於 C = C ^ 2
|=	按位或且賦值運算符	C |= 2 等同於 C = C | 2

其他運算符：

運算符	描述
sizeof	sizeof 運算符返回變量的大小。例如，sizeof(a) 將返回 4，其中 a 是整數。
Condition ? X : Y	條件運算符。如果 Condition 為真 ? 則值為 X : 否則值為 Y。
,	逗號運算符會順序執行一系列運算。整個逗號表達式的值是以逗號分隔的列表中的最后一個表達式的值。
.（點）和 ->（箭頭）	成員運算符用於引用類、結構和共用體的成員。
Cast	強制轉換運算符把一種數據類型轉換為另一種數據類型。例如，int(2.2000) 將返回 2。
&	指針運算符 & 返回變量的地址。例如 &a; 將給出變量的實際地址。
*	指針運算符 * 指向一個變量。例如，*var; 將指向變量 var。

運算優先級

類別	運算符	結合性
后綴	() [] -> . ++ - -	從左到右
一元	+ - ! ~ ++ - - (type)* & sizeof	從右到左
乘除	* / %	從左到右
加減	+ -	從左到右
移位	<< >>	從左到右
關系	< <= > >=	從左到右
相等	== !=	從左到右
位與 AND	&	從左到右
位異或 XOR	^	從左到右
位或 OR	|	從左到右
邏輯與 AND	&&	從左到右
邏輯或 OR	||	從左到右
條件	?:	從右到左
賦值	= += -= *= /= %=>>= <<= &= ^= |=	從右到左
逗號	,	從左到右

3，循環

while循環和do...while循環：小心死循環

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部變量聲明
   int a = 10;
   // while 循環執行
   while( a < 20 )
   {
       cout << "a 的值：" << a << endl;
       a++;
   }
   return 0;
}

do...while：

#include <iostream>
using namespace std;
int main ()
{
   // 局部變量聲明
   int a = 10;
   // do 循環執行
   do
   {
       cout << "a 的值：" << a << endl;
       a = a + 1;
   }while( a < 20 );
   return 0;
}

for循環：和js，php差不多

#include <iostream>
using namespace std;
 
int main ()
{
   //for 循環執行完了以后會調到緊跟着for循環的語句上去執行
    for( int a = 10; a < 20; a = a + 1 )
   {
       cout << "a 的值：" << a << endl;
   }
 
   return 0;
}

嵌套循環：2到100的質數

#include <iostream>
using namespace std;
 
int main ()
{
    int i, j;
    for(i=2; i<100; i++) {    //i是2-100的數
        for(j=2; j <= (i/j); j++) {    //j是i的除數,而且j只需要比i/j小就行了，這樣可以減少循環次數
            if(!(i%j)) {    //可以整除說明有因數
                break; // 如果找到，則不是質數
            }
        }
        if(j > (i/j)) {    //此處不好描述，我們只需要知道當i=11，j=2時候j大於5就不用繼續找比5大的因數了，因為木有了
            cout << i << " 是質數 \n";
        }
    }
    return 0;
}

4，判斷

 if...else...實例：

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部變量聲明
   int a = 100;
 
   // 檢查布爾條件
   if( a < 20 )
   {
       // 如果條件為真，則輸出下面的語句
       cout << "a 小於 20" << endl;
   }
   else
   {
       // 如果條件為假，則輸出下面的語句
       cout << "a 大於 20" << endl;
   }
   cout << "a 的值是 " << a << endl;
 
   return 0;
}

 swich:

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部變量聲明
   char grade = 'D';
 
   switch(grade)    //以grade作為判斷依據
   {
   case 'A' :
      cout << "很棒！" << endl; 
      break;
   case 'B' :    //此處的意思是B和C都輸出‘做的好’
   case 'C' :
      cout << "做得好" << endl;
      break;
   case 'D' :
      cout << "您通過了" << endl;
      break;
   case 'F' :
      cout << "最好再試一下" << endl;
      break;
   default :
      cout << "無效的成績" << endl;
   }
   cout << "您的成績是 " << grade << endl;
 
   return 0;
}

 三元運算符：

if(y < 10){ 
   var = 30;
}else{
   var = 40;
}
寫成以下語句：
var = (y < 10) ? 30 : 40;
//如果y<10那就讓var=30,否則等於40

5，函數

主函數main(),每個c++程序都有至少一個主函數main

自定義函數：

返回類型    函數名稱（ 參數類型 參數）
{
    函數主體
}

 自定義函數實例：

#include <iostream>
using namespace std;
 
// 函數聲明，this is necessary !
int max(int num1, int num2);
 
int main ()
{
   // 局部變量聲明
   int a = 100;
   int b = 200;
   int ret;
 
   // 調用函數來獲取最大值
   ret = max(a, b);
 
   cout << "Max value is : " << ret << endl;
 
   return 0;
}
 
// 函數返回兩個數中較大的那個數
int max(int num1, int num2) 
{
   // 局部變量聲明
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

函數三種參數調用方式：重點

1，傳值調用：（默認）把變量的實際值賦值給形參

#include <iostream>
using namespace std;

// 函數聲明
int max(int num1);    //注意，此處不提前寫函數聲明會報錯，
int main ()
{
   // 局部變量聲明
   int a = 100;
   int x;
   cout <<"original a is:" << a <<endl;    //原來的a是100
   x = max(a);

   cout << "new value is : " << a<< endl;    //后來的a仍舊是100
   return 0;
}

// 函數返回兩個數中較大的那個數
int max(int num1)
{
    int result=num1++;
    return result;
}

2，指針調用：把變量的地址賦值給形參

#include <iostream>
using namespace std;

// 函數聲明
void swap(int *x, int *y);    //星號大約是表示參數為指針類型

int main ()
{
   // 局部變量聲明
   int a = 100;
   int b = 200;
 
   cout << "交換前，a 的值：" << a << endl;
   cout << "交換前，b 的值：" << b << endl;

   /* 調用函數來交換值
    * &a 表示指向 a 的指針，即變量 a 的地址 
    * &b 表示指向 b 的指針，即變量 b 的地址 
    */
   swap(&a, &b);

   cout << "交換后，a 的值：" << a << endl;
   cout << "交換后，b 的值：" << b << endl;
 
   return 0;
}
//一開始a=100，b=200,后來a為200,1為100

// 函數定義 void swap(int *x, int *y) { int temp; temp = *x;    /* 保存地址 x 的值 */ *x = *y;        /* 把 y 賦值給 x */ *y = temp;    /* 把 x 賦值給 y */ return; }

3，引用調用：把變量的引用的地址賦值給形參

#include <iostream>
using namespace std;
 
// 函數聲明
void swap(int &x, int &y);    //引用用&符號來表示
 //我理解的引用就是，把a的引用賦值給swap的形參，因為引用指向的就是原存儲地址，所以，引用調用實際上也會改變原數據的大小
int main ()
{
   // 局部變量聲明
   int a = 100;
   int b = 200;
 
   cout << "交換前，a 的值：" << a << endl;    //100 200
   cout << "交換前，b 的值：" << b << endl;
 
   /* 調用函數來交換值 */
   swap(a, b);
 
   cout << "交換后，a 的值：" << a << endl;
   cout << "交換后，b 的值：" << b << endl;    //200 100
 
   return 0;
}
// 函數定義
void swap(int &x, int &y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 賦值給 x */
   y = temp; /* 把 x 賦值給 y  */
  
   return;
}

 為函數設置默認值

#include <iostream>
using namespace std;
int sum(int a, int b=20)    //設置默認的參數b為20
{
    int result;
    result=a+b;
    return(result);
}
int main()
{
    int c=100;
    int result;
    result=sum(c);    //a參數是傳進去的值，b參數采用默認
    cout<<result<<endl;
    return 0 ;
}

 lambda匿名函數

這是什么鬼，看了半天也不能理解

 用的時候再看的鏈接