C語言運算子、整形提升與截斷
文章目錄
- C語言運算子、整形提升與截斷
- 前言
- part 1.位運算運算子
- part 2.整形提升與截斷
- part 3.計算器的大小端
- 何為大小端
- part 4.資料存盤-浮點型
前言
1.首先需要了解整數儲存的機制；
2.原碼、反碼、補碼之間的關系；
2.(1)正整數原碼、反碼、補碼相同，直接進行二進制轉換就可；（2^32-1個正整數）
2.(2)負整數32位的首位為符號位（1代表負數）；（2^31-1個符數）
我們來說個例子，例如：-1
首先寫出-1的補碼為：
1000 0000 0000 0000 0000 0000 0000 0001 -----原碼
其次求出反碼：符號位不變，其他位取反，得到反碼
1111 1111 1111 1111 1111 1111 1111 1110 -----反碼
最后反碼+1得到補碼，記憶體中存的都是補碼
1111 1111 1111 1111 1111 1111 1111 1111 -----補碼
3.整形提升、截斷
part 1.位運算運算子
（1）按位與運算子&： 如果兩個對應位置的二進制位都為1，則該位結果為1，否則為0，看下面的例子：
int a = 15; //0000 0000 0000 0000 0000 0000 0000 1111 ---15的二進制表示
int b = 19; //0000 0000 0000 0000 0000 0000 0001 0011 ---19的二進制表示
int c = a & b;//0000 0000 0000 0000 0000 0000 0000 0011 ---a&b=3的二進制表示
(2) 按位或運算子|： 如果兩個對應位置的二進制位都為0，則該位結果為0，否則為1，看下面的例子：
int a = 15; //0000 0000 0000 0000 0000 0000 0000 1111 ---15的二進制表示
int b = 19; //0000 0000 0000 0000 0000 0000 0001 0011 ---19的二進制表示
int c = a | b;//0000 0000 0000 0000 0000 0000 0001 1111 ---a|b=31的二進制表示
（3）按位異或運算子^:如果兩個對應位置的二進制位相同時結果為0，否則為1，看下面的例子：
int a = 15; //0000 0000 0000 0000 0000 0000 0000 1111 ---15的二進制表示
int b = 19; //0000 0000 0000 0000 0000 0000 0001 0011 ---19的二進制表示
int c = a^b; //0000 0000 0000 0000 0000 0000 0001 1100 ---a^b=28的二進制表示
下面運用異或來實作倆個數的交換：
#include <stdio.h>
int main()
{
int a = 10; //0000 0000 0000 0000 0000 0000 0000 1010 ---10的二進制表示
int b = 20; //0000 0000 0000 0000 0000 0000 0001 0100 ---20的二進制表示
a = a^b; //a=0000 0000 0000 0000 0000 0000 0001 1110 ---30的二進制表示
b = a^b; //b=0000 0000 0000 0000 0000 0000 0000 1010 ---10的二進制表示
a = a^b; //c=0000 0000 0000 0000 0000 0000 0001 0100 ---20的二進制表示
printf("a = %d b = %d\n", a, b);
return 0;
}
通過異或來實作倆個數字的交換不會出現溢位的情況，
(4) 左移運算子<<:移位規則：左邊拋棄、右邊補0，看下面的例子：
int main(){
int a = 19; //00000000000000000000000000010011
int b = a<<1;//00000000000000000000000000100110
printf("%d", b);//輸出結果38
return 0;
}
(5) 右移運算子>>:
移位規則：首先右移運算分兩種：
- 邏輯移位 左邊用0填充，右邊丟棄
- 算術移位 左邊用原該值的符號位填充，右邊丟棄
(6)按位取反運算子~：對該數的二進制位，若該位為1則結果為0，若改為為0則結果為1，例如：
int a = 19;//00000000000000000000000000010011
int b = ~a;//11111111111111111111111111101100(記憶體中的補碼)
//11111111111111111111111111101011（反碼,即補碼-1）
//10000000000000000000000000010100（原碼,即反碼符號位不變,其余位數取反）
part 2.整形提升與截斷
C的整型算術運算總是至少以預設整型型別的精度來進行的，
為了獲得這個精度，運算式中的字符和短整型運算元在使用之前被轉換為普通整型，這種轉換稱為整型提升，
//負數的整形提升
char c1 = -1;
變數c1的二進制位(補碼)中只有8個位元位：
1111111
因為 char 為有符號的 char
所以整形提升的時候，高位補充符號位，即為1
提升之后的結果是：
1111 1111 1111 1111 1111 1111 1111 1111
//正數的整形提升
char c2 = 1;
變數c2的二進制位(補碼)中只有8個位元位：
00000001
因為 char 為有符號的 char
所以整形提升的時候，高位補充符號位，即為0
提升之后的結果是：
0000 0000 0000 0000 0000 0000 0000 0001
整形提升的例子:
//實體1
char a,b,c;
...
a = b + c;
//負數的整形提升
char c1 = -1;
變數c1的二進制位(補碼)中只有8個位元位：
1111111
因為 char 為有符號的 char
所以整形提升的時候，高位補充符號位，即為1
提升之后的結果是：
1111 1111 1111 1111 1111 1111 1111 1111
//正數的整形提升
char c2 = 1;
變數c2的二進制位(補碼)中只有8個位元位：
0000 0001
因為 char 為有符號的 char
所以整形提升的時候，高位補充符號位，即為0
提升之后的結果是：
0000 0000 0000 0000 0000 0000 0000 0001
//無符號整形提升，高位補0
//實體2
#include<stdio.h>
int main()
{
char a = 0xb6;
short b = 0xb600;
int c = 0xb6000000;
if (a == 0xb6)
{
printf("a");
}
if (b == 0xb600)
{
printf("b");
}
if (c == 0xb6000000)
{
printf("c");
}
return 0;
}
`
實體2中的a,b要進行整形提升,但是c不需要整形提升 a,b整形提升之后,變成了負數,所以運算式
a0xb6 , b0xb600 的結果是假,但是c不發生整形提升,則運算式 c==0xb6000000 的結果是真.
所程式輸出的結果是:c
實體2：
#include <stdio.h>
int main()
{
char a = -1;
//1000 0000 0000 0000 0000 0000 0000 0001 -----原碼
//1111 1111 1111 1111 1111 1111 1111 1110 -----反碼
//1111 1111 1111 1111 1111 1111 1111 1111 -----補碼
//發生截斷
//1111 1111 ----a
//由于要列印整形（%d）格式，所以發生整形提升，前面補充符號位
//1111 1111 1111 1111 1111 1111 1111 1111 -----補碼
//1111 1111 1111 1111 1111 1111 1111 1110 -----反碼
//1000 0000 0000 0000 0000 0000 0000 0001 -----原碼
//a那列印就是-1
signed char b = -1;
unsigned char c = -1;
//1000 0000 0000 0000 0000 0000 0000 0001 -----原碼
//1111 1111 1111 1111 1111 1111 1111 1110 -----反碼
//1111 1111 1111 1111 1111 1111 1111 1111 -----補碼
//發生截斷
//1111 1111 ----c
//由于要列印整形（%d）格式，所以發生了整形提升，前面補充符號位,但c是無符號數，所以前面補0
//由于是正數-----補碼==反碼==原碼
//0000 0000 0000 0000 0000 0000 1111 1111
printf("a=%d,b=%d,c=%d", a, b, c); //a= -1 b= -1 c= 255
return 0;
}
實體3：
#include <stdio.h>
int main()
{
char a = -128;
//1000 0000 0000 0000 0000 0000 1000 0000 -----原碼
//1111 1111 1111 1111 1111 1111 0111 1111 -----反碼
//1111 1111 1111 1111 1111 1111 1000 0000 -----補碼
//截斷
//1000 0000 ----a
//由于要列印無符號整形（%u）格式，所以發生整形提升，前面補充符號位
//1111 1111 1111 1111 1111 1111 1000 0000 -----補碼==反碼==原碼
printf("%u\n", a); //列印的值-----4294967168?
return 0;
}
既然我們已經學會了整形提升和截斷，來讓我們寫一下下面這幾道題：
題目1：以下代碼會發生什么情況
#include<stdio.h>
int main()
{
unsigned int i;
for (i = 9; i >= 0; i--) //無符號整形恒大于0,所以會死回圈
{ //當i變成-1時，把有符號數轉變位無符號數為32個1然后一直死回圈下棋
//1000 0000 0000 0000 0000 0000 0000 0001 -----原碼
//1111 1111 1111 1111 1111 1111 1111 1110 -----反碼
//1111 1111 1111 1111 1111 1111 1111 1111 -----補碼 -1對應的無符號數
printf("%d\n", i);
}
return 0;
}
無符號整形恒大于0,所以會死回圈，
題目2：：以下代碼列印的值為多少
#include<stdio.h>
#include<string.h>
int main()
{
char a[1000];
int i;
/*a是字符型陣列，strlen找的是第一次出現尾零（即值為0）的位置，考慮到a[i]其實是字符型，
如果要為0，則需要 - 1 - i的低八位要是全0，也就是問題簡化成了“尋找當 - 1 - i的結果第一次出現低八位全部為0的情況時，
i的值”（因為字符陣列下標為i時第一次出現了尾零，則字串長度就是i），只看低八位的話，此時 - 1相當于255，所以i == 255的時候，
- 1 - i（255 - 255）的低八位全部都是0，也就是當i為255的時候，a[i]第一次為0，所以a[i]的長度就是255了，*/
for (i = 0; i < 1000; i++)
{
a[i] = -1 - i; //-128~127
}
printf("%d", strlen(a)); //strlen(a)----255
return 0;
}
part 3.計算器的大小端
何為大小端
我們來通過一個代碼來看看自己當前使用的平臺是使用大端存盤還是小端存盤，
#include<stdio.h>
int check_sys()
{
int i =0x00000001;
char* p = (char *)&i; //讓它只能訪問一個位元組的內容
return *p;
}
int main()
{
if (check_sys() == 1)
{
//把一個資料的低位位元組序的內容，存放在低地址處
// 高位位元組的內容，存放在高位地址處
printf("小端\n"); //1在小端記憶體存盤的十六進制----------01 00 00 00
}
else
{
//把一個資料的低位位元組序的內容，存放在高位地址處
//高位位元組序的內容，存放在低位地址處
printf("大端\n"); //1在大端記憶體存盤的十六進制----------00 00 00 01
}
return 0;
}
通過上圖我們發現vs2019存盤是小端位元組序存盤
part 4.資料存盤-浮點型
根據國際標準IEEE（電氣和電子工程協會） 754，任意一個二進制浮點數V可以表示成下面的形式：
(-1)^S * M * 2^E
(-1)^s表示符號位，當s=0，V為正數；當s=1，V為負數，
M表示有效數字，大于等于1，小于2，
2^E表示指數位，
舉例來說： 十進制的5.0，寫成二進制是 101.0 ，相當于 1.01×2^2 ， 那么，按照上面V的格式，可以得出s=0，
M=1.01，E=2，
十進制的-5.0，寫成二進制是 -101.0 ，相當于 -1.01×2^2 ，那么，s=1，M=1.01，E=2，
IEEE 754規定： 對于32位的浮點數，最高的1位是符號位s，接著的8位是指數E，剩下的23位為有效數字M，
對于64位的浮點數，最高的1位是符號位S，接著的11位是指數E，剩下的52位為有效數字M，
IEEE 754對有效數字M和指數E，還有一些特別規定， 前面說過， 1≤M<2 ，也就是說，M可以寫成 1.xxxxxx 的形
式，其中xxxxxx表示小數部分，
IEEE 754規定，在計算機內部保存M時，默認這個數的第一位總是1，因此可以被舍去，只保存后面的xxxxxx部分，
比如保存1.01的時候，只保存01，等到讀取的時候，再把第一位的1加上去，這樣做的目的，是節省1位有效數字，
以32位浮點數為例，留給M只有23位，將第一位的1舍去以后，等于可以保存24位有效數字，
至于指數E，情況就比較復雜，
首先，E為一個無符號整數（unsigned int） 這意味著，如果E為8位，它的取值范圍為0~255；如果E為11位，它的
取值范圍為0~2047，但是，我們知道，科學計數法中的E是可以出現負數的，所以IEEE 754規定，存入記憶體時E的真
實值必須再加上一個中間數，對于8位的E，這個中間數是127；對于11位的E，這個中間數是1023，比如，2^10的E
是10，所以保存成32位浮點數時，必須保存成10+127=137，即10001001，
然后，指數E從記憶體中取出還可以再分成三種情況：
E不全為0或不全為1
這時，浮點數就采用下面的規則表示，即指數E的計算值減去127（或1023），得到真實值，再將有效數字M前
加上第一位的1， 比如： 0.5（1/2）的二進制形式為0.1，由于規定正數部分必須為1，即將小數點右移1位，
則為1.0*2^(-1)，其階碼為-1+127=126，表示為01111110，而尾數1.0去掉整數部分為0，補齊0到23位
00000000000000000000000，則其二進制表示形式為:
E全為0
這時，浮點數的指數E等于1-127（或者1-1023）即為真實值， 有效數字M不再加上第一位的1，而是還原為
0.xxxxxx的小數，這樣做是為了表示±0，以及接近于0的很小的數字，
E全為1
這時，如果有效數字M全為0，表示±無窮大（正負取決于符號位s）；
int main()
{
int n = 9;
//0 00000000 00000000000000000001001 ----整數存盤形式
//(-1)^0 * 0.00000000000000000001001 * 2^-126 ----單精度浮點數存盤形式
float *pFloat = (float *)&n;
printf("n的值為：%d\n", n);//9
printf("*pFloat的值為：%f\n", *pFloat);//0.000000
*pFloat = 9.0;
//1001.0
//(-1)^0 * 1.001*2^3
//S=0 ----表示的是符號位 0為正 ，負數為1
//M=1.001
//E=3 +127
//9.0 -> 1001.0 ->(-1)^01.0012^3 -> s=0, M=1.001,E=3+127=130
//01000001000100000000000000000000
printf("num的值為：%d\n", n);//直接列印整形時，就是2進制到十進制轉換
printf("*pFloat的值為：%f\n", *pFloat);//9.0
return 0;
}
好了，就說到這里，
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/255573.html
標籤：其他
上一篇：c++檔案操作1
下一篇：計算機還能火多久呢?