C语言学习笔记
第一个c语言程序
一般c语言的程序结构
#include <stdio.h>
int main()
{
return 0;
}
#include <stdio.h>
int main()
{
/*我的第一个C程序*/
printf("hello world!\n");
return 0;
}
c语言基本格式：
- 有头文件， #include <stdio.h>是必要头文件（控制输出输入）
- 有主函数main
- 用分号进行断句
- return 0——返回0值（退出程序）
程序结构
包含：
预处理器指令 函数 变量 语句&表达式 注释
#include <stdio.h>
int main()
{
/*我的第一个C程序*/
printf("hello world!\n");
return 0;
}
上方代码的解析：
- 程序的第一行 *#include * 是预处理器指令，告诉 C 编译器在实际编译之前要包含 stdio.h 文件。
- 下一行 int main() 是主函数，程序从这里开始执行。
- 下一行 /…/ 将会被编译器忽略，这里放置程序的注释内容。它们被称为程序的注释。
- 下一行 printf(…) 是 C 中另一个可用的函数，会在屏幕上显示消息 “Hello, World!”。
- 下一行 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 循环语句的循环条件
字符格式化输出：
%d 十进制有符号整数 （用过）
%u 十进制无符号整数
%f 浮点数 （用过）
%s 字符串 （用过）
%c 单个字符
%p 指针的值
%e 指数形式的浮点数
%x, %X 无符号以十六进制表示的整数
%0 无符号以八进制表示的整数
%g 自动选择合适的表示法
数据类型
C语言数据类型
- 基本类型
- 整型
- 字符型
- 浮点型
- 枚举类型
- 指针类型
- 构造类型
- 数组类型
- 结构体类型
- 共用体类型
- 空类型
输出
printf
整数类型
| 类型 | 存储大小 | 值范围 |
|---|---|---|
| char | 1 字节 | -128 到 127 或 0 到 255 |
| unsigned char | 1 字节 | 0 到 255 |
| signed char | 1 字节 | -128 到 127 |
| int | 2 或 4 字节 | -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647 |
| unsigned int | 2 或 4 字节 | 0 到 65,535 或 0 到 4,294,967,295 |
| short | 2 字节 | -32,768 到 32,767 |
| unsigned short | 2 字节 | 0 到 65,535 |
| long | 4 字节 | -2,147,483,648 到 2,147,483,647 |
| unsigned long | 4 字节 | 0 到 4,294,967,295 |
sizeof函数：得到对象的存储字节大小
#include <stdio.h>
#include <limits.h>
int main()
{
printf("int 存储大小 : %lu \n", sizeof(int));
return 0;
}
输出：
int 存储大小 : 4
浮点数
| 类型 | 存储大小 | 值范围 | 精度 |
|---|---|---|---|
| float | 4 字节 | 1.2E-38 到 3.4E+38 | 6 位小数 |
| double | 8 字节 | 2.3E-308 到 1.7E+308 | 15 位小数 |
| long double | 16 字节 | 3.4E-4932 到 1.1E+4932 | 19 位小数 |
输出浮点类型占用的存储空间以及它的范围值：
#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
变量
变量的意义是确定目标并提供存放的空间
变量的名称可以由字母、数字和下划线字符组成 （区分大小写，不能用关键字）
例子：
#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
在一个源文件中引用另外一个源文件中定义的变量，我们只需在引用的文件中将变量加上 extern 关键字的声明即可。 （关闭后怎么继续打开？）
//建立一个工程后，先新建一个文件1（1.c）
#include <stdio.h>
extern int x;
extern int y;
int addtwonum()
{
return x+y;
}
//编译之后保存关闭
//新建一个文件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
左值右值
**左值（lvalue）：**左值可以出现在赋值号左边或者右边，放在左边时候则会对其赋值
a = 10
b = a
**右值（rvalue）：**右值不能对其进行赋值操作
a = 10
10 = 20(会编译错误)
变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。
常量
整数常量
前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。
整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。
85 /* 十进制 */
0213 /* 八进制 */
0x4b /* 十六进制 */
30 /* 整数 */
30u /* 无符号整数 */
30l /* 长整数 */
30ul /* 无符号长整数 */
浮点常量
小数形式输出，e是指数形式
3.14159 /* 合法的 */
314159E-5L /* 合法的 */
510E /* 非法的：不完整的指数 */
210f /* 非法的：没有小数或指数 */
.e55 /* 非法的：缺少整数或分数 */
字符常量
转义字符：
| \ | \ 字符 |
|---|---|
| ’ | ’ 字符 |
| " | " 字符 |
| ? | ? 字符 |
| \a | 警报铃声 |
| \b | 退格键 |
| \f | 换页符 |
| \n | 换行符 |
| \r | 回车 |
| \t | 水平制表符（一个tab键） |
| \v | 垂直制表符 |
| \ooo | 一到三位的八进制数 |
| \xhh . . . | 一个或多个数字的十六进制数 |
例子：
#include <stdio.h>
int main()
{
printf("Hello\nWorld\n\n");
return 0;
}
输出：
Hello World
Press any key to continue
字符串常量
在 C 中，有两种简单的定义常量的方式：
- 使用 #define 预处理器。
- 使用 const 关键字。
#define 预处理器
#define identifier value
用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
const关键字
您可以使用 const 前缀声明指定类型的常量，如下所示：
const type variable = value;
（一般在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
变量的储存类别
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 -
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 -
register变量
使用register变量修饰整型变量
#include <stdio.h> int main() { register int ilnt; ilnt = 100; printf("%d\n",ilnt); return 0; } /* 输出： 100 Press any key to continue */ -
extern变量
extern是外部储存变量
先在iExtern1文件中定义一个外部整形iExtern变量
然后在iExtern2文件中使用iExtern变量，并为其赋值，将其变量值显示到控制台
//iExtern1文件: #include <stdio.h> int main() { extern int iExtern; printf("%d\n",iExtern); return 0; }//iExtern2文件： #include <stdio.h> int iExtern = 100;输出： 100 Press any key to continue
c运算符
算术运算符：
假设变量 A 的值为 10，变量 B 的值为 20
| + | 把两个操作数相加 | A + B 将得到 30 |
|---|---|---|
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 分子除以分母 | B / A 将得到 2 |
| % | 取模运算符，整除后的余数 | B % A 将得到 0 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| – | 自减运算符，整数值减少 1 | A-- 将得到 9 |
a++与++a的区别：
a++是先执行表达式后再自增，执行表达式时使用的是a的原值。
++a是先自增再执行表达式，执行表达式时使用的是自增后的a。
a = 10
c = a++
c = 10,a = 11
c = ++a
a = 11,c = 11
a–与--a的区别：
a–是先执行表达式后自减，执行表达式时使用的是a的原值。
–a是先自减再执行表达式，执行表达式时使用的是自减后的a。
a = 10
c = a--
c = 10,a = 9
c = --a
a = 9,c = 9
#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
可用的算术运算符：
#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
*/
关系运算符：
假设变量 A 的值为 10，变量 B 的值为 20
最低0.47元/天 解锁文章
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
