一、基础 - 1.关键字和数据类型 - 《C 语言基础知识整理》

一、关键字
- 1.数据类型相关的关键字
- 2. 存储相关关键字
二、数据类型

一、关键字

1.数据类型相关的关键字

用于定义变量或者类型
类型变量名；
char 、short、int 、long 、 float、double、
struct、union、enum 、signed、unsigned、void

1、 char 字符型，用 char 定义的变量是字符型变量，占 1 个字节
char ch=’a’; =为赋值号

2、 short 短整型 ,使用 short 定义的变量是短整型变量，占 2 个字节

short int a=11;  //-32768 - ---32767

3、 int 整型，用 int 定义的变量是整型变量，在 32 位系统下占 4 个字节，在 16 平台下占 2 个字节

int a=44;  //-20 亿---20 亿

4、 long 长整型用 long 定义的变量是长整型的，在 32 位系统下占 4 个字节

long int a=66

5、 float 单浮点型（实数），用 float 定义的变量是单浮点型的实数，占 4 个字节

float b=3.8f;

6、 double 双浮点型（实数），用 double 定义的变量是双浮点型的实数，占 8 个字节

double b=3.8;

7、 struct 这个关键字是与结构体类型相关的关键字，可以用它来定义结构体类型，以后讲结构体的时候在讲
8、 union 这个关键字是与共用体（联合体）相关的关键字，以后再讲
9、 enum 与枚举类型相关的关键字以后再讲
10、signed 有符号(正负)的意思
在定义 char 、整型（short 、int、long）数据的时候用 signed 修饰，代表咱们定义的数据是有符号的，可以保存正数，也可以保存负数
例：signed int a=10;

signed int b=-6;

注意：默认情况下 signed 可以省略即 int a=-10;//默认 a 就是有符号类型的数据
11、unsigned 无符号的意思
在定义 char 、整型（short 、int、long）数据的时候用 unsigned 修饰，代表咱们定义的数据是无符
号类型的数据只能保存正数和 0。

unsigned int a=101; unsigned int a=-101; //错误

12、void 空类型的关键字
char、int 、float 都可以定义变量
void 不能定义变量，没有 void 类型的变量
void 是用来修饰函数的参数或者返回值，代表函数没有参数或没有返回值
例：
void fun(void)
{
}
代表 fun 函数没有返回值，fun 函数没有参数

2. 存储相关关键字

register、static、const、auto、extern
1、register 是寄存器的意思，用 register 修饰的变量是寄存器变量，
即：在编译的时候告诉编译器这个变量是寄存器变量，尽量将其存储空间分配在寄存器中。
注意：
(1):定义的变量不一定真的存放在寄存器中。
(2)：cpu 取数据的时候去寄存器中拿数据比去内存中拿数据要快
(3)：因为寄存器比较宝贵，所以不能定义寄存器数组
(4)：register 只能修饰字符型及整型的，不能修饰浮点型

register char ch;
register short int b; 
register int c; 
register float d;//错误的

(5)：因为 register 修饰的变量可能存放在寄存器中不存放在内存中，所以
不能对寄存器变量取地址。因为只有存放在内存中的数据才有地址

register int a; 
int *p; 
p=&a;//错误的，a 可能没有地址

2、static 是静态的意思
static 可以修饰全局变量、局部变量、函数
这个以后的课程中重点讲解
3、const
const 是常量的意思
用 const 修饰的变量是只读的，不能修改它的值

const int a=101;//在定义 a 的时候用 const 修饰，并赋初值为 101

从此以后，就不能再给 a 赋值了
a=111;//错误的
const 可以修饰指针，这个在以后课程中重点讲解

二、数据类型

2.2.1 基本类型
char 、short int 、int、long int、float、double

扩展：常量和变量
常量：在程序运行过程中，其值不可以改变的量
例：100 ‘a’ “hello”

整型 100，125，-100，0
实型 3.14 ， 0.125f，-3.789
字符型 ‘a’, ‘b’, ‘2’
字符串 “a” “ab” “134”

变量：其值可以改变的量被称为变量
int a=100;
a=101;

字符数据

字符常量：
直接常量：用单引号括起来，如：’a’、’b’、’0’等.
转义字符: 以反斜杠’\’开头, ‘\n’代表换行 ‘\t’横向跳格 ‘\‘代表的是 \ +

字符变量：
用 char 定义，每个字符变量被分配一个字节的内存空间。字符值以 ASCII 码的形式存放在变量的内存单元中;
注：char a;
a = ‘x’;
a 变量中存放的是字符’x’的 ASCII :120
即 a=120 跟 a=’x’在本质上是一致的.

字符串常量

是由双引号括起来的字符序列，如“CHINA”、”哈哈哈”
“C program”，“$12.5”等都是合法的字符串常量.

整型数据

整型常量:（按进制分）：

十进制:以正常数字 1-9 开头，如 457789
八进制:以数字 0 开头，如 0123
十六进制：以 0x 开头，如 0x1e

a=10，b=11,c=12, d=13,e=14,f=15
整型变量:

有/无符号短整型(un/signed) short(int) 2 个字节
有/无符号基本整型(un/signed) int 4 个字节
有/无符号长整型(un/signed) long (int) 4 个字节 (32 位处理器)

实型数据(浮点型)

实型常量
实型常量也称为实数或者浮点数
十进制形式: 由数字和小数点组成:0.0、0.12、5.0
指数形式： 123e3 代表 12310 的三次方
123e-3
不以 f 结尾的常量是 double 类型
以 f 结尾的常量(如 3.14f)是 float 类型
实型变量
单精度(float)和双精度(double)3.1415926753456
float 型: 占 4 字节，7 位有效数字,指数-37 到 38
3333.333 33
double 型: 占 8 字节，16 位有效数字,指数-307 到 308
*格式化输出字符：
%d 十进制有符号整数 %u 十进制无符号整数
%x, 以十六进制表示的整数 %o 以八进制表示的整数
%f float 型浮点数 %lf double 型浮点数
%e 指数形式的浮点数
%s 字符串 %c 单个字符
%p 指针的值

特殊应用：
%3d %03d %-3d %5.2f

%3d:要求宽度为 3 位，如果不足 3 位，前面空格补齐;如果足够 3 位，此语句无效
%03d：要求宽度为 3 位，如果不足 3 位，前面 0 补齐;如果足够 3 位，此语句无效
%-3d: 要求宽度为 3 位，如果不足 3 位，后面空格补齐;如果足够 3 位，此语句无效
%.2f：小数点后只保留 2 位

构造类型

概念：由若干个相同或不同类型数据构成的集合，这种数据类型被称为构造类型
例：int a[10];
数组、结构体、共用体、枚举

类型转换

数据有不同的类型，不同类型数据之间进行混合运算时必然涉及到类型的转换问题.
转换的方法有两种：
自动转换:
遵循一定的规则,由编译系统自动完成.
强制类型转换：
把表达式的运算结果强制转换成所需的数据类型
自动转换的原则：
1、占用内存字节数少(值域小)的类型，向占用内存字节数多(值域大)的类型转换,以保证精度不降低.
2、转换方向

1) 当表达式中出现了 char 、short int 、int 类型中的一种或者多种，没有其他类型了参加运算的成员全部变成 int 类型的参加运算，结果也是 int 类型的。

#include <stdio.h>
int main(int argc, char *argv[])
{
    printf("%d\n",5/2); 
    return 0;
}
//2

2) 当表达式中出现了带小数点的实数，参加运算的成员全部变成 double 类型的参加运算，结果也是 double 型。

#include <stdio.h> 
int main(int argc, char *argv[]){ 
    printf("%lf\n",5.0/2); return 0;
}
//2.500000

3) 当表达式中有有符号数也有无符号数，参加运算的成员变成无符号数参加运算结果也是无符号数.(表达式中无实数)

#include <stdio.h> 
int main(int argc, char *argv[]) { 
    int a=-8; 
    unsigned int b=7;
    if(a+b>0) { 
        printf("a+b>0\n"); 
    }else { 
     printf("a+b<=0\n"); 
    }
    printf("%x\n",(a+b)); 
    printf("%d\n",(a+b)); 
    return 0; 
}
/*
a+b>0
ffffffff
-1
*/

4) 在赋值语句中等号右边的类型自动转换为等号左边的类型

#include <stdio.h>
int main(int argc, char *argv[]) { 
    int a; 
    float b=5.8f;//5.8 后面加 f 代表 5.8 是 float 类型，不加的话，认为是 double 类型 
    a=b; 
    printf("a=%d\n",a); 
    return 0; }
//a=5

5) 注意自动类型转换都是在运算的过程中进行临时性的转换，并不会影响自动类型转换的变量的值和其类型

#include <stdio.h>
int main(int argc, char *argv[]) { 
    int a; 
    float b=5.8f;//5.8 后面加 f 代表 5.8 是 float 类型，不加的话，认为是 double 类型 
    a=b; 
    printf("a=%d\n",a);
    printf("b=%f\n",b);//b 的类型依然是 float 类型的，它的值依然是 5.8
    return 0; 
}
/*
a=5
b=5.800000
*/

强制转换:通过类型转换运算来实现
(类型说明符) (表达式)
功能：
把表达式的运算结果强制转换成类型说明符所表示的类型
例如：
(float)a; // 把 a 的值转换为实型
(int)(x+y); // 把 x+y 的结果值转换为整型
注意:
类型说明符必须加括号

#include <stdio.h>
int main(int argc, char *argv[]) {
    float x=0; 
    int i=0;
    x=3.6f;
    i = x;
    i = (int)x; 
    printf("x=%f,i=%d\n",x,i); 
    return 0; 
}
//  x=3.600000,i=3

说明：
无论是强制转换或是自动转换，都只是为了本次运算的需要，而对变量的数据长度进行的临时性转换，而不改变数据定义的类型以及它的值