目录
1.首先认识一下c语言
计算机语言--任何计算机进行交流的语言
C/C++/Java/Python 都是计算机语言
而就像 汉语、英语 --是人和人交流的语言
C语言的主要用途是--底层开发
上层软件 应用软件（qq，网盘）
操作系统（winidows/linux/mac）
底层软件 驱动层
电脑--硬件
举个栗子，Linux系统就是用C语言写出来的
计算机语言的发展：
机器语言 ------>汇编语言 ---------->B语言------>C语言
科学家 -----------助记符
1001 -ADD
0010 -JMP
0101 -MOV
后来由于不同公司 随意改C语言
A公司---1.0版本
B公司---1.1版本
.....
这样就出现了C语言国际标准-------ANSI-C-----C89,C98,C99....
C11,C17
这样机器语言就从低级语言发展为了高级语言
其编译器主要有Clang、GCC、WIN-TC、SUBLIME、MSVC、Turbo C等
2.写出第一个C语言代码
工具：VS2019-IDE-集成开发环境
编辑，编译，调试
1. 创建项目
2.创建源文件
3.写代码 xxxx.c--源文件
xxxx.h--头文件
创建源文件：
在屏幕上打印“hello world”
#include<stdio.h>
//stdio 标准输入输出
//printf是库函数
//使用库函数就要包含对应的头文件
//main是程序的入口
//main函数有且仅有一个（只有一个入口）
int main()
{
printf("hello world\n");//输出
return 0;//返回0
//调试是 fn f5 运行是ctrl f5- 编译+链接+运行
}
3.C语言数据类型
char //字符数据类型 1字节
short //短整型 -32768~32767 2字节
int //整型 4字节
long //长整型 4字节
long long //更长的整型 8字节
float //单精度浮点数 4字节
double //双精度浮点数 8字节
★★ 注意变量的使用
1.float类型
float a=1.5;//此时会警告（截断问题）
//因为编译器会把小数自动识别为double类型 那么就可能出现截断问题（4米的东西放2米的盒子）//因此定义float类型应该在小数后面加个f
float a=1.5f2. 字符类型（char）
char ch=‘w’；//注意‘’内为一个字符
char sh="我是猪"；//字符串为双引号4.变量、常量
生活中有些值是不变的 如身份证，血型，性别等
在c语言中 不变的量叫做常量
可变的量叫变量
//创建变量就是 向内存申请了）空间 如图
4.1 定义变量的方法
int age=10;
int weight=125.5f;
char ch='w';4.2 变量的分类
- 局部变量
- 全局变量
局部变量：在大括号内部定义的变量
全局变量：在大括号外部定义的变量
#include<stdio.h>
int global=2019;
int main()
{
int local=2018;//局部变量
int global =2020;
printf("global=%d\n",global);//这时候打印出来的 global等于2020
return0;
}总结：当全局变量和局部变量发生矛盾的时候 局部变量优先
4.3 变量的使用
举个例子：用户输入两个数 实现两个数相加并输出其和
int num1 = 0;
int num2 = 0;
//输入
scanf("%d%d", &num1, &num2);
//求和
int sum = num1 + num2;
//输出
printf("sum=%d\n", sum);PS：关于scanf的不安全问题 请看另一篇文章
4.4 变量的作用域和生命周期
作用域：
作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/有用的 而限定这个名字的可用性的代码范围就是这个名字的作用域
- 局部变量的作用域是变量所在的局部范围
- 全局变量的作用域是整个工程
int main()
{
{
int a=100;
printf("a=%d\n",a);
}
printf("a=%d\n",a);
//此时会报错 因为会显示括号外部的a是未定义
return 0;
}
如果想要在不同的源文件中使用全局变量 需要声明一下（extern）
生命周期：
变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
- 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
- 全局变量的生命周期是：和程序的生命周期一样
#include<stdio.h>
int a=10;
void test()
{
printf ("test: %d\n", a);
}
int main()
{
test();
return 0;
}可以看到作为全局变量的变量a一直存在到程序结束
4.5 常量
分类
- 字面常量
- const修饰的常量
- #define定义的常变量
- 枚举常量
4.5.1字面常量
3.14;//字面常量
1000;//字面常量4.5.2const修饰的常变量
const float pai=3.14f;//这pai是被const修饰的常变量
pai=6.18;//虽然pai是个变量形式 但是它具有const修饰的常属性 因此不可以被修改
printf("%d\n",pai);
//若打印，会发生报错
const修饰的常变量 虽然具有常属性 但本质还是个变量
因此不可以作为数组长度的参数
4.5.3#define定义的标识符常量
栗子：
#define MAX 100//注意格式 没有等号也没有分号！！！
printf("max=%d\n",MAX);4.5.4枚举常量（enum）
enum Sex
{
MALE,//注意细节：用逗号
FEMALE,
SELECT//最后一个不用逗号
}
int main()
{
printf("%d\n"，MALE);
printf("%d\n",FEMALE);
printf("%d\n",SELECT);
}
//注意 枚举常量的默认 是从0开始的，依次向下递增15.字符串+转义字符+注释
5.1字符串
"hello world\n"这种 由双引号引起来的一串字符曾为字符串字面值（string literal）,或者简称位字符串
注：字符串的结束标志是一个 \0 的转义字符，不算做字符串的内容（\0十分重要）
#include<stdio.h>
int main()
{
char arr1[]="bit";
char arr2[]={'b','i','t'};
char arr3[]={'b','i','t','\0'};
printf("%s\n",arr1);
printf("%s\n",arr2);
printf("%s\n",arr3);
return 0;
}打印结果是：
原因是 字符数组arr2中没有\0结束标志
因为内存是连续的 该数组 bit 前后都是有内存的 因此 计算机会自动向后读 直到读到\0才会结束
因此才会打印出一串随机值
同理如果用strlen函数计算该数组的长度 那么输出的结果也是一个随机数字
5.2转义字符
假如需要打印一个目录 c:\code\test.c
printf("c:\code\test.c");
那么运行结果是：
因此需要引入转移字符
转义字符：
\? 在书写连续多个问号时使用，防止他们被解析成三字母词
\' 用于表示字符常量 '
\" 用于表示一个字符串内部的双引号
\\ 用于表示一个反斜杠，防止被解释为一个转义字符序列
\a 警告字符 蜂鸣（输出你的电脑会响一下）
\b 退格符
\f 进纸符
\n 换行符
\r 回车
\t 水平制表符
\v 垂直制表符
\ddd ddd表示1-3个八进制的数字 如\130 (对应的130换算成十进制从ASCII码表里找到对应符号)
注意：\138表示 两个字符 \13是一个 因为八进制不会出现8
\xdd dd表示两个十六进制数字，如：\x30
//打印一个单引号'
printf("%c\n",'\'');
//打印一个字符串 字符串的内容是一个双引号
printf("%s\n","\"");
//后面的''以及""都是对应前面输出格式的形式 字符类型%c 对应''
// 字符串类型%s 对应""5.3补充
‘0’--字符0 - ASCII码值为48
‘\0’ --转义字符--ASCII码值是0
0 --数字0-- 0
EOF -end of file 文件结束标志 ->实质上是-1（#define EOF -1）
这就涉及到了scanf的多行输入问题：
首先要知道 scanf函数--成功读取几个数据那么就返回几
int a=0;
int b=0;
printf("%d\n",scanf("%d%d",&a,&b));
//输出结果为2因此如果实现scanf的多行输入 就只需要使用循环 不让scanf返回值为EOF即可
int a=0,b=0;
while(scanf("%d%d",&a,&b)!=EOF)//即 只要成功输入了 就进入循环打印这两个值 然后继续循环
{
printf("%d %d\n",a,b);
}
return 0;6.注释
- 代码中有不需要的代码可以直接删除，也可以注释掉
- 代码中有些代码比较难懂，可以加一下注释文字
注释风格
- C语言风格 /**********/
- 缺点：不能嵌套注释
- C++风格 //**********
- 可以注释一行也可以注释多行
7.选择语句
顾名思义：
if......---->怎么样
else ......>怎么样
#include<stdio.h>
int main()
{
int a=0;
printf("你会坚持学习吗?(选择1或0)"\n);
scanf("%d",&a);
if(a==1)
{
printf("你会有奖学金\n");
}
else
{
printf("你会挂科\n");
}
return 0;
}
8.循环语句
有些事情需要在某个条件没达成之前一直做下去 那么这就需要循环语句了
例如
int main()
{
int day = 0;
printf("每天学习\n");
while (day<20000)
{
//if (day == 1000) 把if条件放入循环
// break;
printf("学习了:%d天\n", day);
day++;
}
if (day >= 20000)
printf("奖学金\n");
return 0;9.函数
函数的作用就是在代码十分复杂的时候 进行简化代码，实现代码复用
可能写出该函数需要花费一些时间，但是调用就显得十分简单
例子（利用函数实现两个数相加）
int Add(int x, int y)
{
int z = 0;
z = x + y;
return z;
}
int main()
{
int n1 = 0;
int n2 = 0;
int sum = 0;
//输入
scanf("%d%d", &n1, &n2);
//计算求和
//sum = n1 + n2;
//函数的方式来实现
sum = Add(n1, n2);
//输出
printf("sum = %d\n", sum);
return 0;
}10.数组
顾名思义 存储一组数
C语言中数组的定义是：一组相同类型元素的集合
10.1数组定义
int arr[10]={1,2,3,4,5,6,7,8,9,10};//定义一个整型数组，最多放10个元素10.2数组的下标
C语言规定：数组的每个元素都有一个下标，并且下标是从0开始的
可以通过下标来访问数组的元素
int arr[10]={0};//定义一个最多存储10个元素的整型数组
//下标的范围分别是0~9 
10.3数组的使用
例子：打印出数组各个元素（需要用到循环结构）
int arr[10] = {10,11,12,13,14,15,16,17,18,19};//初始化一个数组
//0 1 2 ...
int i = 0;
while (i < 10)
{
scanf("%d", &arr[i]);
i++;
}//依次输入10个元素
//i=10
i = 0;//重新赋值i为0
while (i < 10)
{
printf("%d ", arr[i]);
i++;
}//输出10个元素10.4关于数组需要注意的地方
- 定义数组的时候如果数组{}里不初始化的话 需要标明数组的大小
- 如果标明数组的大小那么可以不初始化 直接arr[]={}即可
- 定义数组的时候 如 char arr[ 5]={};------[ ]（即数组的大小）为常量，即使为const定义的常变量也不可以 因为本质还是变量
- 在别的编译器（VS以外）支持C99标准的--有变长数组--数组大小可以是变量
11.操作符
认识一下：
算术操作符
+ - * / %（取模（取余））
移位操作符（移动的是二进制位）
>> << //必须把十进制数转化为二进制数进行操作
位操作符（作用的也是二进制位）
&（按位“与”）-----当两个操作数都是1时 结果为1 否则为0
^（按位“异或”）--------当两个操作数都为0时，结果为0 否则为1
|（按位“或”）-------当且仅当两个操作数不相同时，输出结果为1，否则为0
赋值操作符：
= += -= *= /= &= |= >>= <<=
11.1 一些注意事项
- int c=10/3----------输出结果为3--------因为保留整数（整型）
- float c=10/3-------输出结果为3.000000------因为默认10/3进行的是整数除法 即使结果存储到float类型中 后面也都是0
如果实现正确运算 那么需要在一个操作数中加上小数属性
- float c =10/3.0------结果是3.333333但是却会出现截断警告（因为3.0被系统默认为double烈性，而一个double类型存储在精度较低的float类型中 可能会出现截断问题）
- float c = 10/3.0f----这样就可以了（.f后缀表示他是float类型的）
11.2单目操作符
--（只有一个操作数）//同理有两个操作数就是双目操作符
！ 逻辑反操作
- 负值
+ 正值
& 取地址
sizeof 操作数的类型长度（以字节为单位）
~ 对一个数的二进制按位取反
-- 前置--和后置--
++ 前置++和后置++
* 间接访问操作符
（类型） 强制类型转换
对于逻辑反操作
在c语言中0就是假 1就是真
int a=0;
scanf("%d",&a)
//如果a是真的 那么输出 你好呀
if(a)
printf("你好呀\n");
//如果a是假的 那么输出 你不好
if(!a)
printf("你不好"\n)；sizeof
int a=10;
printf("%d\n",sizeof(int));
printf("%d\n",sizeof(a);
//这两结果是一样的 均为4（字节）前置++和后置++
前置++： 先++ 后使用
int a=10; b=++a;//前置++ 分别输出a，b printf("%d %d",a,b); //---a=11 //---b=11 // 即a=a+1 b=a后置++：先使用 后++
int a =10; b=a++;//后置++ 并输出a b的值 printf("%d %d",a,b); //----a=11 //----b=10 // 即b=a a=a+1
强制类型转换
printf("%d\n", b);
int a = (int)3.14;//强制类型转换
printf("%d\n", a);强制把3.14转换为整型 所以输出结果为3
11.3关系操作符
>
>=
<
<=
!= 用于测试“不相等”
== 用于测试“相等”
11.4逻辑操作符
&& 逻辑与
|| 逻辑或
11.5条件操作符
exp1？exp2 : exp3
如果表达式1为真--计算表达式2 并且表达式2的结果作为整个语句的结果
如果表达式1为假--计算表达式3 并且表达式3的结果作为整个语句的结果
int main()
{
int a = 3;
int b = 5;
int m = 0;
// if (a > b)
// m = a;
// else
// m = b;
m = ((a > b) ? a : b);//该语句即为上面的if语句 十分简练
return 0;
}11.6逗号表达式
exp1,exp2,exp3 ...expN
从左向右依次计算，整个表达式的结果是最后一个表达式的结果
int main()
{
int a = 1;
int b = 3;
int c = 4;
int d = (a = b - 3, b = a * 2, c = a - b);
printf("%d %d %d %d\n", a,b,c,d);
return 0;
}11.7下标引用、函数调用和结构成员
[] () . -> //后两个先不介绍
[]
int main()
{
int arr[10] = { 1,2,3,4,5 };//只存了五个 剩下的5个空间默认为0
// 0 1 2 3 4
printf("%d\n", arr[4]);//[]就是下标引用操作符
//[] - arr和4为[]的两个操作数
return 0;
} 11.7.1函数调用操作符
int MAX(int x,int y)
{
if(x>y)
return x;
else
return y;
}
int main()
{
printf("hello");//()就是函数调用操作符
//()的操作数就是函数名printf和"hello"
int a=5;
int b=6;
int m=MAX(a,b);//a和b是两个操作数
()的操作数是 自定义函数MAX,a,b
return 0;
} 12.常见关键字
auto break case char const continue default do double enum float for goto if int long register return short signed sizeof struct switch typedef union unsigned void volatile while
auto--自动变量
--关键字主要用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量，因为所有的变量默认就是auto-----因此很少用
register--寄存器变量
----起到建议作用 建议将变量的值放入寄存器 但最终由编译器决定
----并且寄存器变量是不能取地址的 因为地址 是在内存中取 而寄存器是集成到CPU上面的
int main() { register int num = 10; //寄存器变量是不能取地址的 //register 起到一个建议的作用，建议讲num的值放在寄存器中，最终是由编译器决定的 return 0; }
typedef---- 类型 重定义
unsighed int a=10;//显然前缀太长比较麻烦 typedef unsigned int uint;//我们将unsigned int 重定义为uint 十分简便 //与宏定义不一样 需要加分号 int main() { unsighed int a=20; uint b=10; return 0; }
static---静态的
首先补充一下---内存分为三个区
栈区、堆区、静态区
栈区：存放局部变量、函数的形式参数（临时的变量）
堆区：--动态内存分配 malloc free
静态区--存放静态变量、全局变量
：1.static修饰局部变量----实质是把局部变量放在了静态区存储
而栈区的变量出了作用域生命周期就结束了 但是静态区的变量除了作用域生命周期仍然存在，其生命周期为整个程序的生命周期
这样就改变了局部变量的生命周期 因此a就不会被销毁
//static 修饰局部变量 void test() { int a = 0; a++; printf("%d ", a); } int main() { int i = 0; while (i < 10) { test(); i++; } //其实每一次调用test之后 n都会销毁 每一次循环都会重新定义n=0 //所以最终结果是十个1 return 0; } //修改之后如下 void test() { static int a = 0;//给用static修饰整型数据a a++; printf("%d ", a); } int main() { int i = 0; while (i < 10) { test(); i++; } return 0; }2.static修饰全局变量----我用图来演示
在另一个源文件中定义了一个全局变量
其实在不同的源文件编译的时候 add.c和test_1_13是独立编译的 互相不知道
我们写文件会经历三个步骤：编译-------链接---------生成exe可执行文件（了解一下）
在编译阶段是独立的 在链接阶段不同源文件互相访问找到需要用到的变量或者函数
因此需要声明一下才可以使用来自不同源文件的变量或函数
我们可以发现 通过外部声明是可以使用g_val 这个全局变量的
但是如果我们在add.c中用static修饰g_val变量 那么将会报错 这是因为static改变了全局变量g_val的链接属性 在链接阶段无法被访问到 ---（因此如果在一个大工程中 你不想让别人使用一个变量就可用static修饰该变量）
- static修饰函数
static修饰函数与static修饰全局变量一样 改变了函数的链接属性 这里就不举例子啦
总结一下：
1. static修饰局部变量的时候，改变了局部变量的存储类型：
从栈区存储变成了从静态区存储 因此生命周期发生改变（作用域不变）
2.static修饰全局变量的时候，改变了全局变量的链接属性
本来一个全局变量是有外部链接属性的，被static修饰之后就变成了内部链接属性
（只能在本源文件（.c）内部使用，其他文件无法再使用到）
3.static修饰函数与修饰全局变量一样，改变了函数的外部链接属性，函数只能在本源文件内部使用，其他文件无法再使用到
13.指针
13.1关于内存
什么是指针？？
首先要知道 内存实际上是分了一个个小的内存单元的，每个内存单元是一个字节
并且这每一个内存单元都有自己的编号例如0x00000001-----这个编号其实就是地址 也就是指针
---所以 指针就是一个变量的地址，通过指针可以找到以它为地址的内存单元
而指针变量就是用来存放变量的地址的（即指针）
所以指针也是一个变量
譬如，int 类型的大小是4个字节 因此如果定义一个int a 那么需要在内存开辟出一个4个字节的空间（四个内存单元）用来存储变量a
注意：
对于多字节大小的数据，他的地址一般取的是存储该变量的第一个内存单元的地址
例如 int a 占用四个内存单元 分别是0x00000001、0x00000002、0x00000003、0x00000004 那么int a的显示的地址为0x00000001
13.2指针的使用
13.2.1取变量地址
#include<stdio.h>
int main()
{
int a = 10;
&a;//int类型有四个字节大小，每个字节都有地址，取出的是第一个字节（较小的）地址
printf("%p\n", &a);//地址格式化%p
return 0;
}13.2.2 指针的存储
地址（指针）也是一串数据 可以存储
这就需要 指针变量了（这是一种数据类型）----类型+ * +变量名==指针变量
#include<stdio.h>
int main()
{
int num= 10;
int* p;//p是一个整型指针变量
p = #//p为num的地址
return 0;
}注意：int * p；---int 为该指针指向的数据的类型 ，*标明p是一个指针变量
所以p是一个整型指针变量
13.2.3指针的使用
一般通过指针可以改变 变量的值
#include<stdio.h>
int main()
{
int num = 10;
int* p;
p = #
*p = 20;//*为解引用操作符，*p即对指针(地址)进行解引用 也就是通过指针对应到那个内存单元存储的数据
//*p就是num
printf("%d\n", num);//---num变成了20
return 0;
}13.2.4指针变量的大小
前面我们讨论了 指针变量存储的是变量的首地址
那么指针变量的大小不就取决于该计算机的地址的大小吗？
我们目前常用的32位 64位的计算机，就是地址所占的位数 也就对应着4字节，8字节
因此指针变量的大小与指针所指向的变量的类型无关！！！
#include<stdio.h>
int main()
{
printf("%d\n", sizeof(char*));
printf("%d\n", sizeof(int*));
printf("%d\n", sizeof(short*));
printf("%d\n", sizeof(double*));
return 0;
}输出结果相同！
14.结构体
14.1认识结构体
我们生活在三维空间，显然很多东西是十分复杂滴
比如一个学生，你需要身高，体重，年龄，姓名，分数等等好多参数来描述
那么在C语言中就有了结构体这一东西
struct Stu
{
char name[20];//用一个字符数组来存放名字，大小20应该够了吧...
int age;
char sex[5];
int score;
};//这是在main函数先定义一个结构体 Stu（学生）是一个结构体类型（比如还有上班族类型等等...）
int main()
{
//struct Stu s1;//定义两个学生s1 s2
//struct Stu s2;
struct Stu s1 = { "小明",18,"男",60 };//初始化结构体信息（初始化俩学生的信息）
struct Stu s2 = { "小红",17,"女",100 };
}14.2访问结构体成员
我们如何知道结构体的某一成员呢（学生的某一信息（如身高）） ？
14.2.1利用 . 来访问结构体成员
#include<stdio.h>
struct Stu
{
char name[20];
int age;
char sex[5];
int score;
};
int main()
{
struct Stu s1 = { "小明",18,"男",60 };//初始化结构体信息
struct Stu s2 = { "小红",17,"女",100 };
printf("%s %d %s %d", s1.name, s1.age, s1.sex, s1.score);
return 0;
}14.2.2利用->来访问结构体成员
#include<stdio.h>
struct Stu
{
char name[20];
int age;
char sex[5];
int score;
};
int main()
{
struct Stu s1 = { "小明",18,"男",60 };//初始化结构体信息
struct Stu s2 = { "小红",17,"女",100 };
struct Stu* p=&s1;//注意 指针需要初始化为s1的地址
printf("%s %d %s %d", p->name, p->age, p->sex, p->score);通过s1的地址指向具体成员
return 0;
}
扫一扫
1142
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
