C语言的初步认识
目录
前言
主要介绍C语言的基本知识。
一、C语言是什么？
1.C语言的发展历史
我们知道语言是人类的一种沟通方式，而随着1946年第一步的计算机问世，从一开始的计算要求，人们还希望计算机能够做更多的事情，所以计算机语言（人类沟通计算机的语言）发展起来了，现如今计算机语言已经经过了3个阶段的发展：
1.机器语言（它是计算机直接识别的语言,由0|1组成）
2.汇编语言（是二进制指令的文本形式，就是用助记符来表示机器语言中各种由0|1组成指令。）比如在机器语言中00000011表示加法指令，而汇编语言以ADD来表示。
3.高级语言：（是一种指令集的体系)例如：C，java，c++等高级语言。
而在这些高级语言中，C语言担任着不可替代的地位，因为现如今其余的高级语言都或多或少的借鉴了C语言的语法与经验，学好C语言有利于我们理解其余的高级语言。
二、C语言所需的工具
1.编译器
编译器是把高级语言程序翻译成计算机能理解的机器语言的一种工具
我现在使用的编译器是VS2022
下载链接：VS2022官网
安装教程：b站鹏哥
对于初学者比较推荐使用Dev c++
下载链接：Dev c++官网
安装教程：fishtail2008
三、第一个C语言程序
#include <stdio.h>
//预处理指令，引用头文件
int main()//C语言的唯一入口。
{
printf("Hello World"）；
//打印Hello world
return 0；
}
打印结果：
注意事项:
1.main不要写成mian，以及记得加上#。
2.以英文输入法输入。
3.记得每条语句要加上分号；
细节讲解
1.#include<stdio/h>
这行代码说明的是：告诉编译器把stdio.h（standard input output.header）（标准输入输出头文件）中的内容包含在当前程序中，提供键盘输入和屏幕输出的支持。
2.int main()
这里我们需要知道c程序一定是从main()函数开始执行，在整个工程中有且唯一。int 是 main()函数的返回类型（这里的知识点会在后续文章出现）。
3.注释：在程序里//后面跟一条语句表示的注释这条语句，并不参与编译，如果我们想要注释掉多行语句呢？那就要用到/* XXX */表示注释掉多行语句。比如这样
#include<stdio.h>
int main()
{
/*int a=0;
int b=0;*/
//这代表的是这两条语句已经被注释掉了。
int c=0;
//int d=0;这代表着这行代码已经被注释掉了。
return 0;
我们需要知道注释只是为了帮助读者理解程度，编译器会忽略它们。
所以：
四、C语言的数据类型
我们知道数学里存在着整数、小数，语文中存在着汉字，英语中存在着字母，而在计算机中不仅可以处理数学问题以及生活问题，想要让计算机来表示这些，丰富内容，就出现了数据类型。如下：
char 字符数据类型
short 短整型
int 整型
long 长整型
long long 更长的整形
float 单精度浮点数
double 双精度浮点数
1.在计算机中占据的内存大小
在计算机中存储任何数据都有着大小，现在我们想这些数据类型在计算机中的内存大小，需要使用C语言里的一个内置操作符–sizeof，以字节为单位给出指定类型的大小。
运行结果:
简单介绍一下sizeof操作符:sizeof是C语言的一种单目操作符（不是函数哦），以字节为单位给出指定类型的大小。
五、变量与常量
在生活中我们不变的量成为常量，如：身份证号，血型等，会发生变化的量称为变量，而C语言中自然存在着变量与常量。
1.变量
1.1变量的定义
定义“
方法：数据类型 变量名 = 数值
如 int a=1，char b=‘a’, float c=1.0
#include<stdio.h>
int main()
{
int a=0;//这里我们定义了一个整型变量a并且初识化为0
printf("a=%d\n",a);
a=9;//这里我我们给a赋值一个数9
printf("a=%d\n",a);
return 0;
}
运行结果:
经过运行代码我们可以看出这里a是可以变化的，则它是变量。
1.2变量的命名
只能由字母（包括大写和小写）、数字和下划线（ _ ）组成。
不能以数字开头。
长度不能超过63个字符。
变量名中区分大小写的。
变量名不能使用关键字。
1.2变量的分类
全局变量和局部变量
开始我们可以认为在代码块定义的变量是全局变量，在代码块里面定义的变量是局部变量。
#include <stdio.h>
int year=2023;//定义全局变量
int main()
{
int year=1949;//定义局部变量
printf("%d",year);
return 0;
上面的程序在桌面上可以打印出什么呢?
运行结果:
所以当局部变量和全局变量同名的时候，局部变量优先使用。
1.3变量的作用域和生命周期
作用域
作用域是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用
的而限定这个名字的可用性的代码范围就是这个名字的作用域。就是该变量的可以被
正常访问的代码区域。
**1.**局部变量的作用域是变量所在的局部范围。
进入代码块，形成局部变量（开辟空间），退出代码块，释放局部变量。
举个栗子：
#include<stdio.h>
int main()
{
{
int a=0;
}
printf("%d",a);
return 0;
}
我们在编译器上是无法运行的,因为变量a的作用域只在那个小花括号里面，出去了就没有用了。
**2.**全局变量的作用域是整个工程。
定义完成之后，程序运行的整个生命周期，该变量一直都有效。
举个栗子：
#include<stdio.h>
int a=100;
void test()
{
printf("2-->%d",a);
}
int main()
{
pirntf("1-->%d",a);
void();
return 0;
}
你看全局变量不仅可以在main函数内使用，也可以调用函数使用，如果是在main函数里定义一个变量，那么调用像这样的函数会同样报出向之前全局变量的错误。
生命周期
这里我们要知道变量的本质是在内存中开辟一块空间，然后存储数据。
所以变量的生命周期：
1.变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
2.局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
3.全局变量的生命周期是：整个程序的生命周期。
注：这里的销毁是把之前开辟的空间还给操作空间。
大家可以联系一下上文的作用域帮助理解。
2.常量
2.1常量的定义
定义：有些数据类型在程序使用前已经预先设定好了，在等个程序的运行过程中没有变化。
常量的分类
2.2字面常量
#include <stdio.h>
int main()
{
3，14；//字符常量
2023；//字符常量
return 0；
}
2…3const修饰的常变量
#include<stdio.h>
int main()
{
const year =1999;//const修饰的常变量
year=2000；//const修饰的常变量是不可直接修改的
return 0；
}
const修饰的常变量是具有常属性的不可以被修改，但是本质上还是变量。
这里我们可以从这段代码看出：
#include<stdio.h>
int main()
{
const int a=1;
int arr[a]={0};
return 0;
}
运行结果:
大家看，因为定义数组中int arr[ ]，方括号中必须是常量表达式，我们将a输入却报错了，所以我们知道const修饰的常变量本质上还是变量。
2.4#define 定义的标识符常量
基本结构：#define NAME value
#include<stdio.h>
int main()
{
#definre Max 100//这里由#define定义的语句不需要分号;
printf("max = %d\n", MAX);
return 0;
}
这里的NAME与变量规则一样。
2.5枚举常量
枚举一一列举。
enum Sex
{
MALE,
FEMALE,
SECRET
};
#include<stdio.h>
int main()
{
//枚举常量演示
printf("%d\n", MALE);
printf("%d\n", FEMALE);
printf("%d\n", SECRET);
return 0;
}
注意：第一个枚举成员的默认值为整型的 0，后续枚举成员的值在前一个成员上加 1。如果在这个实例中把第一个枚举成员的值定义为 1，第二个就为 2，以此类推。
六、字符串和转义字符
1.字符串
"abcdefg"
这种由双引号引起来的一串字符称为字符串字面值，或者简称字符串。
注：字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。
#include <stdio.h>
int main()
{
char arr1[] = "abc";
char arr2[] = {'a', 'b', 'c'};
char arr3[] = {'a', 'b', 'c'， '\0'};
printf("%s\n", arr1);
printf("%s\n", arr2);
printf("%s\n", arr3);
return 0;
}
运行结果:
所以我们要记住在计算由” “引起来的字符串计算长度时，是以’\0’为结束标志的，要不然不知道从哪里停止，知道遇到’ \0 '停止。
2.转义字符
转义字符是C语言中表示字符的一种特殊形式。通常使用转义字符表示ASCII码字符集中不可打印的控制字符和特定功能的字符。
。
| 转义字符 | 释义 |
|---|---|
| \? | 在书写连续多个问号时使用，防止他们被解析成三字母词 |
| \a | 响铃 |
| \n | 换行 |
| \t | 横向跳格 |
| \b | 退格 |
| \r | 回车 |
| \f | 换页 |
| \t | 水平制表符 |
| \v | 垂直制表符 |
| \ddd | ddd表示1-3个八进制代表的ASCII字符 |
| \xdd | dd表示1-2个十六进制代表的ASCII字符 |
| \\ | 表示一个反斜杠’\’ |
| \’ | 表示字符常量’ |
| \” | 表示用于表示一个字符串内部的双引号 |
大家可以自己vs2022中尝试一下各种转义字符，这里就不再赘述了。
七、选择语句
在C语言中我们用if else语句，switch来表示循环语句。
这里我们简单介绍一下用法。
1.if else 语句
#include<stdio.h>
int main()
{
int i=0;
printf("有一天你在河边掉了一柄斧头，这时河神问你掉的时哪柄斧头\n");
printf("请输入数字来表示你的选择\n");
printf("提示：输入1表示金斧头，输入2表示银斧头，输入其他数字表示破烂斧头\n");
scanf("%d",&i);
if(1==i)
{
printf("我掉的时这柄金斧头");
}
else if(2==i)
{
printf("我掉的是这柄银斧头");
}
else
{
printf("我掉的是这柄破烂斧头"）;
}
return 0;
}
//你是一个诚实的孩子吗？
运行结果:
当然是诚实的好孩子。😊😊😊
注意事项：
1.if（这里是判断条件） 。
2.if语句接多条语句时用{ }括住，一条语句可用可不用但是还是希望大家都带上{ }。
3.当我们有着两种以上的选择时使用else if 语句来表示其他的情况。
4.else语句后面无需假判断条件，当前面的都不符合则进入else语句。
这里就给大家对选择语句做一个初步了解，不做深入了解。
2.switch语句
#include <stdio.h>
//switch代码演示
int main()
{
int day = 0;
switch(day)
{
case 1：
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期天\n");
break;
}
return 0;
}
break语句的实际效果是把语句列表划分为不同的分支部分。
编程好习惯
在最后一个 case 语句的后面加上一条 break语句。
（之所以这么写是可以避免出现在以前的最后一个 case 语句后面忘了添加 break语句）。
八、循环语句
俗话说日积月累，积水成渊，当满足一定的条件就会出现一种结果，我们用C语言怎么表示呢？C语言中有着while语句，do while 语句，for语句。
这里我们简单使用一下它们的基本用法。
我们举个例子。
1.while语句
基本用法：
#include<stdio.h>
int main()
{
int water = 0;
while(water<=1000)
{
printf("您已成功积累%d滴水\n",water);
water++;
}
if(water>1000)
{
printf("您已成功积累一杯水，请继续加油。");
}
return 0;
}
运行结果:
注：while( )括号中是循环条件，当不满足循环条件时就跳出while语句。这里是先判断循环条件再进行while内的语句。
2.do while语句
基本用法：
#include<stdio.h>
int main()
{
int water=0;
do
{
printf("您已成功积累%d滴水");
water++;
}while(water>=1000)
if(water>1000);
{
printf("您已成功积累一杯水，请继续加油。");
}
return 0;
}
运行结果:
注：在 do while语句中我们只先执行，再判断条件。
3.for语句
#include<stdio.h>
int main()
{
int water = 0;
for(water=0;water<=1000;water++)
{
printf("您已成功积累%d滴水\n",water);
}
printf("您已成功积累一杯水\n");
return 0;
}
运行结果:
所以for循环的基本结构为
for(表达式1; 表达式2; 表达式3)
循环语句;
表达式1：初始化部分，用于初始化循环变量的。
表达式2：条件判断部分，用于判断循环时候终止。
表达式3：调整部分，用于循环条件的调整。
总结：这里只是给大家演示while ,do while, for循环语句的基本用法，关于更加细致的用法请关注后续文章。
九、函数
在 C 语言中，函数由一个函数头和一个函数主体组成。
return_type name( parameter )
{
body of the function
}
返回类型(return_type)：一个函数可以返回一个值。return_type 是函数返回的值的数据类型。有些函数执行所需的操作而不返回值，在这种情况下，return_type 是关键字 void。
函数名称(name)：这是函数的实际名称。函数名和参数列表一起构成了函数签名。
参数(parameter)：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
函数主体：函数主体包含一组定义函数执行任务的语句。
这里只是简单介绍一下函数的用法。
例：
//定义函数
int ADD(int a,int b)
{
return a+b;//返回a+b的值
}
#include<stdio.h>
int main()
{
int a=0;
int b=0;
scanf("%d %d",&a,&b);
printf("a=%d b=%d\n",a,b);
int sum =ADD(a,b);//接收a+b的值
printf("sum=%d",sum);
return 0;
}
运行结果:
十、数组
1.数组的定义
定义”是一组相同类型的元素集合。
数组的初始化：
int arr[10]={1,2,3,4,5,6,7,8,9,10};
//int 是数组中元素的类型。
//[]中是数组元素的个数。
//{}中是元素。
这里我们还需要知道，数组如果初始化时，可以不指定大小。会根据初始化的内容确定数组的大小
如：
int arr[ ]={1，2，3};//没有指定数组大小，更具初始化内容确定数组大小为3.
当我们想要访问数组中的某个元素时，怎么访问呢？
在数组中每个元素都有着对应的下标，下标从零开始。
2.数组的使用
#include <stdio.h>
int main()
{
int i = 0;
int arr[10] = {1,2,3,4,5,6,7,8,9,10};
for(i=0; i<10; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
运行结果:
注意：当我们定义数组时。int arr[ ]，[ ]内必须是常量表达式，如果是变量就会报错，
例：
#include<stdio.h>
int main()
{
int a =1;
int arr[a]={0};
return 0;
}
运行结果:
但是在c99标准中引用了一个概念：变长数组就是可以用变量指定大小的，但是这个数组不能初始化。这里我们不深入涉及，了解即可。
十一、运算符/操作符
算术运算符
| 运算符 | 含义 |
|---|---|
| + | 将两数相加 |
| - | 将两数相减 |
| * | 将两数相乘 |
| / | 将两数相除 |
| % | 两数相除取余数 |
| ++ | 自增运算符，每次加1 |
| – | 自减运算符，每次减1 |
#include<stdio.h>
int main()
{
int a=0;
int b=0;
scanf("%d %d",&a,&b);
printf("%d",a+b);
printf("%d",a-b);
printf("%d",a*b);
printf("%d",a/b);
printf("%d",a%b);
return 0;
}
注意事项：
1.对于%操作符（取模）只能用于整数，其他的几个操作符可以作用于整数和浮点数。返回的是整除之后的余数。
2.对于/操作符，若两数都为整数，那么结果也为整数，即使是 3 / 2原本是为1.5，只取1.
若两数之中只要有一个浮点数，那么结果就以浮点数的形式。
位运算符
1.& 按位与
相异为零，相同不变。
11111111111111111111111111111011
00000000000000000000000000000011
00000000000000000000000000000011
2.| 按位或
相异为一，相同不变
11111111111111111111111111111011
00000000000000000000000000000011
11111111111111111111111111111011```
3.^按位异或
相同为零，相异为一
11111111111111111111111111111011
00000000000000000000000000000011
11111111111111111111111111111000
4.~取反操作符
对于一个数的二进制按位取反
00000000000000000000000000000101
11111111111111111111111111111010
5.<<左移操作符
将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。
a=3;
b=a<<1;
a的补码00000000000000000000000000000011
a<<1: 00000000000000000000000000000110
6.>>右移操作符
算术右移：将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
逻辑右移：将一个数的各二进制位全部右移若干位，左边用0填充，右边丢弃
取决于编译器
a=3;
b=a>>1;
a的补码00000000000000000000000000000011
算术右移00000000000000000000000000000001
逻辑右移00000000000000000000000000000001
逻辑操作符
在C语言中0为假，非零为真
&& （逻辑与操作符）如果两个操作数或条件都非零，则条件为真。
|| （逻辑或操作符）如果两个操作数条件中有任意一个非零，则条件为真。
！ （逻辑非运算符）如果条件为真则逻辑非运算符将使其为假。
赋值操作符
| 赋值操作符 | 含义 |
|---|---|
| = | 把右边操作数的值赋给左边操作数 |
| += | a+=b等于a=a+b |
| -= | a-=b等于a=a-b |
| *= | a*=b等于a=a*b |
| /= | a/b等于a=a/b |
| %= | a%b等于a=a%b |
| <<= | a<<=2等于a=a<<2 |
| >>= | a>>2等于a=a>>2 |
| &= | a&=2等于a=a&2 |
| ^= | a ^ =2等于a=a^2 |
| == | 判断是否相等 |
| ！= | 不相等 |
条件操作符
exp1 ? exp2 : exp3
对表达式exp1进行判断，若判断为真则执行表达式exp2，若判断为假则执行表达式exp3。例如：
#include<stdio.h>
int main()
{
int a = 1;
int b = 0;
b = a > 5 ? 3 : -3;
printf("变量 b 的值为：%d\n", b);
return 0;
}
//运行结果是：变量b的值位：-3
逗号表达式
exp1, exp2, exp3, …exp
运算过程为：从左往右逐个计算表达式，计算结果为最后一个表达式。
#include<stdio.h>
int main()
{
int a=1;
int b=2;
int c=3;
c=a++,b++,a+b;
printf("%d",c);
return 0;
}
运行结果:
十二、常见关键字
C语言提供了丰富的关键字，这些关键字都是语言本身预先设定好的，用户自己是不能创造关键字的。
常见关键字：auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatil while
这里我们简单介绍几个
关键字static
在C语言中：
static是用来修饰变量和函数的
- 修饰局部变量-称为静态局部变量
- 修饰全局变量-称为静态全局变量
- 修饰函数-称为静态函数
修饰局部变量
让我们先看两个例子
#include <stdio.h>
void test()
{
int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for(i=0; i<10; i++)
{
test();
}
return 0;
}
//运行结果为10个1
#include <stdio.h>
void test()
{
//static修饰局部变量
static int i = 0;
i++;
printf("%d ", i);
}
int main()
{
int i = 0;
for(i=0; i<10; i++)
{
test();
}
return 0;
}
//运行结果为1，2，3，4，5，6，7，8，10.
在第一个例子我们可以知道当每次进入test函数时，变量i都会重新定义为0.但是当static修饰时，每次进入tset函数时变量i的值依旧是上次进入test的值。
结论：static修饰局部变量改变了变量的生命周期
让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。
修饰全局变量
一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使用。因为在程序中我们可以创建多个源文件，在一个源文件里定义一个全局变量想要在另一个源文件里使用我们只需要全局变量的源文件声明就可以。
修饰函数
static修饰函数与修饰全局变量类似：一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。
原因与全局变量一样，只不过是函数。有利于项目维护，提供安全保证。
关键字 typedef
作用：使用它来为类型(C语言中的内置类型如int,char等，还有用户自己定义的数据类型）取一个新的名字。
内置类型：
typedef unsigned char byte
这里我们将unsigned char 取一个新的名字 byte.
自定义类型：结构体类型
typedef struct A
{
...
}B;
//这里我们就将结构体A取了一个新的名字B。
十三、指针
内存
在我们初步认识指针时，我们先初步认识一下内存，内存是电脑中特别重要的存储器，存储程序和数据的地方，计算机中程序的运行都是在内存中进行的。
所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是一个字节。
为了能有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址
每一个变量都有一个内存位置，每一个内存位置都定义了可使用 & 运算符访问的地址，它表示了在内存中的一个地址。如图所示：
那么像这样的oxFFFFFF（这里是十六进制，一般显示到电脑屏幕上的地址编号会以十六进制出现，实际上在计算机还是以二进制表示）的地址编号怎么产生的呢？
因为在32位计算机上，有32根地址线，通电时，每根地址线都会产生高低电平的信号，也就是0或者1的数字信号，就有32个数字信号，也就是32个比特位，一个比特位无非就是0或者1，那么组合起来，32位就会产生2的32次方的编号种类，如00000000000000000000000000000000
00000000000000000000000000000001
…
1111111111111111111111111111111111111
则像这样的一个二进制序列我们就做成每一个内存单元的内存编号。
就有着2的32次方的空间。
64位的计算也是类似。
怎么取出地址？
#include <stdio.h>
int main ()
{
int a = 10;
int *p; // 定义指针变量p用来存放地址。
p = &a; //取出a变量的地址放在指针变量p中。
printf("a变量的地址:%p\n", p);
return 0;
}
运行结果:
看这就是a变量在内存中的地址了。但是虽然指针变量a在内存中占4个字节，我们&a取的是它第一个字节的地址。
结论：指针是内存中一个最小单元的编号，也就是地址。平时口语中的指针，通常指的是指针变量，是用来存放内存地址的变量。
这里我们思考一个问题指针有没有大小呢？答案是有的
指针的大小
#include <stdio.h>
int main()
{
printf("%d\n", sizeof(char *));
printf("%d\n", sizeof(short *));
printf("%d\n", sizeof(int *));
printf("%d\n", sizeof(double *));
return 0;
}
//还记得sizeof的用法吗？
结论：
指针变量的大小取决于地址的大小
32位平台下地址是32个bit位（即4个字节）
64位平台下地址是64个bit位（即8个字节）
十四.结构体
结构是 C 语言中一种用户自定义的可用的数据类型，允许您存储不同类型的数据项。
注意它和数组不同哦，数组是一组相同类型的元素。
让我们简单使用一下结构体
结构体的初始化
struct Stu
{
char name[20];//名字
int age; //年龄
char sex[5]; //性别
char id[15]； //学号
};
//结构体的初始化：
struct Stu s = {"阿玥"， 18， "女"， "20990909"}
好了这是简单的定义了一个结构体，那么如果我们想要访问其中的成员呢？
结构体的访问
对于结构成员的访问我们可以使用 . 和 ->操作符来访问，就像数组那样有着下标引用操作符来访问数组中的元素。
//使用. 访问
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
//使用->访问
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps->id);
完整代码：
#include<stido.h>
struct Stu
{
char name[20];//名字
int age; //年龄
char sex[5]; //性别
char id[15]； //学号
};
int main()
{
struct Stu s = {"阿玥"， 18， "女"， "20990909"};
struct Stu *ps = &s;
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps->id);
return 0;
}
运行结果:
总结：这篇文章主要是给大家介绍一下C语言的基本知识，如果有错误希望请大家及时指正。谢谢大家。
523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
