快速走遍C（语言）世界

最新推荐文章于 2024-06-05 08:23:32 发布

暴走的橙子～

最新推荐文章于 2024-06-05 08:23:32 发布

阅读量232

点赞数 5

分类专栏： C语言文章标签： c语言

本文链接：https://blog.csdn.net/qq_58724706/article/details/117883026

版权

C语言专栏收录该内容

28 篇文章 0 订阅

订阅专栏

准备好了吗？

首先，我们先了解一下C语言历史~

接下来让我们准备一下合适的编译器软件吧~

下载完成后是不是迫不及待打开试一下呀~

是不是觉得太简单而无聊了？接下来开始干货：

首先，我们先了解一下C语言历史~

C语言是一门通用计算机编程语言，广泛应用于底层开发。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。尽管C语言提供了许多低级处理的功能，但仍然保持着良好跨平台的特性，以一个标准规格写出的 C语言程序可在许多电脑平台上进行编译，甚至包含一些嵌入式处理器（单片机或称MCU）以及超级电脑等作业平台。

二十世纪八十年代，为了避免各开发厂商用的C语言语法产生差异，由美国国家标准局为C语言制定了一套完整的美国国家标准语法，称为ANSI C，作为C语言最初的标准。 [1] 目前 2011年12月8 日，国际标准化组织（ISO）和国际电工委员会（IEC）发布的C11标准是C语言的第三个官方标准，也是C语言的最新标准，该标准更好的支持了汉字函数名和汉字标识符，一定程度上实现了汉字编程。 C语言是一门面向过程的计算机编程语言，与C++，Java等面向对象的编程语言有所不同。其编译器主要有Clang、GCC、WIN-TC、SUBLIME、MSVC、Turbo C等。

接下来让我们准备一下合适的编译器软件吧~

VS2019在这里下载哦~（可免费使用的软件）：https://www.bilibili.com/video/BV17p4y1h7yR/

下载完成后是不是迫不及待打开试一下呀~

让我们用编译器向世界打个招呼吧！

#include
int main()
{
 printf("Hello world!--你好，世界！\n");
  return 0;
}

运行结果如下：

//解释：main函数是程序的入口，一个工程中main函数有且仅有一个。

是不是觉得太简单而无聊了？接下来开始干货：

数据类型：

char        //字符数据类型
short       //短整型
int         //整形
long        //长整型
long long   //更长的整形
float       //单精度浮点型
double      //双精度浮点型
//有个问题：C语言中有没有字符串类型？

那么思考：为什么出现这么的类型呢？

每种类型的大小是什么？

#include
int main()
{
	printf("%d\n", sizeof(char)); 
	printf("%d\n", sizeof(short));
	printf("%d\n", sizeof(int));
	printf("%d\n", sizeof(long));
	printf("%d\n", sizeof(long long));
	printf("%d\n", sizeof(float));
	printf("%d\n", sizeof(double));
	printf("%d\n", sizeof(long double));
	return 0;
}

每种类型对应的字节大小：

注意：存在这么多的类型，不仅是为了更加丰富的表达生活中的各种值，更是为了能够根据数据范围选择合适的数据类型，对内存空间合理的利用。

那么我们应该怎么合理选择合适的数据类型呢？

整型

如果我们定义的目标数字不太大，例如年龄，一般不会超过120岁（当然有例外，这时候可以用后面介绍的类型），我们可以用char（-128~127）来定义；统计年级人数时，人数可能几千人，我们可以选择short（-32768~32767）类型来定义。

当然在练习过程中我一般喜欢用int来定义，不用考虑太多的麻烦。

下面是我整理的-整型的有符号数取值范围：

char -128~127

short -32768~32767

int -2^31~2^31-1

long -2^64~2^64-1

浮点型

float：单精度，精度是2^23，能够保证六位。

double: 双精度，精度是是2^52，能保证15位。

变量、常量

生活中有些值是不会改变的（比如：圆周率、性别（？）、身份证号码等等）

有些值是可以改变的（比如：身高、年龄、物价等等）

类比于C语言，不变的值叫做常量，改变的值叫做变量。

字面常量

3.1415926
3

define定义的常量

#include
#define N 100

int main()
{
  int arr[N]={0};
  return 0;
}

注意：arr[ ]的"[]"里面只能放常量，如果上面代码可行，实际上就是#define定义的就是常量。

方法：define +空格+字母（习惯上用大写）+数字 -------------（注意后面没有分号）

const 修饰的常变量

const int a = 10;
int a = 9;

此时const修饰的变量a不能再被更改，编译器不能过去。这可以对不想改变的量就行锁定，不会被不小心更改。

注意：在这里要说明的是，const修饰的变量a还是常量，只是被赋予了常属性。

枚举常量

#include
   //举例
   enum Sex
   {
       MALE,
   FEMALE,
   SECRET,
   };
   //括号中的MALE、FEMALE、SECRET是枚举常量

变量

定义变量的方法：

int age=150;
int weight=50;
char='a';

变量的分类：

局部变量

全局变量

#include

int a=1;//全局变量

int main()

{

int b=2;//局部变量，就是放到main函数内部的变量

int a=2;//在main函数内外都定义一个变量，赋给不同的值会不会出错呢？不出错的话打印的 //a是多少呢？

printf("%d\n",a);

printf("%d\n",b);

return 0;

}

运行结果如下：

这说明了什么呢？----全局变量和局部变量可以同名定义，这时候局部变量优先使用。（划重点）

变量的使用

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

补充一下：输入函数scanf和输出函数printf使用的知识。

可以看到：变量num1取2，变量num2取3 后算出的的值。

变量的作用域和生命周期

作用域：

程序设计概念上通常来讲，一段程序代码中所使用的名字总不是一直可行有效的。

而限制这个所使用的名字可行范围叫作作用域。

注意：1. 局部变量的作用域是变量所在的局部范围。

2. 全局变量的作用域是整个工程。

生命周期：

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

1. 局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

2. 全局变量的生命周期是：整个程序的生命周期。

字符串+转义字符+注释

字符串

字符串：" Hello world ! \n "

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

注意：字符串的结束标志是一个 \0 的转义字符（虽然表面上没有体现出来，知人知串不知心啊）。在计算字符串长度的时候 \0 是结束标志，不算作字符串内容；在计算字符串空间大小时，\0却包括在内。

在具体打印字符串的时候\0具体起到什么作用呢？

直接上代码：

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

从运行结果我们可以看到，在字符串结尾有\0时打印的是"bit",没有\0的打印的是"bit烫烫烫烫蘠it".

总结：\0是字符串结束的标志，但是在实际打印中不会去打印。如果后面没有\0时，在打印过程中系统会一直往后面寻找，一直找到\0才会停止打印。

注意：arr1定义的字符串后面有一个默认的\0.

转义字符

如果我们想要在屏幕上打印一个目录： c:\code\test.c

我们会不会这样写？

#include
int main()
{
printf("c:\code\test.c\\n");
return 0;
}

这样写的结果却是这样：

发现这不是我们想要的结果啊！怎么回事？

这里就不得不提一下转义字符了。转义字符顾名思义就是转变意思。下面看一些转义字符。

#include
int main()
{
   //在屏幕上打印一个单引号‘，怎么做？双引号呢？
   printf("%c\n",'\'');
   printf("%s\n", "\"");
   return 0;
}

实际结果如下：

如果没有那个“多余的”--- ‘\’结果会怎么样？

哎呀，是不是发现出错了。不难得出结论，转义字符就是转变意思。

再来练习一下：

那我们打印\n该怎么做呢？

笔试题：

//程序输出什么？

#include

int main()

{

printf("%d\n", strlen("abcdef"));

printf("%d\n", strlen("c:\test\328\test.c")); // \32被解析成一个转义字符,8不会被解析成转义字符\ddd中ddd表示1~3个八进制数字，8 不属于0~7的范围。

return 0;

}

测试结果如下：

在这里注意的是 \32和 \t 被解析成一个转义字符，在计算长度时，只算成一个字符的长度。

注释

1. 代码中有不需要的代码可以直接删除，也可以注释掉

2. 代码中有些代码比较难懂，可以加一下注释文字来帮助理解代码

比如：

#include
Add(int x, int y)
{
   return x + y;
}
/*Div(int x, int y)
{
   return x / y;
}*/ //Div自定义的函数在下面没有用到，而且也不想用，那么可以采用 '/*' 和 ’*/‘来注释掉。
int main()
{
   //c++注释风格，下面注释掉的和打印的结果相同。如果保留一个，可以这样注释掉。
   //int a = 2;
   //int b = 3;
   //printf("%d\n", Add(a, b));
   printf("%d\n", Add(2, 3));
   return 0;
}

两种打印结果如下：

注释有两种风格：

c++风格的注释//xxxxxxx

可以注释一行也可以多行注释

c语言风格的注释/*xxxxxxx*/

缺陷：不能嵌套注释

函数

先看这两段代码：

#include
int main()
{
   int num1 = 0;
   int num2 = 0;
   int sum = 0;
   printf("请输入两个整数:");
   scanf("%d%d", &num1, &num2);
   sum = num1 + num2;
   printf("%d", sum);
   return 0;
}
用函数来定义
#include
int Add(int x, int y)
{
   return x + y;
}
int main()
{
   int num1 = 0;
   int num2 = 0;
   int sum = 0;
   printf("请输入两个整数:\n");
   scanf("%d%d", &num1, &num2);
   sum = Add(num1, num2);
   printf("%d", sum);
   return 0;
}

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

比如对于一些一直重复使用的算法，使用函数可以不断调用，来使代码变得简洁一些。

数组

c语言给了数组的定义：一组相同类型元素的集合。

如果要储存1~10的数字，使用数组该怎么存呢？

int arr[10]={1,2,3,4,5,6,7,8,9,10};//定义一个数组，存放1~10的数字

int arr[]={1,2,3,4,5,6,7,8,9,10};//定义一个数组，存放10个数字（在这里大括号里有10个数字，说明数组中存了10个int类型的数字）

既然学会了定义数组，那我们怎么来使用数组呢？

打印数组里的内容：

#include
int main()
{
   int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
   int i = 0;
   for (i = 0; i < 10; i++)
   {
       printf("%d ", arr[i]);
   }
   return 0;
}

打印的结果如下：

操作符

算术操作符

+ - * / %

移位操作符

<< >>

位操作符

& ^ |

赋值操作符

= += -= *= /= &= ^= |= >>= <<=

单目操作符

！逻辑反操作

- 负值

+ 正直

& 取地址

sizeof 操作数的类型长度（以字节为单位）

-- 前置、后置--

++ 前置、后置++

* 间接访问操作符(解引用操作符)

（类型）强制类型转换

关系操作符

>

>=

<

<=

== 用来测试相等

!= 用来测试不相等

逻辑操作符

&& ||

条件操作符

exp1 ? exp2 : exp3

逗号表达式

exp1, exp2, exp3, …expN

下标引用、函数调用和结构成员

[] () . ->

常见关键字

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:

顾名思义是类型定义，这里应该理解为类型重命名。

#include
//将 unsigned int 重名为u_int,所以u_int 也是一个类型名
typedef unsigned int u_int;
int main()
{
   u_int num1 = 20;
   unsigned int num2 = 20;
   //num1,num2的类型是一样的
   return 0;
}

define定义的常量和宏

//define定义的标识符常量
#define MAX 100
//define定义的宏
#include
#define Add( x , y) ( (x) + (y) )
int main()
{
printf("%d", Add(2, 3));
return 0;
}

运行结果如下：

指针

内存：

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

那么怎么使用指针呢？

#include
int main()
{
   int num = 10;
   int* p;
   p = &num;
   //int *p=&num; //第二种写法
   *p = 20;
   printf("%d", num);
   return 0;
}

运行结果：

指针定义其他类型的：

#include
int main()
{
   char ch = 'n';
   char* p = &ch;
   *p = 'm';
   printf("%c\n", ch);
   printf("%c", *p);
   return 0;
}

有没有感到很简单？

指针的大小

在32位平台上是4个字节；在64位平台上是8个字节。

结构体

结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。

比如描述学生，学生包含：名字+年龄+性别+学号这几项信息。

这里只能使用结构体来描述了。

那么如何使用呢？

#include
struct Stu
{
   char name[20]; //名字
   int age; //年龄
   char sex[5]; //性别
   char id[20]; //学号
};
int main()
{
   struct Stu s = { "张三", "20", "男", "47022004" };
   //.为结构体成员访问操作符
   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);
   return 0;
}