運算子

一、算術運算子

1. ＋ 加法運算子

   把兩個運算元相加

   int c = 21+10;	//c = 31
   

2. － 減法運算子

   第一個運算元減去第二個運算元

   int a = 21-10;	//a = 11
   

3. * 乘法運算子

   把兩個運算元相乘

   int b = 21*10;	//b = 210
   

4. / 除法運算子

   把兩個運算元相除

   / 運算元均為整數，結果為取商并取整

   int d = 16/5;	//d = 3
   

   / 運算元中有一或兩個浮點數，結果為取商

   double e = 16/5;	//e = 3.200000
   

5. % 取模運算子

   整除后的余數運算元都必須為整數，結果取余
   注意：“余數”符號和左邊運算元相同

   int b = 7%3;	//b = 1
   int c = -7%3;	//c = -1
   int e = 7%-3;	//e = 1
   

6. ++自增運算子

   • 前綴++a

       i = 5；  ++i;  	//i = 6;  ++i = 6;
     

   • 后綴a++

       i = 5;   i++;		//i = 6;  i++ = 5;`
     

     int a = ++i;
     int b = i++;
     前綴——先自增后賦值，后綴——先賦值后自增

7. —-自減運算子

   • 前綴—a

      i = 5；  —i;   //i=4;  —i=4;
     

   • 后綴a—

      i = 5;   i—;   //i=4;  i—=5;`
     

     int a = --i;
     int b = i–;
     前綴——先自減后賦值，后綴——先賦值后自減

二、關系運算子

關系運算子的結果是邏輯值（真or假）

1. == 等于

   判斷兩個運算元是否相等，如果相等，條件運算式為真，不相等則為假，

   例：
   5 == 3; 假
   5 == 5; 真

2. != 不等于

   判斷兩個運算元是否不相等，如果不相等，條件運算式為真，相等則為假，

3. > 大于

   左運算元是否大于右運算元，如果是，條件運算式為真

4. < 小于

   左運算元是否小于右運算元，如果是，條件運算式為真

5. >= 大于等于

   左運算元是否大于等于右運算元，如果是，條件運算式為真

6. <= 小于等于

   左運算元是否小于等于右運算元，如果是，條件運算式為真

三、邏輯運算子

邏輯運算子的運算元只能由邏輯值來充當

0 ——表示邏輯假； 1 (非0值) ——表示邏輯真

1. && 邏輯與

   如果兩個運算元都非零，則結果為真

   短路原則：當&&左邊的運算元是假，則右邊運算式就不需要進行判斷，運算結果為假

   int a = (12==8 && 4/2==2);	//a = 0
   

2. || 邏輯或

   兩個運算元都為0，結果為假

   短路原則：當||左邊的運算元是真，則右邊運算式就不需要進行判斷，運算結果為真

   int x = 1,y = 1; 
   int t = ++x || ++y;
   /*
   結果是t = 1, x = 2, y = 1
   因為++x為真，運算式 ++x || ++y 的結果為真，不用計算++y
   */
   

3. ！ 邏輯非

   逆轉運算元狀態，使真變為假，假變為真，

   a=1;	//!a為假
   

四、位運算子

（計算機先將輸入的十進制數，轉換成二進制補碼，再進行位運算，然后將二進制結果轉換成十進制）
在計算機中操作的是補碼
作用于位，逐位進行操作（）

以3，5與運算為例演示逐位運算：

真值表：

例：a = 60； b = 13；
二進制補碼： a = 00111100； b = 00001101；

正整數的補碼與原碼相同，負整數的補碼是將原碼除符號位外的所有位取反后加1
······································································································································

1. & 與運算子

   按”位與“操作，按二進制位進行”與“運算，

   都1才1 1&1 = 1

   a&b = 00001100
   

2. | 或運算子

   按”位或“操作，按二進制位進行”或“運算，

   都0才0 0|0 = 0

   a|b = 00111101
   

3. ^異或運算子

   按二進制位進行”異或“運算，

   相同為0，不同為1
   1^0=1； 1^1=0； 0^0=0

   a^b = 00110001
   

4. ~ 取反運算子

   按二進制位進行”取反“運算，

   按位取反：二進制每一位取反，0變1，1變0，

   對所有整數取反=本身的相反數-1

   計算步驟：（~b為例）二進制數在記憶體中以補碼的形式存盤，

   轉二進制：00001101

   計算補碼：00001101

   按位取反：11110010

   轉為原碼：10001110（負整數反碼轉原碼，將反碼減1后除符號位外的所有位取反）

   符號位為1是負數，即-14

5. << 二進制左移運算子

   將一個運算物件的各二進制位全部左移若干位（左邊的二進制位丟棄，右邊補0），

   a<<2   
   00111100 → 11110000
   

6. >> 二進制右移運算子

   將一個數的各二進制位全部右移若干位，正數左補0，負數左補1，右邊丟棄，

   a>>2   
   00111100 → 00001111
   

五、賦值運算子

給變數賦值

基本賦值運算子

= 把右邊運算元的值賦給左邊運算元（符號=的左邊該是一個可修改的變數名，而右邊是賦給該變數的值，）

int a = 12;

復合賦值運算子

+= 加且賦值運算子

把右邊運算元加上左邊運算元的結果賦值給左邊運算元

a += 12; //→ a = a+12;

-= 減且賦值運算子

把左邊運算元減去右邊運算元的結果賦值給左邊運算元

a-=12; //→ a = a-12;

*= 乘且賦值運算子

把右邊運算元乘以左邊運算元的結果賦值給左邊運算元

a *= 12; //→ a = a*12;

/= 除且賦值運算子

把左邊運算元除以右邊運算元的結果賦值給左邊運算元

a /= 12; //→ a = a/12;

%= 求模且賦值運算子

求兩個運算元的模賦值給左邊運算元

a %= 12; //→ a = a%12;

<<= 左移且賦值運算子

a <<= 2; //→ a = a<<2;

>>= 右移且賦值運算子

a >>= 2; → a = a>>2;

&= 按位與且賦值運算子

a &= 2; //→ a = a&2;

^= 按位異或且賦值運算子

a ^= 2; //→ a = a^2;

|= 按位或且賦值運算子

a |= 2; //→ a = a|2;

六、其他運算子

1. ? :條件運算子(三元運算子)

   先判斷？前面的條件運算式的邏輯值，如果為真，結果為？后面的運算式的運算結果；如果為假，則結果是：后面的運算式的運算結果，

   x>y ? x : y

   若x>y,則結果為x

   若x<y,則結果為y

2. & 取地址運算子

   回傳變數的地址

   求某個變數的地址，如scanf()中的&a表示求a的記憶體空間地址，

   int a;
   scanf("%d",&a);
   

3. *指標運算子

   指向一個變數

   求某個記憶體地址中的資料，

   int* a;
   int var=20;
   a = &var;
   printf("%d",*a);	//結果為20
   

4. ,逗號運算子

   當順序點用，結合順序是從左至右按順序求值，完畢后，整個運算式的值是最后一個運算式的結果，

   a=(12+6,7/8,9+3);
   //結果：a=12;
   

5. sizeof()求位元組數運算子

   回傳變數的大小，用于求一個物件或者型別所占的記憶體位元組數，

   • 語法：sizeof有兩種語法：

     sizeof(type_name); //sizeof(型別);
sizeof object; //sizeof物件

     例：

     sizeof(int) = 4;
     

   • 當為陣列的時候，sizeof的值=陣列元素型別 x 元素個數；

     例:

     int a[2] = {0,1};  
     sizeof(a);	//4x2=8;
     

   • 總結
     sizeof(陣列): 分配的陣列空間大小；
     sizeof(指標): 該指標所用的空間大小（在32位系統是4，在64系統是8）；
     sizeof(型別): 該型別所占的空間大小；
     sizeof(物件): 物件的實際占用空間大小；
     sizeof(函式): 函式的回傳型別所占的空間大小，函式的回傳型別不能是void

   • sizeof()和strlen()的區別：

     1. sizeof求的是占用記憶體的大小，strlen求的是字串的實際長度；（sizeof統計’\0’，strlen不統計’\0’）
     2. sizeof是運算子，strlen是函式;
     3. sizeof可以用型別做引數，strlen只能用char*做引數，且必須是以’’\0’'結尾的;(sizeof還可以用函式做引數)
     4. 陣列作為引數傳給函式時傳的是指標而不是陣列，傳遞的是陣列的首地址，

   • 特點

     1、sizeof是運算子，不是函式，sizeof以byte為單位回傳運算元的大小，

     2、sizeof不能求得 void 型別的長度，

     3、sizeof能求得 void * 型別的長度，

     4、sizeof能求得靜態分配記憶體的陣列的長度，

     5、sizeof不能求得動態分配的記憶體的大小!

     6、sizeof不能對不完整的陣列求長度！

     7、當運算式作為sizeof的運算元時，它回傳運算式的計算結果的型別大小，但是它不對運算式求值！

     8、sizeof可以對函式呼叫求大小，并且求得的大小等于回傳型別的大小，但是不執行函式體，

     9、sizeof求得的結構體(及其物件)的大小并不等于各個資料成員物件的大小之和！

     10、sizeof不能用于求結構體的位域成員的大小，但是可以求得包含位域成員的結構體的大小！

6. (型別)強制型別轉換運算子

   一般形式：（型別名）（運算式\常量\變數）

   例：

   (int)(x+y）	//將x+y的值轉換為整型
   
   (float)(5%3) 	//將5%3的值轉換成單精度型
   

   注意：

   • (int)(x+y)與(int)x+y 意義不同,前者先做x+y操作再轉換，后者先轉換x型別再+y

   • 型別轉換得一個中間值，原變數型別沒有發生變化，

     例：

     double a = 4.6;
     int b = (int)a;
     printf("a=%lf,b=%d", a, b);		//結果：a=4.600000,b=4`
     

7. [] 下標運算子

   具有兩個運算元的雙目運算子，

   • 指向Type型物件的指標
   • 整數類資料型別下標運算子[ ]的運算元的順序是隨意的，
   • 下標運算子所生成的值的型別是 Type型

   a[5] = 4;
   int b[10] = {0};
   double c[2][2] = {1.0,2.0,3.0,4.0};
   

8. () 函式呼叫運算子

   return_type function_name**(** parameter list )

   void example();	//無回傳型別,無形參
   int student( int id, char sex );	//int回傳型別,有形參
   

9. _>間接成員運算子

   _> 用于結構體指標，指向該結構的指標訪問結構的成員

   如

   struct Books *struct_pointer;	//定義結構體指標
   struct_pointer -> title;	//指標指向結構體成員title
   

10. . 結構體訪問成員運算子

    . 用來訪問結構體，共用體中的成員

    訪問成員的一般形式是： 結構變數名 . 成員名

    student.pwd = 12345;	//訪問student結構體成員pwd，并賦值