- ??個人主頁：庫庫的里昂
- ??CSDN新晉作者
- ??歡迎 ??點贊?評論?收藏
- ?系列專欄C語言初階、代碼小游戲
- ??希望作者的文章能對你有所幫助，有不足的地方請在評論區(qū)留言指正，大家一起學習交流！??
【前言】
- 操作符的種類比較多，也是我們在敲代碼過程中很常用的知識點，里面有很多重點內容和易錯的地方，所以還請大家要十分專注，不要遺漏任何一處！
- 希望通過這篇博客，你能夠有所收獲，能夠得到進一步的提升，這才是最主要的！下面讓我們來一起看一看吧。??
一、算術操作符（）
+ - * / %
加 減 乘 除 余
這里重點介紹 / 和 %
1.除號 /
對于 / 操作符如果兩個操作數(shù)都為整數(shù)，執(zhí)行整數(shù)除法。而只要有浮點數(shù)執(zhí)行的就是浮點數(shù)除法。
代碼示例：
#include<stdio.h>
int main()
{
int m = 7 / 2;
double n = 7.0 / 2.0;
printf("m=%d\n", m);
printf("n=%lf\n", n);
return 0;
}
代碼結果：
m=3
n=3.500000
2.取余 %
- % 操作符的兩個操作數(shù)必須為整數(shù)。返回的是整除之后的余數(shù)。
- 除了 % 操作符之外，其他的幾個操作符可以作用于整數(shù)和浮點數(shù)。
代碼示例：
#include<stdio.h>
int main()
{
int m = 7 % 2;
printf("m=%d",m);
return 0;
}
運行結果：
m=1
二、移位操作符
左移操作符：<<
右移操作符：>>
注：
- 移位操作符的操作數(shù)只能是整數(shù)。
- 對于移位操作符，不要移動負數(shù)位，這個是標準為定義的
代碼示例：
int a = 10;
int b = a >> -2;//error
那移位操作符怎么移位的呢？
其實"位"是指二進制位,所以移位操作符是指移動一個數(shù)的二進制位.
說到二進制數(shù)，就不得不提到三種表示形式：原碼、補碼、反碼
那原碼、補碼、反碼的二進制表示形式是什么呢？
首先，無論是原碼反碼還是補碼，它們都是由符號位和數(shù)值位組成的，一般將最高位作為符號位，用‘0’表示正數(shù)，‘1’表示負數(shù)。
1.原碼
正數(shù)
5
二進制表示：00000101
原碼：00000000 00000000 00000000 00000101
負數(shù)
-5
二進制表示：10000101
原碼：10000000 00000000 00000000 00000101
2.反碼
正數(shù)的反碼和原碼相等
負數(shù)：原碼除符號位全部變成相反數(shù)（0-1）
-5
反碼11111111 11111111 11111111 11111010
3.補碼
正數(shù)的原碼、反碼、補碼相等
負數(shù)：在反碼的基礎上加1
-5
補碼：11111111 11111111 11111111 11111011
4.左移操作符
移位規(guī)則：
左邊拋棄、右邊補0
正數(shù)
代碼示例：
#include<stdio.h>
int main()
{
int m = 10;
//原碼：00000000 00000000 00000000 00001010
int n = m << 1;
printf("n=%d",n);
return 0;
}
代碼結果：
n=20
結果分析：
原碼: 00000000000000000000000000001010
移動后的補碼: 00000000000000000000000000000101 0
如圖所示，m向左偏移1位相當于其原碼向左移動一位，移出去的0去掉，在右邊補上個0，因為正數(shù)的原碼、反碼、補碼相同，所以移位后的補碼為0000 0000 00000000 00000000 00010100
化為十進制數(shù)為20
負數(shù)
代碼示例：
#include<stdio.h>
int main()
{
int m = -10;
//原碼：10000000 00000000 00000000 00001010
int n = m << 1;
printf("n=%d",n);
return 0;
}
代碼結果：
n=-20
結果分析：
原碼：10000000000000000000000000001010
反碼：11111111111111111111111111110101
補碼：11111111111111111111111111110110
移動后的補碼： 11111111111111111111111111110110 0
反碼：11111111111111111111111111111011
原碼：10000000000000000000000000000100
如圖所示，m向左偏移1位相當于其原碼向左移動一位，移出去的1去掉，在右邊補上個0，算得移動后的原碼為10000000000000000000000000000100
化為10進制數(shù)是**-20**
5.右移操作符
移位規(guī)則：
首先右移運算分兩種：
1. 邏輯移位
左邊用0填充，右邊丟棄
2. 算術移位（常用）
左邊用原該值的符號位填充，右邊丟棄
正數(shù)
邏輯移位
代碼示例：
#include<stdio.h>
int main()
{
int m = 10;
//原碼：00000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d",n);
return 0;
}
代碼結果：
n=5
結果分析：
10原碼：00000000000000000000000000001010
移動后的補碼： 00000000000000000000000000000101 0
如圖所示，m向右偏移1位相當于其原碼向右移動一位，移出去的0去掉，在左邊補上個0，因為正數(shù)的原碼、反碼、補碼相同，所以移動后的原碼為：00000000000000000000000000000101
化為10進制數(shù)是5
算術移位
代碼示例：
#include<stdio.h>
int main()
{
int m = 10;
//原碼：00000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d",n);
return 0;
}
代碼結果：
n=5
結果分析：
10原碼：00000000000000000000000000001010
移動后的補碼： 00000000000000000000000000000101 0
如圖所示，m向右偏移1位相當于其原碼向右移動一位，移出去的0去掉，在左邊補上個0，因為正數(shù)的原碼、反碼、補碼相同，所以移動后的原碼為：00000000000000000000000000000101
化為10進制數(shù)是5
總結：正數(shù)的邏輯移位和算術移位的結果相等
負數(shù)
邏輯移位
代碼示例：
#include<stdio.h>
int main()
{
int m = -10;
//原碼：10000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d", n);
return 0;
}
代碼結果：
n=5
結果分析：
-10原碼：10000000000000000000000000001010
反碼：11111111111111111111111111110101
補碼：11111111111111111111111111110110
移動后的補碼： 01111111111111111111111111111011 0
反碼：01111111111111111111111111111010
原碼：00000000000000000000000000000101
如圖所示，m向右偏移1位相當于其原碼右移動一位，移出去的0去掉，在左邊邊補上個0，算得移動后的原碼為00000000000000000000000000000101
化為10進制數(shù)是5
算術移位
代碼示例：
#include<stdio.h>
int main()
{
int m = -10;
//原碼：10000000 00000000 00000000 00001010
int n = m >> 1;
printf("n=%d", n);
return 0;
}
代碼結果：
n=-5
結果分析：
-10原碼：10000000000000000000000000001010
反碼：11111111111111111111111111110101
補碼：11111111111111111111111111110110
移動后的補碼： 11111111111111111111111111111011 0
反碼：11111111111111111111111111111010
原碼：10000000000000000000000000000101
如圖所示，m向右偏移1位相當于其原碼右移動一位，移出去的0去掉，在左邊邊補上個1，算得移動后的原碼為10000000000000000000000000000101
化為10進制數(shù)是**-5**
總結：負數(shù)的邏輯移位和算術移位的結果互為相反數(shù)
綜上所述：
算術右移：左邊用原該值的符號位填充
邏輯右移：左邊補0
左移操作符不存在邏輯移位
VS2019編譯環(huán)境下支持算術移位
三、位操作符
位操作符有：
& //按位與
| //按位或
^ //按位異或
注?。?！
他們的操作數(shù)必須是整數(shù)
同樣這里的位也是指二進制位.
1.按位與操作符：&
按位與操作符的計算方法：
- 只有兩邊的操作數(shù)都為真的時候才為真,否則都為假.
- 即二進制對應的位置都為1時取1，否則都為0
正數(shù)
代碼示例：
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 & num2;
printf("num3=%d",num3);
return 0;
}
代碼結果：
num3=0
結果分析：
1補碼：00000000000000000000000000000001
2補碼：00000000000000000000000000000010
1&2補碼：00000000000000000000000000000000 //0
2.按位或操作符：|
按位或操作符的計算方法：
只要一邊為真則為真。
即二進制對應的位置有1時取1，否則為0。
代碼示例：
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 | num2;
printf("num3=%d",num3);
return 0;
}
代碼結果：
num3=3
結果分析：
1補碼：00000000000000000000000000000001
2補碼：00000000000000000000000000000010
1|2補碼：00000000000000000000000000000011//3
3.按位異或操作符：^
按位或操作符的計算方法：
相同為假,相異為真。
即二進制對應位置相同則取0；反之，則為1。
代碼示例：
#include <stdio.h>
int main()
{
int num1 = 1;
int num2 = 2;
int num3 = num1 ^ num2;
printf("num3=%d",num3);
return 0;
}
代碼結果：
num3=3
結果分析：
1補碼：00000000000000000000000000000001
2補碼：00000000000000000000000000000010
1|2補碼：00000000000000000000000000000011//3
按位異或操作符推廣：實現(xiàn)兩個數(shù)的交換。（不能創(chuàng)建臨時變量）
代碼示例：
#include <stdio.h>
int main()
{
int a = 10;
int b = 20;
a = a^b;//10^20
b = a^b;//10^20^20=10^0=10
a = a^b;//10^20^10=10^10^20=0^20=20
printf("a = %d b = %d\n", a, b);
return 0;
}
代碼結果：
a=20 b=10
小結：
異或操作符滿足交換律
四、賦值操作符
賦值操作符是一個很棒的操作符，他可以讓你得到一個你之前不滿意的值。也就是你可以給自己重新賦值。
代碼示例:
int weight = 120;
weight = 89;//不滿意就賦值
double salary = 10000.0;
salary = 20000.0;//使用賦值操作符賦值。
這里需要注意的是
1.連續(xù)賦值容易使人誤解,建議分開賦值
代碼示例：
int a = 10;
int x = 0;
int y = 20;
a = x = y+1;//連續(xù)賦值
這樣的代碼感覺怎么樣？
那同樣的語義，你看看：
x = y+1;
a = x;
這樣的寫法是不是更加清晰爽朗而且易于調試。
2.復合賦值符
代碼示例：
#include <stdio.h>
int main()
{
int a = 2, b = 3;
a += b;//a=a+b
a -= b;//a=a-b
a *= b;//a=a*b
a /= b;//a=a/b
a %= b;//a=a%b
a >>= b;//a=a>>b
a <<= b;//a=a<<b
a &= b;//a=a&b
a |= b;//a=a|b
a ^= b;//a=a^b
return 0;
}
五、單目操作符
1.單目操作符介紹
! 邏輯反操作
- 負值
+ 正值
& 取地址
sizeof 操作數(shù)的類型長度（以字節(jié)為單位）
~ 對一個數(shù)的二進制按位取反
-- 前置、后置--
++ 前置、后置++
* 間接訪問操作符(解引用操作符)
(類型) 強制類型轉換
1.1邏輯反操作：！
將邏輯結果取反,即真的變?yōu)榧俚?假的變?yōu)檎娴?br> 在c語言中,0為假,非0為真
代碼示例：
#include <stdio.h>
int main()
{
int a = 1;
int b = 0;
printf("a=%d\n", !a);//0
printf("b=%d", !b);//1
return 0;
}
2.2取地址：&
用于得到變量,數(shù)組等的地址
在C語言中，變量，常量字符串，數(shù)組，結構體包括指針等在內存中都是有地址的,需要在內存中分配一塊空間來存儲這些值,而內存的編號就是內存地址
但是字面常量（如常數(shù) 6）在內存中是沒有地址的,因為它本身并不需要在保存下來
代碼示例：
#include <stdio.h>
int main()
{
int a = 1;
printf("%p",&a);
return 0;
}
代碼結果：
0133F800
結果分析：
確實是取地址
1.3操作數(shù)的類型長度（以字節(jié)為單位）：sizeof
sizeof()用于計算操作數(shù)所占空間大小,單位是字節(jié),可以以類型、指針、數(shù)組和函數(shù)等作為參數(shù)。
返回值類型為unsigned int
代碼示例：
#include <stdio.h>
void test1(int arr[])
{
printf("%d\n", sizeof(arr));//(2)
}
void test2(char ch[])
{
printf("%d\n", sizeof(ch));//(4)
}
int main()
{
int arr[10] = { 0 };
char ch[10] = { 0 };
printf("%d\n", sizeof(arr));//(1)
printf("%d\n", sizeof(ch));//(3)
test1(arr);
test2(ch);
return 0;
}
代碼結果：
40
10
4
4
結果分析：
我們知道,在數(shù)據(jù)類型篇已經(jīng)了解c語言中各數(shù)據(jù)類型占用多少字節(jié).
所以當sizeof(數(shù)組名)操作符在計算不同類型的數(shù)組的時候.得到的結果不同,為相應數(shù)組中元素總>和所占用的字節(jié)數(shù).
當我們在數(shù)組傳參時,傳的是數(shù)組首元素的地址,而計算地址的大小只有兩種結果
總結:
數(shù)組名一般表示的是數(shù)組首元素的地址,但有兩個情況是例外的!
1.sizeof（數(shù)組名）——這里數(shù)組名表示的是整個數(shù)組,用于計算整個數(shù)組所占空間的大小
2.&數(shù)組名-----這里的數(shù)組名表示的是整個數(shù)組，即這里取的是整個數(shù)組的地址
數(shù)組+1:
1.4按位取反：~
代碼示例：
#include <stdio.h>
int main()
{
int a = 7;
printf("~a=%d", ~7);
return 0;
}
代碼結果：
~a=-8
結果分析：
7補碼:00000000000000000000000000000111
~7補碼:11111111111111111111111111111000
~7反碼:11111111111111111111111111110111
~7原碼:10000000000000000000000000001000//-8
1.5前置、后置++
代碼示例：
#include <stdio.h>
int main()
{
int a = 10;
int b = 10;
int x = ++a;//先對a進行自增，再使用a
int y = b++;//先使用b，再對b進行自增
printf("x=%d y=%d",x,y);
return 0;
}
代碼結果：
x=11 y=10
1.6前置、后置–
代碼示例：
#include <stdio.h>
int main()
{
int a = 10;
int b = 10;
int x = --a;//先對a進行自減，再使用a
int y = b--;//先使用b，再對b進行自減
printf("x=%d y=%d",x,y);
return 0;
}
代碼結果：
x=9 y=10
六、關系操作符
>
>=
<
<=
!= 用于測試“不相等”
== 用于測試“相等”
這些關系運算符比較簡單，沒什么可講的，但是我們要注意一些運算符使用時候的陷阱。
警告：
在編程的過程中== 和=不小心寫錯，導致的錯誤。
七、邏輯操作符
&& 邏輯與
|| 邏輯或
它們分別為兩個按位與（&）和兩個按位或（|）組成，它們的效果是一樣的，但它們的作用對象不同：
- &&(邏輯與):表示操作符兩邊的操作符都為’真’是才為’真’,否則都為’假’
- | | (邏輯或):只要有一個為’真’,則為’真’,否則都為’假’
- 并不是對二進制位進行運算.
區(qū)分邏輯與和按位與
區(qū)分邏輯或和按位或
代碼示例：
#include<stdio.h>
int main()
{
int a = 1&2;//0
int b = 1&&2;//1
int c = 1|2;//3
int d = 1||2;//1
return 0;
}
重點來了?。?！
一道360筆試題：
例1：
#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\n d = %d\n i=%d", a, b, c, d,i);
return 0;
}
例2：
#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\n d = %d\n i=%d", a, b, c, d,i);
return 0;
}
代碼結果：
例1：
a=1
b=2
c=3
d=4
i=0
例2：
a=1
b=3
c=3
d=4
i=1
結果分析：
例1
- a++是后置++,所以表達式a++在使用時是0,故表達式左邊結果為假
- 即整個a++ && ++b && d++;語句為假,不執(zhí)行后面的++b和d++操作
- 最后:a自增1(后置++),故結果為,a+1=1,b,c,d值不變
例2
- 同樣a++是后置++,所以表達式a++在使用時是0,故表達式左邊結果為假
- 但是邏輯與會繼續(xù)執(zhí)行表達式++b,則表達式++b的結果為真,則整個表達式
- a++||++b||d++;的結果為真,并不會繼續(xù)執(zhí)行d++
- 最終:a+1,b+1,d和c不變
八、條件操作符(三目操作符)
exp1 ? exp2 : exp3
當我們要輸出兩個數(shù)的較大數(shù)時，通常使用if語句完成：
#include <stdio.h>
int main()
{
int a = 0, b = 0;
scanf("%d %d", &a, &b);
if (a > b)
{
printf("%d", a);
}
else printf("%d", b);
return 0;
}
其實我們可以轉換為較為簡單的寫法,條件表達式寫法:
#include <stdio.h>
int main()
{
int a = 0, b = 0;
scanf("%d %d", &a, &b);
a > b ? printf("%d", a) : printf("%d", b);
return 0;
}
九、逗號表達式
exp1, exp2, exp3, …expN
1.逗號表達式，就是用逗號隔開的多個表達式。
2.逗號表達式，從左向右依次執(zhí)行。整個表達式的結果是最后一個表達式的結果。
代碼示例：
#include<stdio.h>
{
int a = 1;
int b = 2;
int c = (a>b, a=b+10, a, b=a+1);
printf("c=%d",c)
return 0;
}
代碼結果：
c=13
靈活運用逗號表達式
逗號表達式實際使用時的妙處:
#include <stdio.h>
int main()
{
int a = 3, b = 5, c = 0;
b=dispose1(a);//函數(shù)處理1
c=dispose2(b);//函數(shù)處理2
while (c > 0)
{
//這里是一段業(yè)務處理
b = dispose1(a);//函數(shù)處理1
c = dispose2(b);//函數(shù)處理2
}
return 0;
}
改為逗號表達式之后:
#include <stdio.h>
int main()
{
int a = 3, b = 5, c = 0;
while (b = dispose1(a), c = dispose2(b),c > 0)
{
//這里是一段業(yè)務處理
}
return 0;
}
十、下標引用、函數(shù)調用和結構成員
1. [ ] 下標引用操作符
操作數(shù)：一個數(shù)組名 + 一個索引值
int arr[10];//創(chuàng)建數(shù)組
arr[9] = 10;//實用下標引用操作符。
[ ]的兩個操作數(shù)是arr和9。
2. ( ) 函數(shù)調用操作符
接受一個或者多個操作數(shù)：第一個操作數(shù)是函數(shù)名，剩余的操作數(shù)就是傳遞給函數(shù)的參數(shù)。
代碼示例：
#include <stdio.h>
void test1()
{
printf("hehe\n");
}
void test2(const char *str)
{
printf("%s\n", str);
}
int main()
{
test1();//實用（）作為函數(shù)調用操作符。
test2("hello bit.");//實用（）作為函數(shù)調用操作符。
return 0;
}
3. 訪問一個結構的成員
. 結構體.成員名
-> 結構體指針->成員名
代碼示例：
#include <stdio.h>
struct Stu
{
char name[10];
int age;
char sex[5];
double score;
}；
void set_age1(struct Stu stu)
{
stu.age = 18;
}
void set_age2(struct Stu* pStu)
{
pStu->age = 18;//結構成員訪問
}
int main()
{
struct Stu stu;
struct Stu* pStu = &stu;//結構成員訪問
stu.age = 20;//結構成員訪問
set_age1(stu);
pStu->age = 20;//結構成員訪問
set_age2(pStu);
return 0;
}
【最后】
有關操作符還有最后一個隱式類型轉換，因為這部分知識點還是比較重要的，所以我們留到下一篇文章仔細講解，大家可以訂閱我的專欄，這樣大家就可以第一時間收到我發(fā)的文章啦！文章來源：http://www.zghlxwxcb.cn/news/detail-619741.html
好了,c語言中,有關操作符的知識就講到這里了，希望對大家有所幫助！??文章來源地址http://www.zghlxwxcb.cn/news/detail-619741.html
到了這里，關于C語言中的操作符（萬字詳解）的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！
