C语言自学笔记_#include int main(){ puts("陆玖"); return 0

C语言学习笔记

第一个c语言程序

一般c语言的程序结构

#include <stdio.h>
int main()
{
   

	return 0;
}
1
2
3
4
5
6
7

#include <stdio.h>

int main()
{
   
    /*我的第一个C程序*/
    printf("hello world!\n");
    return 0;
}
1
2
3
4
5
6
7
8
9

c语言基本格式：

1. 有头文件， #include <stdio.h>是必要头文件（控制输出输入）
2. 有主函数main
3. 用分号进行断句
4. return 0——返回0值（退出程序）

程序结构

包含：

预处理器指令 函数 变量 语句&表达式 注释

#include <stdio.h>

int main()
{
   
    /*我的第一个C程序*/
    printf("hello world!\n");
    return 0;
}
1
2
3
4
5
6
7
8
9

上方代码的解析：

1. 程序的第一行 *#include * 是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。
2. 下一行 int main() 是主函数，程序从这里开始执行。
3. 下一行 /…/ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释。
4. 下一行 printf(…) 是 C 中另一个可用的函数，会在屏幕上显示消息 “Hello, World!”。
5. 下一行 return 0; 终止 main() 函数，并返回值 0。

基本语法

关键字

auto			声明自动变量
break			跳出当前循环
case			开关语句分支
char			声明字符型变量或函数返回值类型
const			定义常量，如果一个变量被 const 修饰，那么它的值就不能再被改变
continue		结束当前循环，开始下一轮循环
default			开关语句中的"其它"分支
do				循环语句的循环体
double			声明双精度浮点型变量或函数返回值类型
else			条件语句否定分支（与 if 连用）
enum			声明枚举类型
extern			声明变量或函数是在其它文件或本文件的其他位置定义
float			声明浮点型变量或函数返回值类型
for				一种循环语句
goto			无条件跳转语句
if				条件语句
int				声明整型变量或函数
long			声明长整型变量或函数返回值类型
register		声明寄存器变量
return			子程序返回语句（可以带参数，也可不带参数）
short			声明短整型变量或函数
signed			声明有符号类型变量或函数
sizeof			计算数据类型或变量长度（即所占字节数）
static			声明静态变量
struct			声明结构体类型
switch			用于开关语句
typedef			用以给数据类型取别名
unsigned		声明无符号类型变量或函数
union			声明共用体类型
void			声明函数无返回值或无参数，声明无类型指针
volatile		说明变量在程序执行中可被隐含地改变
while			循环语句的循环条件
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
32

字符格式化输出：

%d 十进制有符号整数 （用过）
%u 十进制无符号整数
%f 浮点数 （用过）
%s 字符串 （用过）
%c 单个字符
%p 指针的值
%e 指数形式的浮点数
%x, %X 无符号以十六进制表示的整数
%0 无符号以八进制表示的整数
%g 自动选择合适的表示法

数据类型

C语言数据类型

1. 基本类型
   • 整型
   • 字符型
   • 浮点型
   • 枚举类型
2. 指针类型
3. 构造类型
   • 数组类型
   • 结构体类型
   • 共用体类型
4. 空类型

输出

printf

整数类型

sizeof函数：得到对象的存储字节大小

#include <stdio.h>
#include <limits.h>
 
int main()
{
   
   printf("int 存储大小 : %lu \n", sizeof(int));
   
   return 0;
}


输出：
int 存储大小 : 4 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

浮点数

输出浮点类型占用的存储空间以及它的范围值：

#include <stdio.h>
#include <float.h>
 
int main()
{
   
   printf("float 存储最大字节数 : %lu \n", sizeof(float));		
    /*sizeof得到对象的存储字节大小*/
   printf("float 最小值: %E\n", FLT_MIN );						
    /* float库的宏，定义最大的有限浮点值，FLT_MAX的值为3.402823466e+38F*/
   printf("float 最大值: %E\n", FLT_MAX );						
    /* float库的宏，定义了最小的浮点值，FLT_MIN的值为1.175494351e-38F*/		
   printf("精度值: %d\n", FLT_DIG );							
    /* float库的宏，定义了舍入后不会改变表示的十进制数字的最大值,FLT_DIG的值为6*/
   
   return 0;
}


输出：
float 存储最大字节数 : 4 
float 最小值: 1.175494E-38
float 最大值: 3.402823E+38
精度值: 6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

变量

变量的意义是确定目标并提供存放的空间

变量的名称可以由字母、数字和下划线字符组成 （区分大小写，不能用关键字）

例子：

#include <stdio.h>
 
// 函数外定义变量 x 和 y
int x;		//建立变量x
int y;		//建立变量y
int addtwonum()		//建立addtwonum函数（后面是函数的内容）
{
   
    // 函数内声明变量 x 和 y 为外部变量
    extern int x;	
    extern int y;
    // 给外部变量（全局变量）x 和 y 赋值
    x = 1;			//引用到addtwonum函数时x，y才会赋值
    y = 2;
    return x+y;		//返回addtwonum函数得到的值
}
 
int main()
{
   
    int result;
    // 调用函数 addtwonum
    result = addtwonum();	//若不引用addtwonum函数，直接用x+y，会输出0
    
    printf("result 为: %d\n",result);
    return 0;
}


输出：
result 为: 3
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

在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可。 （关闭后怎么继续打开？）

//建立一个工程后，先新建一个文件1（1.c）
#include <stdio.h>

extern int x;
extern int y;
int addtwonum()
{
   
    return x+y;
}
//编译之后保存关闭
1
2
3
4
5
6
7
8
9
10
11

//新建一个文件2（2.c）
#include <stdio.h>
  
/*定义两个全局变量*/
int x=1;
int y=2;
int addtwonum();
int main(void)
{
   
    int result;
    result = addtwonum();
    printf("result 为: %d\n",result);
    return 0;
}
//完成后运行


输出：
result 为:3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

左值右值

**左值（lvalue）：**左值可以出现在赋值号左边或者右边，放在左边时候则会对其赋值

a = 10
b = a
1
2

**右值（rvalue）：**右值不能对其进行赋值操作

a = 10
10 = 20(会编译错误)
1
2

变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。

常量

整数常量

前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */
1
2
3
4
5
6
7

浮点常量

小数形式输出，e是指数形式

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */
1
2
3
4
5

字符常量

转义字符：

例子：

#include <stdio.h>

int main()
{
   
	printf("Hello\nWorld\n\n");

	return 0;
}


输出：
Hello   World

Press any key to continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

字符串常量

在 C 中，有两种简单的定义常量的方式：

1. 使用 #define 预处理器。
2. 使用 const 关键字。

#define 预处理器

#define identifier value
1

用define来定义函数的值或者类型

（需要在int main()之前声明定义函数）

#include <stdio.h>

#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'

int main()
{
   
	int area;

	area = LENGTH * WIDTH;
	printf("value of area : %d",area);
	printf("%c",NEWLINE);

	return 0;

}


输出：
value of area : 50
Press any key to continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

const关键字

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;
1

（一般在int main（）后面定义函数）

#include <stdio.h>

int main()
{
   
	const int LENGTH = 10;
	const int WIDTH = 5;
	const char NEWLINE = '\n';
	int area;
	
	area = LENGTH * WIDTH;
	printf("value of area:%d",area);
	printf("%c",NEWLINE);
	
	return 0;
}


输出：
value of area:50
Press any key to continue
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

变量的储存类别

auto

register

static

extern

• auto变量

  定义一个局部变量为自动时的，每次执行到定义该变量时，都会产生一个新的变量，并且对其重新进行初始化

  #include <stdio.h>
  
  void AddOne()
  {
       
  	auto int ilnt = 1;
  	ilnt = ilnt + 1;
  	printf("%d\n",ilnt);
  }
  
  int main()
  {
       
  	printf("第一次调用: ");
  	AddOne();
  	printf("第二次调用: ");
  	AddOne();
  
  	return 0;
  }
  
  
  输出：
  第一次调用: 2
  第二次调用: 2
  Press any key to continue
  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

• static变量

  static变量只会在第一次初始化变量，在随后的运行过程中，变量将会保持语句块上一次执行的值

  #include <stdio.h>
  
  void AddOne()
  {
       
  	static int ilnt=1;
  	ilnt=ilnt+1;
  	printf("%d\n",ilnt);
  }
  
  int main()
  {
       
  	printf("第一次调用: ");
  	AddOne();
  	printf("第二次调用: ");
  	AddOne();
  
  	return 0;
  }
  
  
  输出：
  第一次调用: 2
  第二次调用: 3
  Press any key to continue
  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

• register变量

  使用register变量修饰整型变量

  #include <stdio.h>
  
  int main()
  {
       
  	register int ilnt;
  	ilnt = 100;
  	printf("%d\n",ilnt);
  	return 0;
  }
  
  
  /*
  输出：
  100
  Press any key to continue
  */
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

• extern变量

  extern是外部储存变量

  先在iExtern1文件中定义一个外部整形iExtern变量

  然后在iExtern2文件中使用iExtern变量，并为其赋值，将其变量值显示到控制台

  //iExtern1文件:
  #include <stdio.h>
  
  int main()
  {
       
  	extern int iExtern;
  	printf("%d\n",iExtern);
  	return 0;
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10

  //iExtern2文件：
  #include <stdio.h>
  
  int iExtern = 100;
  1
  2
  3
  4

  输出：
  100
  Press any key to continue
  1
  2
  3

c运算符

算术运算符：

假设变量 A 的值为 10，变量 B 的值为 20

a++与++a的区别：

a++是先执行表达式后再自增，执行表达式时使用的是a的原值。

++a是先自增再执行表达式，执行表达式时使用的是自增后的a。

a = 10

c = a++
c = 10,a = 11

c = ++a
a = 11,c = 11
1
2
3
4
5
6
7

a–与--a的区别：

a–是先执行表达式后自减，执行表达式时使用的是a的原值。

–a是先自减再执行表达式，执行表达式时使用的是自减后的a。

a = 10

c = a--
c = 10,a = 9
c = --a
a = 9,c = 9
1
2
3
4
5
6

#include <stdio.h>
 
int main()
{
   int c;
   int a = 10;
   c = a++; 
   printf("先赋值后运算：\n");
   printf("Line 1 - c 的值是 %d\n", c );
   printf("Line 2 - a 的值是 %d\n", a );
   a = 10;
   c = a--; 
   printf("Line 3 - c 的值是 %d\n", c );
   printf("Line 4 - a 的值是 %d\n", a );
 
   printf("先运算后赋值：\n");
   a = 10;
   c = ++a; 
   printf("Line 5 - c 的值是 %d\n", c );
   printf("Line 6 - a 的值是 %d\n", a );
   a = 10;
   c = --a; 
   printf("Line 7 - c 的值是 %d\n", c );
   printf("Line 8 - a 的值是 %d\n", a );
 
}


输出：
先赋值后运算：
Line 1 - c 的值是 10		第1条，输出c的值
Line 2 - a 的值是 11
Line 3 - c 的值是 10
Line 4 - a 的值是 9
先运算后赋值：
Line 5 - c 的值是 11
Line 6 - a 的值是 11
Line 7 - c 的值是 9
Line 8 - a 的值是 9
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
32
33
34
35
36
37
38
39

可用的算术运算符：

#include <stdio.h>

int main()
{
   
	int a = 21;
	int b = 10;
	int c;
	
	c = a + b;
	printf("Line 1 - c 的值是 %d\n",c);
	c = a - b;
	printf("Line 2 - c 的值是 %d\n",c);
	c = a * b;
	printf("Line 3 - c 的值是 %d\n",c);
	c = a / b;
	printf("Line 4 - c 的值是 %d\n",c);
	c = a % b;
	printf("Line 5 - c 的值是 %d\n",c);
	c = a++;
	printf("Line 6 - c 的值是 %d\n",c);
	c = a--;
	printf("Line 7 - c 的值是 %d\n",c);

}


/*
输出：
Line 1 - c 的值是 31				第一条语句，输出c的值
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 21
Line 7 - c 的值是 22
Press any key to continue
*/
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
32
33
34
35
36
37
38

关系运算符：

假设变量 A 的值为 10，变量 B 的值为 20