通過這篇文章我們將熟練掌握C語言中的各種運算子，運算式求值是如何使用運算子的，運算式求值該注意一些什么呢？這里概念性的東西比較少，主要是通過代碼演示，會正確使用各種運算子（12815字）

一、運算子

1.算數運算子

2. 移位運算子

左移運算子

右移運算子

3.位運算子

按位與

按位或

按位異或

變態的筆試題

一道筆試題

4. 賦值運算子

5.復合賦值符

6.單目運算子

7.關系運算子

8.邏輯運算子

一道筆試題

9.條件運算子

10.逗號運算式

11. 下標參考、函式呼叫和結構成員

二、運算式求值

隱式型別轉換

整型提升

整型提升的意義

如何進行整型提升

算術轉換

運算子的屬性

復雜運算式的求值有三個影響的因素

錯誤示范

一、運算子

分類：

算術運算子
移位運算子
位運算子
賦值運算子
單目運算子
關系運算子
邏輯運算子
條件運算子
逗號運算式
下標參考、函式呼叫和結構成員

1.算數運算子

+ - * / %

注意：

除了% 運算子之外，其他的幾個運算子都可以作用于整數和浮點數，
% 運算子的兩個運算元必須為整數，回傳的是整除之后的余數

如下代碼：

int main()
{
	3.5 % 2.5;
	return 0;
}

發現編譯器報錯了

3. 對于/ 運算子如果兩個運算元都為整數，執行整數除法，而只要有浮點數執行的就是浮點數除
法

如下代碼：

#include <stdio.h>
int main()
{
	printf("%d\n", 5 / 2);
	printf("%f\n", 5.0 / 2);
	return 0;
}

運行結果：

2. 移位運算子

<< 左移運算子
>> 右移運算子

左移運算子

左邊丟棄，右邊補零

如下代碼：

#include <stdio.h>
int main()
{
	int a = 7;
	int b = a << 1;
	printf("%d\n", b);
	return 0;
}

分析：

要知道移位移的是二進制位

這里的a是整型變數，4個位元組32bit，所以7寫成二進制應該是

00000000000000000000000000000111

向左移動一位，就是左邊丟棄一位，右邊補零

00000000000000000000000000001110

如下圖：

運行結果：

右移運算子

右移操作分為兩種

算數右移----右邊丟棄，左邊補原符號位
邏輯右移----右邊丟棄，左邊補零

邏輯右移和上面的左移操作類似，這邊不再啰嗦

主要看一下算數右移

我們知道，有符數分為正數和負數，它們的符號位分別為：

正數----0

負數----1

也就是說如果正數進行算數右移的話，應該是右邊丟棄，左邊補0

負數進行算數右移的話，應該是右邊丟棄，左邊補1

我們通過以下代碼來驗證一下算數右移

#include <stdio.h>
int main()
{
	int a = -1;
	int b = a >> 1;
	printf("%d\n", b);
	return 0;
}

分析：

這里我們還需要知道的是，整數在記憶體中存放的是二進制，并且是以補碼形式來存的

這里的-1

原碼：10000000000000000000000000000001

反碼：11111111111111111111111111111110

補碼：11111111111111111111111111111111

將它進行算數右移的話就是右邊丟棄，左邊補1

結果：11111111111111111111111111111111

仍然還是-1

運行結果：

也從這里可以看出來我們的編譯器進行的是算數右移

注意：對于移位運算子，不要移動負數位，這個是標準未定義的

如下代碼：

int num = 20;
num >> -1;//

3.位運算子

& //按位與
| //按位或
^ //按位異或

注：他們的運算元必須是整數

按位與

我們來看下面的代碼：

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a & b;
	printf("%d\n", c);
	return 0;
}

分析:

按位與這里的位指的是二進制位

每位數一一對應，全1為1，有0為0

3的二進制為

00000000000000000000000000000011

5的二進制為

00000000000000000000000000000101

然后將3和5對應位相與

結果就是

00000000000000000000000000000001

運行結果：

按位或

有1為1，全0為0

代碼如下：

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a | b;
	printf("%d\n", c);
	return 0;
}

分析：

3的二進制：00000000000000000000000000000011

5的二進制：00000000000000000000000000000101

相或結果就是：00000000000000000000000000000111

結果為7

運行驗證：

按位異或

不同為0，相同為1

代碼如下：

#include <stdio.h>
int main()
{
	int a = 3;
	int b = 5;
	int c = a ^ b;
	printf("%d\n", c);
	return 0;
}

分析：

3的二進制：00000000000000000000000000000011

5的二進制：00000000000000000000000000000101

相異或結果就是：00000000000000000000000000000110

結果為6

運行驗證：

變態的筆試題

題目：不能創建臨時變數（第三個變數），實作兩個數的交換

之前我們實作兩個數的交換都是通過創建第三個變數來實作交換的，如下代碼：

代碼1：

#include <stdio.h>
int main()
{
	int a = 1;
	int b = 2;
	int t = 0;     //創建臨時變數
	t = a;
	a = b;
	b = t;
	printf("a==%d\n", a);
	printf("b==%d\n", b);
}

運行結果：

上面這就是我們通常的操作，但是如果不創建第三個變數，如何做到交換兩數呢？

我們通過異或運算子來達到交換兩數的目的

代碼2：

#include <stdio.h>
int main()
{
		int a = 3;
	    int b = 5;
		printf("a == %d     ", a);
		printf("b == %d\n", b);
		a = a ^ b;
		b = a ^ b;
		a = a ^ b;
		printf("a == %d     ", a);
		printf("b == %d\n", b);
		return 0;
}

運行結果

分析：

如下圖示：

會發現三次異或之后a,b兩數完成了交換

這是為什么呢？

我們可以將第一次a^b的結果110看作是一個密碼，這個密碼和b異或之后翻譯出來的值為011就是原本a的值，再將這個密碼和a異或翻譯出來的值就是原本b的值

相當于是這樣：

a^b^a==b

a^b^b==a

舉例：

011^011==000

000^111==111

兩個相同的數字異或的結果為0，用這個0作為密碼去和其他一個數字異或，結果還是這個數字

所以我們也可以做如下總結：

a^a==0

0^a==a

注意：一般在開發中我們都是用臨時變數的方法來交換兩數

兩種方法比較：

創建臨時變數：代碼可讀性高，代碼執行效率相對較高

異或：代碼可讀性差，代碼執行效率相對較低

一道筆試題

撰寫代碼實作：求一個整數存盤在記憶體中的二進制中1的個數

方法1：

分析：

通過將這個數與1按位與的方法，可以知道這個數最后一位是不是1，然后將這個數右移一位，再繼續使用這種方法來看最后一位是不是1，但這種方法必須是回圈32次（整型32位）

#include <stdio.h>
int main()
{
	int n = 6;
	int i = 0;
	int count = 0;
	for (i = 0; i < 32; i++)
	{
		if (((n >> i) & 1) == 1)
			count++;
	}
	printf("二進制中1的個數 = %d\n", count);
	return 0;
}

運行結果這種方法不論有多少個1，都必須回圈32次，效率較低

方法2：

分析：

先來看看以下幾組計算：

111^110==110 n&(n-1)

110^101==100

100^011==0

可以發現n&(n-1)相當于是把n中最右邊的1給消掉了

那么我們其實就可以通過n=n&(n-1)這樣的方式來求得1的個數，賦值了幾次，1就是幾

#include <stdio.h>
int main()
{
	int n = 6;
	int i = 0;
	int count = 0;
	while (n)
	{
		count++;
		n = n & (n - 1);
	}
	printf("二進制中1的個數 = %d\n", count);
	return 0;
}

運行結果：

4. 賦值運算子

相信經過一段時間的學習，對賦值操作已經有了一定的了解，這里再啰嗦兩句

1.賦值運算子可以連續使用

int main()
{
	int a = 1;
	int b = 2;
	int x = b = a;   //連續賦值
}

但是建議不要出現這種寫法，這種不便于除錯與閱讀

以下的代碼更易除錯

int main()
{
	int a = 1;
	int b = 2;
	int x = 0;
	b = a;
	x = b;
}

5.復合賦值符

+=
-=
*=
/=
%=
>>=
<<=
&=
|=
^=

將運算運算子寫成了復合的形式，這樣寫更加簡潔

如下示例：

a = a + 3;
a += 3;
b = b / 3;
b /= 3;
c = c % 2;
c %= 2;
d = d >> 1;
d >>= 1;
e = e & 1;
e &= 1;

6.單目運算子

我們通過前面的學習會發現+，-等這些運算子都是有兩個運算元，稱為雙目運算子，那么這里的單目運算子就是只有一個運算元的運算子

! 邏輯反操作
- 負值
+ 正值
& 取地址
sizeof 運算元的型別長度（以位元組為單位）
~ 對一個數的二進制按位取反
-- 前置、后置--
++ 前置、后置++
* 間接訪問運算子(解參考運算子)
(型別) 強制型別轉換

1.邏輯反操作！將一個數或運算式的真值改變，原來為假，進行邏輯反操作之后變為真

int main()
{
	int a = 5;
	int b = 0;
	printf("a == %d\n", a);
	printf("!a == %d\n", !a);
	printf("b == %d\n", b);
	printf("!b == %d\n", !b);
	return 0;
}

運行結果：

注意在C語言里面 非0表示真，0表示假

使用如下示例：

#include <stdio.h>
int main()
{
	int exp = 0;
	if (!exp)
	{
		printf("hello\n");
	}
	return 0;
}

分析：

這里exp原本是0，0表示假，在if陳述句的判斷中，!exp將exp的真值變為真，所以就會執行if陳述句里面的陳述句，列印hello

運行結果：

2.取地址運算子 &

這個運算子用來取出變數的地址

如下代碼

int main()
{
	int a = 10;
	int* pa = &a;    //創建指標變數將a的地址存進去
	*pa = 15;
	printf("%d\n", a);
	return 0;
}

分析：

這段代碼中我們通過&a拿到a的地址并將其存進指標變數pa里面，然后通過解參考運算子 * 將pa所指向的物件內容修改為15

運行結果：

指標圖示：

3.sizeof

可能很多人都把sizeof當作函式了，但其實sizeof是一個運算子，不是函式，可以用來計算型別的大小

如下代碼：


int main()
{
	int a = 5;
	int arr[10] = { 0 };
	printf("%d\n", sizeof a);   //通過變數名來計算的時候sizeof的括號可以省略
	printf("%d\n", sizeof(arr));
	printf("%d\n", sizeof(int[10]));    //這兩種方式都能用來計算陣列的大小，陣列名去掉就是陣列的型別
	return 0;
}

運行結果：

注意第二種求陣列大小的方法---陣列名去掉就是陣列的型別

4. ~ 這是對一個數的二進制位按位取反

如下代碼：

#include <stdio.h>
int main()
{
	int a = 0;
	//分析：
	//a的原碼：00000000000000000000000000000000
	//補碼：   00000000000000000000000000000000
	//按位取反 11111111111111111111111111111111
	//反碼；   11111111111111111111111111111110
	//原碼：   10000000000000000000000000000001
	//所以結果應該是-1
	printf("%d\n", ~a);
}

運行結果：

5.自增，自減運算子

#include <stdio.h>
int main()
{
	int a = 0;
	int b = a++;    //后置++，先使用a的值，然后再讓a加1
	int c = 1;
	int d = ++c;    //前置++，先讓c加1，然后再把c的值賦給d
	printf("a=%d,b=%d\n",a,b);
	printf("c=%d,d=%d\n", c, d);
}

注意自增運算子是帶有副作用的

如下代碼：想要讓b實作a+1的效果

int main()
{
	int a = 15;
	int b = 0;
	b = a + 1;   // 方法1
	//b = ++a;        //方法2
}

這兩種方法都可以讓b達到a+1的效果，但是第二種方法產生副作用，讓a的值也自增了1

6.強制型別轉換運算子

如下代碼：

3.14是double型別的，將double型別的資料賦給int型別，我們發現編譯器報了一個警告

那么我們應該怎么解決呢？這個時候就可以用強制型別轉換，將3.14強制轉換成整型

#include <stdio.h>
int main()
{
	int a = (int)3.14;
	return 0;
}

7.關系運算子

>
>=
<
<=
!= 用于測驗“不相等”
== 用于測驗“相等”

注意：

>=，<=，!=，==這幾個由兩個符號組成的運算子中間不能有空格
等于==和賦值=分清楚

8.邏輯運算子

&& 邏輯與
|| 邏輯或

邏輯運算子只關心運算元的真偽

1.邏輯與 && ，如果兩邊的值都為真，那么結果為真，如果其中有一個為假，那么結果為假

2.邏輯或 || ，如果兩邊有一個值為真，那么結果為真，如果兩個都為假，那么結果為假

代碼演示：

#include <stdio.h>
int main()
{
	int a = 5;
	int b = 3;
	int c = 0;
	int d = 0;
	printf("%d,%d\n", a && b, a && c);
	printf("%d,%d\n", a || b, d || c);
}

運行結果：

現在再看一下我們之前遇到過的一個問題：

判斷年齡在18--30之間的為青年

#include <stdio.h>
int main()
{
	int age = 0;
	printf("請輸入年齡\n");
	scanf("%d", &age);
	if (18 <= age <= 30)
	{
		printf("青年人\n");
	}
	return 0;
}

發現當輸入70的時候仍然能夠列印成年人

主要就是在if里面如果要這樣判斷一個范圍的話不能這樣用，而應該用邏輯與&&

一道筆試題

#include <stdio.h>
int main()
{
	int i = 0, a = 0, b = 2, c = 3, d = 4;
	i = a++ && ++b && d++;
	printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
    i = a++||++b||d++;
	printf("a = %d\n b = %d\n c = %d\nd = %d\n", a, b, c, d);
	return 0;
}

想想這道題的列印結果是什么呢？是2 3 3 5嗎？

分析：

要知道，在邏輯與&&運算中，只要有一個為假，則整體為假，這個式子中a++的值為0，為假，右邊就不用再算了，不需要把所有式子都算完，所以第一個printf的結果應該是1 2 3 4

第二個運算的式子中a++值為1，為真，后面的幾個就不需要再算了，直接整體為真，第二個printf的列印結果應該是

總結：

邏輯與 && 來說，如果左邊為0，右邊就不用再算了

邏輯或 || 來說，左邊如果為1，右邊就不需要再算了

9.條件運算子

這里的條件運算子有三個運算元，所以也叫三目運算子，exp1 ? exp2 : exp3

含義：運算式1的結果如果為真，就執行運算式2，如果運算式1的結果為假，就執行運算式3

我們之前寫代碼求兩個數的最大值都是通過if陳述句來判斷，現在我們完全可以通過條件運算子來計算，可以極大的簡化代碼
通過以下兩段代碼的對比來體驗一下：

代碼1：

int main()
{
	int a = 1;
	int b = 2;
	int max = 0;
	if (a > b)
	{
		max = a;
	}
	else
	{
		max = b;
	}
	return 0;
}

代碼2：

int main()
{
	int a = 1;
	int b = 2;
	int max = 0;
	a > b ? a : b;
	return 0;
}

這兩段代碼實作的是同樣的功能，但明顯可以發現代碼2比代碼1簡潔很多

10.逗號運算式

逗號隔開的一串運算式，逗號運算式的結果從左向右依次計算，但運算式的結果是最后一個運算式的結果

int main()
{
	int a = 1;
	int b = 2;
	int c = (a > b, a = b + 10, a, b = a + 1);//逗號運算式
	printf("%d\n", c);
	return 0;
}

執行完之后c的值是多少呢？

分析：

整個逗號運算式中，從左向右依次計算，首先a>b進行了判斷，不產生結果，然后a=b+10，a變成了12，再執行了a,不產生結果，b=a+1執行之后，b的值變成了13，所以c的值為13

11. 下標參考、函式呼叫和結構成員

1. [ ] 下標參考運算子

運算元：一個陣列名 + 一個索引值

這個下標參考運算子在學陣列的時候就已經很了解了，這里主要再說一下它的一些其他使用方式

#include <stdio.h>
int main()
{
	int arr[5] = { 4,3,2,1,0 };
	printf("%p\n", arr + 4);    //陣列名表示首元素地址
	printf("%p\n", &arr[4]);
	printf("%d\n", *(arr + 4));
	printf("%d\n", arr[4]);
	printf("%d\n", 4[arr]);
	return 0;
}

注意最后一種寫法

2.( ) 函式呼叫運算子

我們平時在呼叫函式的時候必須要有這個圓括號，不能省略，里面可以放函式的引數

3.訪問一個結構體的成員

C語言里面有兩種方式可以訪問結構體成員，一個是

結構體變數.結構體成員

結構體指標->結構體成員

我們可以通過以下代碼再來體驗一下

#include <stdio.h>
struct Peo
{
	char name[20];
	int age;
};
int main()
{
	struct Peo p = { "張三",18 };    //創建結構體變數并初始化
	struct Peo* ps = &p;     //創建一個結構體指標
    //結構體變數.結構體成員
	printf("姓名:%s  年齡:%d", p.name, p.age);       //用.來訪問
    //結構體指標->結構體成員
	printf("姓名:%s  年齡:%d", ps->name, ps->age);    //用指標訪問
	return 0;
}

二、運算式求值

運算式求值的順序一部分是由運算子的優先級和結合性決定,同樣，有些運算式的運算元在求值的程序中可能需要轉換為其他型別

隱式型別轉換

偷偷進行型別的轉換（并不會直觀的展現出來）

整型提升

C的整型算術運算總是至少以預設整型型別的精度來進行的，
為了獲得這個精度，運算式中的字符和短整型運算元在使用之前被轉換為普通整型，這種轉換稱為整型提升

運算式中可以使用整數的地方，就可以使用列舉型別，或有符號或無符號的字符、短整數、整數位域，如果一個int可以表示上述型別，則該值被轉化為int型別的值；否則，該值被轉化為unsigned int型別的值，這一程序被稱作integral promotion，

整型提升的意義

運算式的整型運算要在CPU的相應運算器件內執行，CPU內整型運算器(ALU)的運算元的位元組長度
一般就是int的位元組長度，同時也是CPU的通用暫存器的長度，

因此，即使兩個char型別的相加，在CPU執行時實際上也要先轉換為CPU內整型運算元的標準長
度，

通用CPU（general-purpose CPU）是難以直接實作兩個8位元位元組直接相加運算（雖然機器指令
中可能有這種位元組相加指令），所以，運算式中各種長度可能小于int長度的整型值，都必須先轉
換為int或unsigned int，然后才能送入CPU去執行運算，

如何進行整型提升

我們通過下面的例子來說明

#include <stdio.h>
int main()
{
	char a = 3;
	char b = 127;
	char c = a + b;
	printf("%d\n", c);
	return 0;
}

分析：

這里的char c = a + b這句執行的時候會發生整型提升

首先a和b要進行加法運算，a和b都要提升為整型

a和b原本為char型別，8bit

00000011-----a

01111111-----b

進行整型提升，因為 char 為有符號的 char，所以整形提升的時候，高位補充符號位，即為0

00000000000000000000000000000011-----a提升后

00000000000000000000000001111111-----b提升后

00000000000000000000000010000010-----相加結果

要賦給c，但c是char型別，只能存8位，存進去的應該是

10000010-----c里面

在進行列印的時候%d以整型進行列印，這里還要發生整型提升char 為有符號的 char，所以整形提升的時候，高位補充符號位

11111111111111111111111110000010-----c提升之后的補碼

11111111111111111111111110000001-----c提升之后的反碼

10000000000000000000000001111110-----c提升之后的原碼

為-126

運行結果：

算術轉換

參與運算的運算元型別大于int

如果某個運算子的各個運算元屬于不同的型別，那么除非其中一個運算元轉換為另一個運算元的型別，否則操作就無法進行，下面的層次體系稱為尋常算術轉換

long double
double
float
unsigned long int
long int
unsigned int
int

如果某個運算元的型別在上面這個串列中排名較低，那么首先要轉換為另外一個運算元的型別后執行運算

注意：算術轉換要合理，要不然會有一些潛在的問題（精度丟失等）

運算子的屬性

復雜運算式的求值有三個影響的因素

運算子的優先級
運算子的結合性
是否控制求值順序

注意：兩個相鄰的運算子先執行哪個？取決于他們的優先級，如果兩者的優先級相同，取決于他們的結合性

運算子優先級
運算子	描述	用法示例	結果型別	結合性	是否控制求值順序
（）	聚組	（運算式）	與表達式同	N/A	否
（）	函式呼叫	rexp（rexp，...,rexp）	rexp	L-R	否
[ ]	下標參考	rexp[rexp]	lexp	L-R	否
.	訪問結構體成員	lexp.member_name	lexp	L-R	否
->	用指標訪問結構體成員	rexp->member_name	lexp	L-R	否
++	后綴自增	lexp ++	rexp	L-R	否
--	后綴自減	lexp --	rexp	L-R	否
!	邏輯反	! rexp	rexp	R-L	否
~	按位取反	~ rexp	rexp	R-L	否
+	單目，表示正值	+ rexp	rexp	R-L	否
-	單目，表示負值	- rexp	rexp	R-L	否
++	前綴自增	++ lexp	rexp	R-L	否
--	前綴自減	-- lexp	rexp	R-L	否
*	間接訪問	* rexp	lexp	R-L	否
&	取地址	& lexp	rexp	R-L	否
sizeof	取其長度，以位元組表示	sizeof rexp sizeof(型別）	rexp	R-L	否
(類型）	型別轉換	(型別) rexp	rexp	R-L	否
*	乘法	rexp * rexp	rexp	L-R	否
/	除法	rexp / rexp	rexp	L-R	否
%	整數取余	rexp % rexp	rexp	L-R	否
+	加法	rexp + rexp	rexp	L-R	否
-	減法	rexp - rexp	rexp	L-R	否
<<	左移位	rexp << rexp	rexp	L-R	否
>>	右移位	rexp >> rexp	rexp	L-R	否
>	大于	rexp > rexp	rexp	L-R	否
>=	大于等于	rexp >= rexp	rexp	L-R	否
<	小于	rexp < rexp	rexp	L-R	否
<=	小于等于	rexp <= rexp	rexp	L-R	否
==	等于	rexp == rexp	rexp	L-R	否
!=	不等于	rexp != rexp	rexp	L-R	否
&	按位與	rexp & rexp	rexp	L-R	否
^	按位異或	rexp ^ rexp	rexp	L-R	否
\|	按位或	rexp \| rexp	rexp	L-R	否
&&	邏輯與	rexp && rexp	rexp	L-R	是
\|\|	邏輯或	rexp \|\| rexp	rexp	L-R	是
? :	條件運算子	rexp ? rexp : rexp	rexp	N/A	是
=	賦值	lexp = rexp	rexp	R-L	否
+=	以...加	lexp += rexp	rexp	R-L	否
-=	以...減	lexp -= rexp	rexp	R-L	否
*=	以...乘	lexp *= rexp	rexp	R-L	否
/=	以...除	lexp /= rexp	rexp	R-L	否
%=	以...取模	lexp %= rexp	rexp	R-L	否
<<=	以...左移	lexp <<= rexp	rexp	R-L	否
>>=	以...右移	lexp >>= rexp	rexp	R-L	否
&=	以...與	lexp &= rexp	rexp	R-L	否
^=	以...異或	lexp ^= rexp	rexp	R-L	否
\|=	以...或	lexp \|= rexp	rexp	R-L	否
，	逗號	rexp，rexp	rexp	L-R	是

錯誤示范

示范1：

a*b + c*d + e*f

這是一個有問題的代碼

分析：

我們都知道 * 優先級比 + 高，但是存在的問題是：

這三個乘號誰先算
第三個*和第一個＋誰先算

出現多種計算方式

示范2：

c + --c;

分析：

這個運算式先算＋還是先算--可以由優先級來確定

存在的問題是誰先準備好

到底是先準備好c還是先準備好--c,這是很重要的

有以下兩種
int c = 2;
c + --c;
//先算--c
//--c執行后c是1
//運算式就是1 + 1
2.
int c = 2;
c + --c;
//先準備好c
//整個運算式就成了2 + 1
這兩種計算出來的結果是不一樣的

示范3：

#include <stdio.h>
int main()
{
	int i = 10;
	i = i-- - --i * (i = -3) * i++ + ++i;
	printf("i = %d\n", i);
	return 0;
}

這段代碼來源于《C和指標》

作者將這段代碼在11種不同的編譯器中編譯出來的結果都是不一樣的

示范4

#include <stdio.h>
int fun()
{
	static int count = 1;
	return ++count;
}
int main()
{
	int answer;
	answer = fun() - fun() * fun();
	printf("%d\n", answer);//輸出多少？
	return 0;
}

這段代碼的執行結果是什么呢？

分析：

這段代碼中的answer = fun() - fun() * fun();這個運算式是個問題運算式，我們只能知道先算*再算-，但到底先呼叫哪個fun()是不確定的

注意：我們寫出的運算式如果不能通過運算子的屬性確定唯一的計算路徑，那這個運算式就是存在問題的，

雖然已經掌握了運算子的優先級，結合性，以及控制求值順序這些屬性，但還是沒有辦法確定出每個運算式的唯一求值方式，由此可見我們平時在寫代碼的時候應該要避免寫出問題運算式，寫出的運算式要由唯一確定的計算路徑

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

-------------------------C語言運算子部分完結-----------------------------

關于C語言，每個知識點后面都會單獨寫博客更加詳細的介紹

歡迎大家關注！！！

一起學習交流！！！

讓我們將編程進行到底！！！

--------------整理不易，請三連支持------------------

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/301459.html

標籤：其他

上一篇：專業不對口跨行做了功能測驗的我，100天我是如何從菜鳥快速成長為自動化測驗工程師的？

下一篇：30個Python小游戲，上班摸魚我能玩一天【內附原始碼】

【C語言】??運算子詳解??（詳細講解+代碼演示+圖解）

一、運算子

1.算數運算子

2. 移位運算子

左移運算子

右移運算子

3.位運算子

按位與

按位或

按位異或

變態的筆試題

一道筆試題

4. 賦值運算子

5.復合賦值符

6.單目運算子

7.關系運算子

8.邏輯運算子

一道筆試題

9.條件運算子

10.逗號運算式

11. 下標參考、函式呼叫和結構成員

二、運算式求值

隱式型別轉換

整型提升

整型提升的意義

如何進行整型提升

算術轉換

運算子的屬性

復雜運算式的求值有三個影響的因素

錯誤示范