高级语言-》汇编语言-》机器语言
gcc main.c && ./a.out 表示先gcc main.c，再在这个基础上运行./a.out，&&表示运行的承接
1
2
3
| \\打印\本身
\'打印小点'
\"打印双引号"
|
可以简单理解变量为：内存需要找到一个位置存放CPU要处理的数据，每个数据都有一个地址，这些地址实际上就是一些数字，计算机很擅长处理这些，我们为了更好的标记这些数据，就给这些数据贴上了标签，这个标签就是变量。它的核心作用就是让人类和编译器能通过名字（而不是原始数字地址）操作数据。
变量首字母只能用字母和下划线来命名
\斜杠的作用:
下面这个代码会报错，因为不加操作的话，printf打印的东西需要双引号都包含着在同一行，
1
2
3
4
5
6
7
| #include <stdio.h>
int main(void)
{
printf("
");
}
|
解决方法：加上一个\，就可以起到高速编译器他们是一起的，只是空间不够换写了一行罢了
1
2
3
4
5
6
7
| #include <stdio.h>
int main(void)
{
printf("\
");
}
|
传统的C语言有32个关键字。C99标准增加了5个关键字，一共37个。C11标准增加了7个，一共44个。
int a 整形 //在内存中找到一个整形大小的位置，并且给他命名为a
char b 字符型 //在内存中找到一个字节大小的位置，并且给他命名为b
float c 单精度浮点型 //在内存中找到一个单精度浮点数型数据大小的位置，并且命名为c
double d 双精度浮点型//在内存中找到一个双精度浮点型数据大小的位置，并且命名为d
简单来说,double比float可以容纳更多的小数位
什么是常量呢？在程序运行的过程中，它的值不能够被改变，称为常量。如字符’a’，数字520，小数3.14，这些都是常量，因为它们仅代表一个具体的值，并且不能够被改变。
C语言中常见的常量如下。
- （1）整型常量：520, 1314, 123。
- （2）实型常量：3.14, 5.12, 8.97。
- （3）字符常量。·普通字符：’L’, ‘o’, ‘v’, ‘e’。
·转义字符：’\n’, ‘\t’, ‘\b’。
- （4）字符串常量：”FishC”。
- （5）符号常量：使用之前必须先定义。
符号常量：
#define 标识符 常量
定义符号常量可以通过宏定义（#define）或 const关键字
编译器会自动识别define定义的那些变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| #include <stdio.h>
#define URL "http://www.fishc.com"
#define NAME "鱼C工作室"
#define BOSS "小甲鱼"
#define YEAR 2010
#define MONTH 5
#define DAY 20
int main(void)
{
printf("%s成立于%d年%d月%d日\n", NAME, YEAR, MONTH, DAY);
printf("%s是%s创立的……\n", NAME, BOSS);
printf("%s的域名是%s\n", NAME, URL);
return 0;
}
|
转移字符’\0’作用:
C语言的五种数据类型：
让整数占用更少的内存可以在int前面加short，让整数占用更多内存可以在int前面加long，例如：
1
2
| short int a = 10;
long int b = 102929;
|
这样a只占用2个字节的内存，而b可能（是可能）会占用8个字节的内存。
也可以将int省略，只写short、long，如下：
1
2
3
| short a = 10;
long b = 102929;
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| #include <stdio.h>
int main(void)
{
printf("int = %d\n", sizeof(int));
printf("short int = %d\n", sizeof(short int));
printf("long int = %d\n", sizeof(long int));
printf("long long int = %d\n", sizeof(long long int));
printf("char = %d\n", sizeof(char));
printf("_Bool = %d\n", sizeof(_Bool));
printf("float = %d\n", sizeof(float));
printf("double = %d\n", sizeof(double));
printf("long double = %d\n", sizeof(long double));
return 0;
}
|
1
2
3
4
5
6
7
8
9
| int = 4
short int = 2
long int = 8
long long int = 8
char = 1
_Bool = 1
float = 4
double = 8
long double = 16
|
int i
我们可以使用sizeof(int) sizeof(i)，直接可以sizeof()数据类型和变量
short、int、long等整型类型默认带符号，等价于 signed short。
除非显式声明为 unsigned short，否则编译器会假定其为有符号类型。
1
2
3
4
5
6
7
8
9
| #include<stdio.h>
int main(void){
short i=-1;
unsigned short j=-1;
printf("%d\n",i);
printf("%d\n",j);
return 0;
}
|
来看一个代码:
1
2
3
4
5
6
7
8
9
10
11
| #include <stdio.h>
#include <math.h>
int main(void)
{
nt result = pow(2, 32) - 1;
printf("result = %u\n", result);
return 0;
}
|
报错: warning: overflow in conversion from ‘double’ to ‘int’ changes value from ‘4.294967295e+9’ to ‘2147483647’ [-Woverflow]
报错显示已经溢出了
修正结果：
1
2
3
4
5
6
7
8
9
10
11
| #include <stdio.h>
#include <math.h>
int main(void)
{
unsigned int result = pow(2, 32) - 1;
printf("result = %u\n", result);
return 0;
}
|
因为使用到了math库，在编译的时候要加上一个-lm，表示链接作用
无符号类型（unsigned）的输出格式符确实是 %u，但具体使用时需根据数据类型选择匹配的格式符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
| unsigned int
%u
printf("%u", x);
最常用，默认无符号整型
unsigned short
%hu
printf("%hu", (unsigned short)x);
需加 h前缀（short是"half word"）
unsigned long
%lu
printf("%lu", (unsigned long)x);
32/64位系统通用
unsigned long long
%llu
printf("%llu", (unsigned long long)x);
C99标准引入
|
为什么一字节为-128到+127
1000000表示最小值-128，00000000为0，0111111为最大值127
计算机是使用补码存放数据的
字符如果用%d表示的话，那就是一个ASCALL码
1
2
3
4
5
6
7
8
9
| #include <stdio.h>
int main(void)
{
char a='c';
printf("%c is %d",a,a);
return 0;
}
|
1
2
3
4
5
6
7
8
9
10
| #include <stdio.h>
int main(void)
{
char a = 70, b = 105, c = 115, d = 104, e = 67;
printf("%c%c%c%c%c\n", a, b, c, d, e);
return 0;
}
|
仔细看一下上面的知识点，%c和整数可以相互转换
编程的时候一定要小心一些变量的定义，例如:下面这个是不小心char的定义的
1
2
3
4
5
6
7
8
9
10
11
| #include <stdio.h>
int main(void)
{
char height;
height = 170;
printf("小甲鱼的身高是%d厘米！\n", height);
return 0;
}
|
字符串实际上就是一串字符，只需要在内存当中找到一块空间，存放一串字符，就是组成了字符串，但是注意最后面要加一个’\0’，让编译器知道字符串到这个地方就终止了
可以使用下面三种方法定义字符串：
1
2
3
4
5
6
7
8
9
10
11
12
| #include <stdio.h>
int main(void)
{
char a[6] = {'F', 'i', 's', 'h', 'C', '\0'};
char b[]="FishC";
char c[]={"FishC"};
printf("%ld\n",sizeof(b)/sizeof(char));
return 0;
}
|
上面这个代码会发生什么呢：会打印3.000000
当一个运算符的几个操作数类型不同时，编译器需要将它们转换为相同的数据类型才能进行运算。通常情况下，编译器会将占用“坑位”较小的操作数转换为占用“坑位较大的操作数的数据类型，再进行运算。这样做是为了确保计算的精确度。
当遇到类似 1+2.0 这种两种不同数据类型的操作数的运算时，编译器首先将1转换为浮点型 1.0，然后再与2.0相加，得到同样为浮点型的结果3.0。
因为1.0所占坑位比1的大
也可以进行强类型转换
printf(“%d\n”,1+(int)1.0);
那下面这个会打印什么呢：
printf(“%d\n”,1+(int)1.8);会打印2，C语言编译器不会四舍五入，他会直接取整数部分，舍弃掉小数部分