数据类型

1.有符号数和无符号数

1.1 有符号数和无符号数

1. 有符号数
有符号数是最高位为符号位，0代表正数，1代表负数。,最高位为符号位,其他位为数据位

• 默认是有符号数
• 要存储一个负数,要定义一个有符号数

char num;
signed char num;  // 有符号数
unsgned char num;// 无符号数

#include <stdio.h>

int main()
{
	signed int a = -1089474374; //定义有符号整型变量a
	printf("%X\n", a); //结果为 BF0FF0BA

	//B       F      0        F       F     0        B	      A
	//1011 1111 0000 1111 1111 0000 1011 1010

	return 0;
}

2. 无符号整数
无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数。
*当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值。

#include <stdio.h>

int main()
{
	unsigned int a = 3236958022; //定义无符号整型变量a
	printf("%X\n", a); //结果为 C0F00F46

	return 0;
}

1.2 数的范围

有符号数和无符号数能够表示数的个数是一样的,但是表示的数的范围是不一致的
1. char类型

• 有符号char -128 - 127 (-2^7 ~ 2^7-1)
• 无符号char 0 - 255 (0 - 2^8-1)
• 规定:将负0表示成-128
• 有符号和无符号都表示256个数

// 有符号
1,000 0000 - 1,111 1111    -0 - -127       
0,000 0000 - 0,111 1111    +0 - +127       
// 无符号
0000 0000 - 1111 1111      0 - 255         

2. short类型

• signed:-2^15 - 2^15-1
• unsigned:0 - 2^16-1

其他类型可以类似推导得出

3. 数的范围不能越界

2.计算机内存数值存储方式

2.1 计算机中数值的存储

120对应的二进制,01111010
-23对应二进制,10010111

// 计算机中存储值,负数在计算机中的存储?
// 以char类型存储0 -0 -1 1
-0    : 1000 0000 
0     : 0000 0000
1     : 0000 0001
-1    : 1000 0001

// 使用源码操作加减
0000 0001     1
1000 0001  + -1
1000 0010    -2   //结果错误

如果负数在计算机中原码存储,会导致两个问题,负数运算结果不正确,0的状态还有两种

// 如果以反码存储,查看结果
            源码        反码
-0    : 1000 0000      1111 1111
0     : 0000 0000      0000 0000
1     : 0000 0001      0000 0001
-1    : 1000 0001      1111 1110

1       0000 0001
-1      1111 1110
-0      1111 1111     // 结果为-0,运算结果正确但是有两种0

以反码存储,负数运算结果正确但是0得状态有两种

// 以补码存储,负数运算结果
-0  0000 0000 
0   0000 0000
1   0000 0001
-1  1111 1111

-1 + 1 = 0
// 负数运算结果正确,而且0的状态只有一种

正数和负数在计算机中都是以补码进行存储的

2.2 原码

一个数的原码(原始的二进制码)有如下特点：

• 最高位做为符号位，0表示正,为1表示负
• 其它数值部分就是数值本身绝对值的二进制数
• 负数的原码是在其绝对值的基础上，最高位变为1
  下面数值以1字节的大小描述:

原码表示法简单易懂，与带符号数本身转换方便，只要符号还原即可，但当两个正数相减或不同符号数相加时，必须比较两个数哪个绝对值大，才能决定谁减谁，才能确定结果是正还是负，所以原码不便于加减运算。

#include <stdio.h>

int main()
{
  char num = 0x81; // 十六进制数--给的是补码--1000 0001
  printf("%d\n",num); //  %d输出有符号32位整数 -127
  printf("%u\n,num");  // %u输出无符号32位整数 11931683
  
  system("pause");
  return 0;


  unsigned int d = 0xffffffff;  定义无符号int变量d,以十六进制的方式进行赋值
  /*
    虽然定义的是无符号数,但是打印的是%d需要将其看成有符号数
    d = 0xffffffff -- 赋值以16进制赋值,给的是补码
    补码: 1111 1111 1111 1111 1111 1111 1111 1111
    反码: 1000 0000 0000 0000 0000 0000 0000 0000
    原码: 1000 0000 0000 0000 0000 0000 0000 0001   输出-1
  */
  printf("有符号方式打印:d = %d\n",d); // -1
  printf("无符号方式打印:d = %u\n",d); // 0xffffffff
}

2.3 反码

• 对于正数，反码与原码相同
• 对于负数，符号位不变，其它部分取反(1变0,0变1)

反码运算也不方便,通常用来作为求补码的中间过渡

2.4 补码

在计算机系统,数值一律用补码来存储

补码特点::

• 对于正数，原码、反码、补码相同
• 对于负数，其补码为它的反码加1
• 补码符号位不动，其他位求反，最后整个数加1，得到原码

2.5 补码的意义

示例1:用8位二进制数分别表示+0和-0

不管以原码方式存储，还是以反码方式存储，0也有两种表示形式。为什么同样一个0有两种不同的表示方法呢？
但是如果以补码方式存储，补码统一了零的编码：

示例2:计算9-6的结果
以原码方式相加：

结果为-15，不正确。

以补码方式相加：

最高位的1溢出,剩余8位二进制表示的是3，正确。

在计算机系统中，数值一律用补码来存储，主要原因是：

• 统一了零的编码
• 将符号位和其它位统一处理
• 将减法运算转变为加法运算
• 两个用补码表示的数相加时，如果最高位(符号位)有进位，则进位被舍弃

#include <stdio.h>

int main(){
  // 赋值时(输入),赋的是十进制,给的是原码,如果赋值给的是8进制或者是16进制给的是补码
  // 打印时(输出),十进制打印的是原码,如果是十六进制或者8进制打印的是补码
  char num = 129;
  //129 -- 十进制 -- 原码-反码-补码 1000 0001 
  // num是有符号数,最高位为1,计算机认为这是一个负数的补码
  /*
    1000 0001
    1111 1110
    1111 1111    -127
  */
  printf("num = %d\n",num); // -127
}

#include <stdio.h>

int main(){
  // 如果赋值给的是8进制或者十六进制给的是补码
  // 输出,十进制要的是原码,16进制或8进制要的是补码
  char ch = 0x82; // 1000 0010
  /*
    补码 1000 0010
    反码 1111 1101
    原码 1111 1110     -126
  */
  printf("%d\n",ch);

  //2
  int num = 0x80 00 00 01;
  // 补码: 1000 0000 0000 0000 0000 0000 0000 0001
  // 反码: 1111 1111 1111 1111 1111 1111 1111 1110
  // 原码: 1111 1111 1111 1111 1111 1111 1111 1111  -7fffffff
  printf("%d\n,num");

  //3.
  char ch = -123; // 原码 1 111 1011
  printf("%d\n",ch);  // -123
}

2.6 数值溢出

当超过一个数据类型能够存放最大的范围时，数值会溢出。
有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失。

#include <stdio.h>

int main()
{
	char ch;

	//符号位溢出会导致数的正负发生改变
        // 7f -- 补码 -- 0111 1111
        //  2 -- 补码 -- 0000 0010
                         1000  0001 
        // 反码 1111 1110 
        // 原码 1111 1111     -127    
	ch = 0x7f + 2; //127+2
	printf("%d\n", ch);
	//	0111 1111
	//+2后 1000 0001，这是负数补码，其原码为 1111 1111，结果为-127

	//最高位的溢出会导致最高位丢失
        // 补码 1111 1111
        //      0000 0001
	unsigned char ch2;
	ch2 = 0xff+1; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0000， char只有8位最高位的溢出，结果为0000 0000，十进制为0

	ch2 = 0xff + 2; //255+1
	printf("%u\n", ch2);
	//	  1111 1111
	//+1后 10000 0001， char只有8位最高位的溢出，结果为0000 0001，十进制为1

	return 0;
}

3. 整型

3.1 整型变量的定义与输出

#include <stdio.h>

int main(){
  char num = 0x81;
  // 补码 -- 1000 0001
  // 反码 -- 1111 1110
  // 原码 -- 1111 1111  
  print("%d\n",num); // 打印有符号数 -- 最高位为符号位 -127 
  print("%u\n"num); // 4294967169(涉及到8位转32位)  (输出无符号数)
  
  int num_2 = 0x81;
  // 0000 0000 ... 1000 0001  (补码-原码)
  printf("%d\n",num_2); // 129
  printf("%u\n",num_2); // 129
  
}

#include <stdio.h>

int main()
{
	int a = 123;	//定义变量a，以10进制方式赋值为123
	int b = 0567;	//定义变量b，以8进制方式赋值为0567
	int c = 0xabc;	//定义变量c，以16进制方式赋值为0xabc

	printf("a = %d\n", a);    // a = 123
	printf("8进制：b = %o\n", b); // 567(8进制)
	printf("10进制：b = %d\n", b); // 375 (十进制)
	printf("16进制：c = %x\n", c); // abc
	printf("16进制：c = %X\n", c); // ABC
	printf("10进制：c = %d\n", c); // 2748

	unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
        // 十六进制给的是补码,所以存储的时候以补码的形式存储,输出使用%d,就是有符号数,补码转原码,符号
        // 位不变,输出使用%u,无符号数,高位不是符号位
        // 补码: 1111 1111 1111 1111 1111 1111 1111 1111
        // 反码: 1000 0000 0000 0000 0000 0000 0000 0000
        // 原码: 1000 0000 0000 0000 0000 0000 0000 0001
	printf("有符号方式打印：d = %d\n", d);  // -1
	printf("无符号方式打印：d = %u\n", d);  // 0xffffffff
	return 0;
}

3.2 整型变量的输入

• 从键盘输入一个数,使用scanf()函数
• scanf()从键盘(标准输入)读取数据,键盘输入之后,内容写到标准输入文件(stdin),当程序运行到scanf()的时候,从标准输入中读取,读取内容取决于前面的格式,\n表示结束
• scanf()没有回车或者换行,会阻塞程序
• 空格也会结束输入
  

#include <stdio.h>

int main()
{
	int sum = 0;
        int num = 0;
        scanf("%d",&num); // 键盘输入-->标准输入-->num变量
        scanf("%d %d",&num,&sum); // 键盘输入两个值,中间用空格123 456分别给两个变量
        printf("%d\n",num);
        printf("%d\n",sum);
        system("pause");
        return 0;
}

#include <stdio.h>

int main()
{
	int a;
	printf("请输入a的值：");

	//不要加“\n”
	scanf("%d", &a);

	printf("a = %d\n", a); //打印a的值

	return 0;
}

3.3 整型变量占用的空间

注意：

• 需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能长于 int 类型。
• 当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。
  sizeof关键字
• sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节
• sizeof的返回值为size_t
• size_t类型在32位操作系统下是unsigned int，是一个无符号的整数

#include <stdio.h>

int main()
{
	char a;
        short int b; // 短整型 int可以省略
        int c;
        long d;
        long long e;
        // sizeof 用来测数据类型的大小,打印的是字节数
        // sizeof(变量或者数据类型)
}

#include <stdio.h>

int main()
{
	short a = 10;
	int b = 10;
	long c = 10l; //或者10L
	long long d = 10ll; //或者10LL

	printf("sizeof(a) = %u\n", sizeof(a));
	printf("sizeof(b) = %u\n", sizeof(b));
	printf("sizeof(c) = %u\n", sizeof(c));
	printf("sizeof(c) = %u\n", sizeof(d));

	printf("short a = %hd\n", a);
	printf("int b = %d\n", b);
	printf("long c = %ld\n", c);
	printf("long long d = %lld\n", d);

	unsigned short a2 = 20u;
	unsigned int b2 = 20u;
	unsigned long c2= 20ul; 
	unsigned long long d2 = 20ull; 

	printf("unsigned short a = %hu\n", a2);
	printf("unsigned int b = %u\n", b2);
	printf("unsigned long c = %lu\n", c2);
	printf("unsigned long long d = %llu\n", d2);

	return 0;
}