C语言基础之【数据类型】（上）

往期 C语言 知识回顾： 链接： C语言基础之【C语言概述】

常量与变量

关键字

在这里插入图片描述

数据类型

数据类型的作用之一：决定了程序为变量分配多少内存空间。

在这里插入图片描述

常量

常量： 在程序执行过程中其值不发生改变的量。

常量的特点：

1. 不可变性：常量的值在定义后不能被修改。
2. 直接使用：常量可以直接在代码中使用，无需额外的计算或处理。
3. 提高可读性：使用常量可以使代码更易于理解和维护。
4. 优化性能：编译器可以对常量进行优化，减少运行时的计算开销。

#define PI 3.1415  //没有分号结束标记

宏定义语法：#define 宏名 宏值

const int a=10;

只读变量定义语法： const类型名 变量名 = 变量值

• 被const关键字修饰的变量，表示为只读变量

变量

变量

变量： 在程序运行过程中其值可以改变的量。 变量在使用前必须先定义，定义变量前必须有相应的数据类型

变量的特点：

1. 可变性：变量的值可以在程序运行期间被修改。
2. 命名：变量通过名称来标识，名称通常由字母、数字和下划线组成。
   • 标识符不能是关键字（注：标识符是常量和变量的统称）
   • 标识符的第一个字符必须为字母或下划线
   • 标识符中字母区分大小写
3. 数据类型：变量具有特定的数据类型，决定了它可以存储的数据种类和范围。
   • 变量在编译时为其分配相应的内存空间
4. 作用域：变量的作用域决定了它在程序中的可见性和生命周期。
   • 可以通过其名字和地址访问相应内存

在这里插入图片描述

变量定义时的注意事项：

1. 变量要想使用必须有定义：当编译器编译程序时，在变量使用之前，必须要看到变量定义。
   • 如果没有看到变量定义，编译器会自动找寻一个变量声明提升成为定义。
   • 如果该变量的声明前有extern 关键字，无法提升。
2. 定变量时尽量不要重名

变量定义语法: 类型名 变量名 = 变量值(一般方法)

声明和定义区别

#include <stdio.h>

int main()
{
	//extern 关键字只做声明，不能做任何定义
	//声明一个变量a，a在这里没有建立存储空间
	extern int a;
	a = 10;	//err, 没有空间，就不可以赋值

	int b = 10;	//定义一个变量b，b的类型为int，b赋值为10

	return 0;
}

从广义的角度来讲声明中包含着定义，即定义是声明的一个特例，所以并非所有的声明都是定义：

• int b 它既是声明，同时又是定义
• 对于 extern b来讲它只是声明不是定义

一般的情况下：把建立存储空间的声明称之为定义，而把不需要建立存储空间的声明称之为声明

使用示例

#include <stdio.h>
#define MAX 10 //声明了一个常量，名字叫MAX，值是10，常量的值一旦初始化不可改

int main()
{
	int a;	//定义了一个变量，其类型为int，名字叫a

	const int b = 10; //定义一个const常量，名为叫b，值为10
	//b = 11; //err,常量的值不能改变

	//MAX = 100;	//err,常量的值不能改变

	a = MAX;//将abc的值设置为MAX的值
	a = 123;

	printf("%d\n", a); //打印变量a的值
	return 0;
}

整型

整型变量的定义和输出

#include <stdio.h>

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

	printf("10进制：a = %d\n", a);
	printf("8进制：b = %o\n", b);
	printf("10进制：b = %d\n", b);
	printf("16进制：c = %x\n", c);
	printf("16进制：c = %X\n", c);
	printf("10进制：c = %d\n", c);

	unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
	printf("有符号方式打印：d = %d\n", d);
	printf("无符号方式打印：d = %u\n", d);
	return 0;
}

定义： int a = 123; int b = 0567; int c = 0xabc; unsigned int d = 0xffffffff; 输出： 10进制：a = 123 8进制：b = 567 10进制：b = 375 16进制：c = abc 16进制：c = ABC 10进制：c = 2748 有符号方式打印：d = -1 无符号方式打印：d = 4294967295

整型变量的输入

#include <stdio.h>

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

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

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

short、int、long、long long

注意事项：

• 整型数据在内存中占的字节数与所选择的操作系统有关。
  • int 类型整数的长度不能长于 long 类型。
  • int 类型整数的长度不能短于 short 类型。
• 一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。
• 一个大的数据类型赋值给一个小的数据类型，那么就可能丢失高位。

整型常量的表示方式及其对应的数据类型：

#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);//short a = 10;
	printf("int b = %d\n", b);//int b = 10;
	printf("long c = %ld\n", c);//long c = 10l;
	printf("long long d = %lld\n", d);//long long d = 10ll; 
	//short a = 10
	//int b = 10
	//long c = 10
	//long long d = 10
    
	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;
}

定义： short a = 10; int b = 10; long c = 10l; long long d = 10ll; unsigned short a2 = 20u; unsigned int b2 = 20u; unsigned long c2= 20ul; unsigned long long d2 = 20ull; 输出： sizeof( a ) = 2 sizeof( b ) = 4 sizeof( c ) = 4 sizeof( c ) = 8 short a = 10 int b = 10 long c = 10 long long d = 10 unsigned short a = 20 unsigned int b = 20 unsigned long c = 20 unsigned long long d = 20

有符号数和无符号数区别

有符号数整数

有符号数是最高位为符号位

• 0代表正数。
• 1代表负数。

#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;
}

有符号整数在内存中的存储：

• 在计算机中，有符号整数是以补码形式存储数值
• signed int 是一个有符号的32位整数类型，范围从 -2,147,483,648 到 2,147,483,647

所以：当你定义一个 signed int 变量 a 并赋值为 -1089474374 时，这个负数 -1089474374 在内存中以 二进制补码 形式存储。

求有符号整数之负数的补码的步骤：

1. 取绝对值的二进制
2. 对二进制表示取反（除符号位的其他位：0变1，1变0）
   • 正数，符号位为 0
   • 负数，符号位为 1
3. 对取反后的结果加1

计算过程： 步骤二进制值第一步0100 0000 1111 0000 0000 1111 0100 0110第二步1011 1111 0000 1111 1111 0000 1011 1001第三步1011 1111 0000 1111 1111 0000 1011 1010 将二进制补码转换为十六进制，每4位二进制对应一个十六进制数字： BF0FF0BA10111111000011111111000010111010

无符号整数

无符号整数最高位不是符号位，而就是数的一部分。 无符号数不可能是负数。

• 当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值。

#include <stdio.h>

int main()
{
	unsigned int a = 3236958022; //定义无符号整型变量a
	printf("%X\n", a); //结果为 C0F00F46
    
	//1100 0000  1111  0000  0000  1111  0100  0110	
    //  C 	 0	  F		0	   0	 F	   4	 6	
   
	return 0;
}

无符号整数在内存中的存储：

• 在计算机中，无符号整数它不存在符号位，直接以二进制原码形式存储数值
• unsigned int 是一个无符号的32位整数类型，范围从 0 到 4,294,967,295

所以：当你定义一个 unsigned int 变量 a 并赋值为 3236958022 时，这个无符号整数 3236958022在内存中以 二进制原码 的形式存储。

计算过程：

• 第一步：1100 0000 1111 0000 0000 1111 0100 0110

将二进制原码转换为十六进制，每4位二进制对应一个十六进制数字 二进制段11000000111100000000111101000110十六进制C0F00F46

有符号和无符号整型取值范围

sizeof关键字

关键字介绍： sizeof ：用于计算给定数据类型或者变量所占用的内存大小（以字节为单位）

• sizeof是C 语言中的一个操作符，而不是函数。
• sizeof不是函数，所以不需要包含任何头文件。
• sizeof在处理内存分配、数据存储以及程序的空间复杂度分析等方面非常有用。

关键字使用： sizeof有两种语法形式：

• sizeof(类型)：这里的 “类型” 可以是 基本数据类型（如 int、char、float、double 等）、 用户自定义的数据类型（如结构体 struct、联合体 union）或者 指针类型（如 int*、char* 等）
  • 例如：sizeof(int) 会返回 int 类型在当前编译器环境下所占用的字节数。
• sizeof(表达式)：这里的 “表达式” 通常是一个 变量。
  • 例如，如果有 int a;，那么 sizeof(a) 会返回变量 a 所占用的字节数。

实际上：sizeof 在计算变量所占用字节数时，不会对变量进行求值，只是根据变量的类型来确定其占用空间。

关键字返回值： sizeof ：返回一个 size_t 类型的值，表示占用的字节数。

• size_t 是一个无符号整数类型。
  • 在不同的系统和编译器环境下，它可能是 unsigned int 或者 unsigned long 等类型。
• size_t定义在头文件 <stddef.h> 中。
  • 这个类型足够大，可以用来表示任何对象的大小。

#include <stdio.h>

int main()
{
	int a;
	int b = sizeof(a);//sizeof得到指定变量占用内存的大小，单位：字节
	printf("b = %d\n", b);

	size_t c = sizeof(a);
	printf("c = %u\n", c);//用无符号数的方式输出c的值

	return 0;
}

输出： b = 4 c = 4

字符型

字符变量的定义和输出

字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。 字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的 ASCII 编码放到变量的存储单元中。 char的本质就是一个1字节大小的整型

字符型变量赋值时，需要用一对英文半角格式的单引号(’ ')把字符括起来。

#include <stdio.h>

int main()
{
	char ch = 'a';
	printf("sizeof(ch) = %u\n", sizeof(ch));

	printf("ch[%%c] = %c\n", ch); //打印字符
	printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值

	char A = 'A';
	char a = 'a';
	printf("a = %d\n", a);	//97
	printf("A = %d\n", A);	//65

	printf("A = %c\n", 'a' - 32); //小写a转大写A
	printf("a = %c\n", 'A' + 32); //大写A转小写a

	ch = ' ';
	printf("空字符：%d\n", ch); //空字符ASCII的值为32
	printf("A = %c\n", 'a' - ' '); //小写a转大写A
	printf("a = %c\n", 'A' + ' '); //大写A转小写a

	return 0;
}

输出： sizeof(ch) = 1 ch[%c] = a ch[%d] = 97 a = 97 A = 65 A = A a = a 空字符：32 A = A a = a

字符变量的输入

#include <stdio.h>

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

	//不要加“\n”
	scanf("%c", &ch);
	printf("ch = %c\n", ch); //打印ch的字符

	return 0;
}

ASCII对照表

在这里插入图片描述

ASCII 码大致由以下三部分组成： 控制字符 ：ASCII值 0 到 31 是控制字符，用于控制设备（如打印机、终端等） 打印字符 ：ASCII值 32 到 126 是可打印字符，包括空格、数字、字母和标点符号。

• 32：空格
• 48 ~ 57：数字 0 到 9
• 65 ~ 90：大写字母 A 到 Z
• 97 ~ 122：小写字母 a 到 z

扩展字符 ：ASCII值 128 到 255 是扩展ASCII字符，通常用于表示特殊符号、图形字符等。

• 这部分字符集因地区和编码方式不同而有所差异。

转义字符

C语言转义字符表：

1. 常用转义字符：
   • \n 和 \r 常用于文本换行。
   • \t 用于对齐文本。
   • \\、\' 和 \" 用于在字符串中表示特殊字符。
2. 8进制和16进制转义字符：
   • \ddd：用3位8进制数表示一个字符。
     • 例如：\101 表示字符 A（ASCII值为65）
   • \xhh：用2位16进制数表示一个字符。
     • 例如：\x41 也表示字符 A
3. 空字符 \0：
   • 用于表示字符串的结束标志（C语言中的字符串以 \0 结尾）

#include <stdio.h>

int main()
{
	printf("abc");
	printf("\refg\n"); //\r切换到句首， \n为换行键

	printf("abc");
	printf("\befg\n");//\b为退格键， \n为换行键

	printf("%d\n", '\123');// '\123'为8进制转义字符，0123对应10进制数为83
	printf("%d\n", '\x23');// '\x23'为16进制转义字符，0x23对应10进制数为35

	return 0;
}

输出： efg abefg 83 35

#include <stdio.h>

int main() {
    printf("警报: \a\n");
    printf("退格: abc\bdef\n");
    printf("换页: \f\n");
    printf("换行: 第一行\n第二行\n");
    printf("回车: abc\rdef\n");
    printf("水平制表: abc\tdef\n");
    printf("垂直制表: \v\n");
    printf("反斜线: \\\n");
    printf("单引号: \'\n");
    printf("双引号: \"\n");
    printf("问号: \?\n");
    printf("空字符: \0（不可见）\n");
    printf("8进制转义: \101\n"); // 输出 A
    printf("16进制转义: \x41\n"); // 输出 A
    return 0;
}

输出： 警报: 退格: abdef 换页: 换行: 第一行 第二行 def : abc 水平制表: abc def 垂直制表: 反斜线: 单引号: ’ 双引号: " 问号: ? 空字符: 8进制转义: A 16进制转义: A

关于 printf("8进制转义: \101\n");

• 在 C 语言中，\ 后面紧跟 1 到 3 位八进制数字构成的转义序列，表示一个特定的字符。
• 这里的 \101 就是一个八进制转义字符序列，八进制数 101 转换为十进制是 65，而在 ASCII 码表中，十进制值为 65 的字符对应的就是大写字母 A
• 所以当执行 printf("8进制转义: \101\n"); 时，会将 \101 解析为对应的字符 A 输出 。

关于 printf("16进制转义: \x41\n");

• 在 C 语言里，\x 后面紧跟 1 到 2 位十六进制数字构成的转义序列，表示一个特定的字符。
• 这里的 \x41 就是一个十六进制转义字符序列，十六进制数 41 转换为十进制也是 65，按照 ASCII 码表，十进制值为 65 的字符就是大写字母 A
• 因此在执行 printf("16进制转义: \x41\n"); 时，会把 \x41 解析为对应的字符 A 输出。

实型(浮点型)

实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。 在C语言中， 浮点型变量分为两种：

• 单精度浮点数(float)
• 双精度浮点数(double)

double型变量所表示的浮点数比 float 型变量更精确。

• 不以 f 结尾的常量是double类型。
• 以 f 结尾的常量(如3.14f)是float类型。

由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。

#include <stdio.h>

int main()
{
	//传统方式赋值
	float a = 3.14f; //或3.14F
	double b = 3.14;

	printf("a = %f\n", a);
	printf("b = %lf\n", b);

	//科学法赋值
	a = 3.2e3f; //3.2*1000 = 3200，e可以写E
	printf("a1 = %f\n", a);

	a = 100e-3f; //100*0.001 = 0.1
	printf("a2 = %f\n", a);

	a = 3.1415926f;
	printf("a3 = %f\n", a); //结果为3.141593

	return 0;
}

输出： a = 3.140000 b = 3.140000 a1 = 3200.000000 a2 = 0.100000 a3 = 3.141593

int main() 
{
    float m = 3.145;
    double n = 4.566545;

    printf("m=%5.2f\n", m);
    printf("n=%5.3lf\n", n);

    return 0;
}

输出： m= 3.14 n=4.567

#include <stdio.h>

int main() 
{
	float m = 3.145;
	double n = 4.566545;

	printf("m=%08.2f\n", m);
	printf("n=%08.3lf\n", n);

	return 0;
}

输出： m=00003.14 n=0004.567