【C语言系列】初始C语言

塞雪

于 2024-10-05 12:54:04 发布

阅读量873

点赞数 23

文章标签： c语言

本文链接：https://blog.csdn.net/2301_80434397/article/details/142693279

版权

学习目标

基本了解C语言的基础知识，对C语言有一个大概的认识。

本章对于C语言的知识点都是点到为止，主要目的是构建一个大体框架，之后再详细阐述。

本章重点

什么是C语言

第一个C语言程序

数据类型

变量、常量

字符串、转义字符、注释

选择语句

循环语句

函数

数组

操作符

常见关键字

define定义常量和宏

指针

结构体

什么是C语言

C语言是一门通用计算机编程语言，广泛应用于底层开发。

第一个C语言程序

#include<stdio.h>
int main()
{
	printf("Hello World\n");
	return 0;
}

//std-标准
//i-input
//o-output
//包含头文件
#include<stdio.h>
//C语言规定，main函数是程序的入口
//标准的主函数的写法
int main()
{
	printf("Hello World\n");
	return 0;
}

数据类型

char	字符数据类型	1
short	短整型	2
int	整型	4
long	长整型	4
long long	更长的整型	8
float	单精度浮点数	4
double	双精度浮点数	8

C语言中没有字符串类型！

C语言规定:sizeof(long)>=sizeof(int)

丰富的数据类型提高了空间的利用率，减少浪费。

数据类型的使用

char ch='w';
int age=20;

创建变量的本质是向内存申请一块空间。

变量、常量

变化的值——变量

不变的值——常量

定义变量的方法

类型类型名（最好初始化）

变量的分类

局部变量

全局变量

#includ<stdio.h>
int b = 20;//全局变量
int main()
{
	int a = 10;//局部变量
	return 0;
}

在同一个范围内，一个变量只能出现一次。

全局变量和局部变量的名字是可以相同的，在使用过程中，局部优先。但不建议相同。

变量的使用

#includ<stdio.h>
int main()
{
	int a = 10;//建立变量时要初始化，如果不初始化，放的是一个随机值，不利于后续使用
	return 0;
}

变量的作用域和生命周期

作用域

作用域是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的。

而限定这个名字的可用性的代码范围就是这个名字的作用域。

局部变量的作用域是变量所在的局部范围。
全局变量的作用域是整个工程。

生命周期

变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段。

局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。
全局变量的生命周期是：整个程序的生命周期。

常量

常量分类

字面常量
const 修饰的常变量
#define 定义的标识符常量
枚举常量

字面常量：10，3.14，'a'(字符常量),"abc"(字符串常量）

const 修饰的常变量：某一变量不想被改变，在其前面添加"const"即可。

C语言中，const 修饰的常变量，本质是变量，但是不能直接被修改，有常量的属性。

#define 定义的标识符常量

#define MAX 100

枚举常量

可一一枚举

enum Color
{
	//枚举常量
	RED,
    GREEN,
    BLUE
};
int main()
{
	enum Color c = RED;
	return 0;
}

字符串、转义字符、注释

字符串

由双引号引起来的一串字符称为字符串面值，简称字符串。

注:字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容。
存储字符串用字符数组。

#include <stdio.h>
//下面代码，打印结果是什么？为什么？（突出'\0'的重要性）
int main()
{
char arr1[] = "bit";
char arr2[] = {'b', 'i', 't'};
char arr3[] = {'b', 'i', 't'， '\0'};
printf("%s\n", arr1);//bit
printf("%s\n", arr2);//乱码，因为无结束标志
printf("%s\n", arr3);//bit
return 0;
}

转义字符

\？	在书写连续多个问号时使用，防止他们被解析成三字母词
\'	用于表示字符常量'
\“	用于表示一个字符串内部的双引号
\\	用于表示一个反斜杠，防止它被解释为一个转义序列符。
\a	警告字符，蜂鸣
\b	退格符
\f	进纸符
\n	换行
\r	回车
\t	水平制表符
\v	垂直制表符
\ddd	ddd表示1~3个八进制的数字。如： \130 X
\xdd	dd表示2个十六进制数字。如： \x30 0

注释

代码中有不需要的代码可以直接删除，也可以注释掉
代码中有些代码比较难懂，可以加一下注释文字

注释有两种风格：
C语言风格的注释 /*xxxxxx*/
缺陷：不能嵌套注释
C++风格的注释 //xxxxxxxx
可以注释一行也可以注释多行

选择语句

#include <stdio.h>
int main()
{
int coding = 0;
printf("你会去敲代码吗？（选择1 or 0）:>");
scanf("%d", &coding);
if(coding == 1)
{
prinf("坚持，你会有好offer\n");
}
else
{
printf("放弃，回家卖红薯\n");
}
return 0;
}

循环语句

分类

while语句
for语句
do ... while语句

//while循环的实例
#include <stdio.h>
int main()
{
printf("坚持敲代码\n");
int line = 0;
while(line<=20000)
{
line++;
printf("我要继续努力敲代码\n");
}
if(line>20000)
printf("好offer\n");
return 0;
}

函数

#include <stdio.h>
int main()
{
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = num1 + num2;
printf("sum = %d\n", sum);
return 0;
}

上述代码，写成函数如下：

#include <stdio.h>
int Add(int x, int y)
{
int z = x+y;
return z;
}
int main()
{
int num1 = 0;
int num2 = 0;
int sum = 0;
printf("输入两个操作数:>");
scanf("%d %d", &num1, &num2);
sum = Add(num1, num2);
printf("sum = %d\n", sum);
return 0;
}

函数的特点就是简化代码，可反复使用。

数组

数组的定义：一组相同类型元素的集合

数组定义

int arr[10] = {1,2,3,4,5,6,7,8,9,10};//定义一个整形数组，最多放10个元素

数组的下标

C语言规定：数组的每个元素都有一个下标，下标是从0开始的。
数组可以通过下标来访问的。
比如：

int arr[10] = {0};
//如果数组10个元素，下标的范围是0-9

int arr[10]	0	0	0	0	0	0	0	0	0	0
下标	0	1	2	3	4	5	6	7	8	9

数组的使用

#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;
}

操作符

算术操作符：+ - * / %

移位操作符：>> <<

位操作符：& ^ |

赋值操作符：= += -= *= /= &= |= >>= <<=

单目操作符：

！	逻辑反操作
-	负值
+	正值
&	取地址
sizeof	操作数的类型长度（以字节为单位）
~	对一个数的二进制按位取反
--	前置、后置--
++	前置、后置++
*	间接访问操作符（解引用操作符）
（类型）	强制类型转换

关系操作符：

!= 用于测试“不相等”

==用于测试“相等”

逻辑操作符：&& 逻辑与

|| 逻辑或

条件操作符：exp1？exp2：exp3

逗号表达式：exp1,exp2,exp3,…expN

逗号表达式的特点：从左向右依次计算，整个表达式的结果是最后一个表达式的结果

下标引用、函数调用和结构成员：[] () . ->

常见关键字

关键字是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 volatile while

关键字typedef

类型重命名

//将unsigned int 重命名为uint_32, 所以uint_32也是一个类型名
typedef unsigned int uint_32;
int main()
{
//观察num1和num2,这两个变量的类型是一样的
unsigned int num1 = 0;
uint_32 num2 = 0;
return 0;
}

关键字static

1. 修饰局部变量-称为静态局部变量

static修饰局部变量的时候，局部变量出了作用域，不会销毁。本质上，static修饰局部变量的时候，改变了变量的存储位置，从而影响了变量的生命周期，和程序的生命周期一样。
2. 修饰全局变量-称为静态全局变量

全局变量是具有外部连接属性的。

static修饰全局变量的时候，这个全局变量的外部连接属性就变成了内部链接属性。其他源文件就不能再使用这个全局变量了。
3. 修饰函数-称为静态函数

一个函数本来是具有外部连接属性的，但被static修饰的时候，外部连接属性就变成了内部链接属性，其他源文件无法使用。

修饰局部变量

//代码1
#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;
}
//代码2
#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;
}

static修饰局部变量改变了变量的生命周期
让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。

修饰全局变量

//代码1
//add.c
int g_val = 2018;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}
//代码2
//add.c
static int g_val = 2018;
//test.c
int main()
{
printf("%d\n", g_val);
return 0;
}

一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使
用。

修饰函数

//代码1
//add.c
int Add(int x, int y)
{
return c+y;
}
//test.c
int main()
{
printf("%d\n", Add(2, 3));
return 0;
}
//代码2
//add.c
static int Add(int x, int y)
{
return c+y;
}
//test.c
int main()
{
printf("%d\n", Add(2, 3));
return 0;
}

一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

define定义常量和宏

宏的参数无类型

//define定义标识符常量
#define MAX 1000
//define定义宏
#define ADD(x, y) ((x)+(y))
#include <stdio.h>
int main()
{
int sum = ADD(2, 3);
printf("sum = %d\n", sum);
sum = 10*ADD(2, 3);
printf("sum = %d\n", sum);
return 0;
}

指针

内存

内存是电脑上特别重要的存储器，计算机中程序的运行都是在内存中进行的。
所以为了有效的使用内存，就把内存划分成一个个小的内存单元，每个内存单元的大小是1个字节。
为了能够有效的访问到内存的每个单元，就给内存单元进行了编号，这些编号被称为该内存单元的地址。

变量是创建内存中的（在内存中分配空间的），每个内存单元都有地址，所以变量也是有地址的。
取出变量地址如下：

#include <stdio.h>
int main()
{
int num = 10;
&num;//取出num的地址
//注：这里num的4个字节，每个字节都有地址，取出的是第一个字节的地址（较小的地址）
printf("%p\n", &num);//打印地址，%p是以地址的形式打印
return 0;
}

那地址如何存储，需要定义指针变量。

int num = 10;
int *p;//p为一个整形指针变量，int说明p指向的对象是int类型的
p = &num;

存放指针（地址）的变量就是指针变量。

指针就是用来存放地址的。

指针的使用实例：


#include <stdio.h>
int main()
{
int num = 10;
int *p = &num;
*p = 20;//解引用操作符，通过p中存放的地址，找到p所指向的对象，*p就是p指向的对象
return 0;
}

指针变量的大小

#include <stdio.h>
//指针变量的大小取决于地址的大小
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
printf("%d\n", sizeof(char *));//4
printf("%d\n", sizeof(short *));//4
printf("%d\n", sizeof(int *));//4
printf("%d\n", sizeof(double *));//4
return 0;
}

结构体

结构体是把一些单一类型结合在一起。

struct Stu
{
char name[20];//名字
int age; //年龄
char sex[5]; //性别
char id[15]； //学号
};

结构体的初始化：

//打印结构体信息
struct Stu s = {"张三"， 20， "男"， "20180101"};
//.为结构成员访问操作符
printf("name = %s age = %d sex = %s id = %s\n", s.name, s.age, s.sex, s.id);
//->操作符
struct Stu *ps = &s;
printf("name = %s age = %d sex = %s id = %s\n", ps->name, ps->age, ps->sex, ps-
>id);