初识C语言

一、什么是C语言？

  C语言是一门通用计算机编程语言，广泛应用于底层开发。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

  二十世纪八十年代，为了避免各开发厂商用的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等。

  VS2013 / VS2019-是集成开发环境–集成了MSVC这样的编译器–可以编写+编译C语言的代码!
 
 

二、第一个C语言程序

2.1 创建一个项目

打开VS2019

选择空项目，其中可以选择语言，然后点击下一步

设置项目名称和位置，然后点击创建

这里代表项目创建好了，接下来创建源文件

2.2 创建一个源文件

右击源文件 - 添加 - 新建项

选择C++文件，设置名称，然后添加；这里我们除了添加源文件 .c ，我们还可以添加头文件 .h

2.3 写代码

创建完源文件是没有代码的，这里我们编写了第一个C语言程序，一个工程中main函数有且仅有一个，main函数是程序的入口

这里我们稍微了解一下

2.4 编译代码+运行

ctrl+F5是直接运行

也可以找到-调试-开始执行
 
 

三、数据类型

char       //字符数据类型
short     //短整型
int       //整形
long      //长整型
long long   //更长的整形
float      //单精度浮点数
double    //双精度浮点数

3.1 数据类型所占空间大小

sizeof - 关键字 - 操作符 - 计算类型或者变量所占空间的大小

3.2 计算中的单位

1 byte(字节) = 8 bit（比特）
1 kb = 1024 byte
1 mb = 1024 kb
1 gb = 1024 mb
1 tb = 1024gb
1 pb = 1024tb
 
 

四、变量、常量

  在计算机高级语言中，数据有俩种表现形式：变量和常量

4.1常量

  在程序运行过程中，其值不能被改变的量称为常量。

C语言中的常量分为以下以下几种：
字面常量
const 修饰的常变量
#define 定义的标识符常量
枚举常量

#include <stdio.h>
//举例
enum Sex
{
//要是MALE=3; 这里代表赋初值，那么下面的枚举常量就会接在3后面递增1，如下图
 MALE,
 FEMALE,
 SECRET
};
//括号中的MALE,FEMALE,SECRET是枚举常量
int main()
{
    //字面常量演示
    3.14;//字面常量
    1000;//字面常量
    
    //const 修饰的常变量　它本身的值具有常量的属性不能被改变。
    const float pai = 3.14f;   //这里的pai是const修饰的常变量
    pai = 5.14;//是不能直接修改的！
    
    int arr[10] = {0};//10个元素
    const int n = 10;
    int arr2[n] = {0};//n是变量的，这里是不行
    
    //#define的标识符常量 演示
 #define MAX 100
    printf("max = %d\n", MAX);
    
    //枚举常量演示
    printf("%d\n", MALE);   //0
    printf("%d\n", FEMALE);	//1
    printf("%d\n", SECRET); //2
    //注：枚举常量的默认是从0开始，依次向下递增1的
     return 0; 
     }

注：
上面例子上的 pai 被称为 const 修饰的常变量， const 修饰的常变量在C语言中只是在语法层面限制了
变量 pai 不能直接被改变，但是 pai 本质上还是一个变量的，所以叫常变量。

枚举常量：

4.2 变量

  在程序运行过程中，其值可以被改变的量称为变量

4.2.1 全局变量和局部变量

当局部变量和全局变量同名的时候，局部变量优先使用.

4.3 变量的作用域和生命周期

4.3.1 作用域

  作用域：是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。
  局部变量的作用域是变量所在的局部范围。
  全局变量的作用域是整个工程。

全局变量应用到整个工程，在另一个文件中使用extern进行变量并进行引用

4.3.2 生命周期

  生命周期：变量的生命周期指的是变量的创建到变量的销毁之间的一个时间段
  局部变量的生命周期是：进入作用域生命周期开始，出作用域生命周期结束。

  全局变量的生命周期是：整个程序的生命周期即main函数。
 
 

五、字符串+转义字符+注释

5.1 字符串 “hello bit.\n”

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

注：字符串的结束标志是一个 \0 的转义字符。在计算字符串长度的时候 \0 是结束标志，不算作字符串。

5.1.1 字符串的长度和打印字符串

\0转义字符的重要性

5.2 转义字符

  转义字符：顾名思义就是转变意思

5.2.1 常见的转义字符以及含义

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

例子：

5.2.2 转义字符\ddd八进制的数字 和 \xdd十六进制数字

一个转义字符占用 1 个长度

5.3 注释

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

5.3.1 注释的两种风格

1.C语言风格的注释 /*xxxxxx*/

缺陷：不能嵌套注释

2.C++风格的注释 //xxxxxxxx

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

六、选择语句(初始)

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

 
 

七、循环语句(初始)

C语言中如何实现循环呢？
7.1 while语句-讲解
7.2 for语句（后期讲）
7.3 do … while语句（后期讲）

//while循环的实例
#include <stdio.h>
int main()
{
    printf("开始学习\n");
    int line = 0;
    while(line<=20000)
   {
        line++;
        printf("继续努力敲代码%d\n",line);
   }
    if(line>20000)
        printf("好offer\n");
    return 0; 
    }

 
 

八、函数(初始)

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

int Add(int x, int y)
{
	int z = 0;
	z = x + y;
	return z;
}
int main()
{
	int num1 = 0;
	int num2 = 0;
	scanf("%d%d", &num1, &num2);
	
	//int sum = num1 + num2;
	//函数的方式解决
	int sum = Add(num1, num2);

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

	return 0;
}

 
 

九、数组(初始)

  数组 : 一组相同类型的元素的集合

9.1 数组定义

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

9.2 数组的下标

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

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

9.3 数组的使用

上面是运行结果

int main()
{
	//数组 - 一组相同类型的元素的集合
	//10个整形1-10存起来
	//数组是用下标来访问的
	//*
	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
	int i = 0;
	while (i < 10)
	{
		printf("%d ", arr[i]);
		i++;
	}
	char ch[5] = {'a', 'b', 'c'};//不完全初始化，剩余的默认为0

	return 0;
}

 
 

十、操作符

  简单介绍为主，后面课件重点讲。

10.1 常见操作符

算术操作符	+ - * / % （加减乘除模余）
移位操作符	>> << (左移右移)
位操作符	& ^ |
赋值操作符	= += -= *= /= &= ^= |= >>= <<=

10.2 单目操作符

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

10.3 关系操作符

关系操作符	含义
>	大于
>=	大于或等于
<	小于
<=	小于或等于
!=	用于测试“不相等”
==	用于测试“相等”

10.4 逻辑操作符

逻辑操作符	含义
&&	逻辑与
||	逻辑或

10.5 其他操作符

逗号表达式	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

11.1 关键字 typedef

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

 

11.2 关键字static

在C语言中：
static是用来修饰变量和函数的
1. 修饰局部变量-称为静态局部变量
2. 修饰全局变量-称为静态全局变量
3. 修饰函数-称为静态函数

11.2.1 修饰局部变量

//代码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); //这里输出 2 到 11
}
int main()
{
int i = 0;
    for(i=0; i<10; i++)
   {
        test();
   }
    return 0; }

 对比代码1和代码2的效果理解static修饰局部变量的意义。
结论：
 static修饰局部变量改变了变量的生命周期，让静态局部变量出了作用域依然存在，到程序结束，生命周期才结束。

11.2.2 修饰全局变量

代码1：没有修饰之前，extern 声明外部符号的

代码2：修饰之后，会报错

  代码1正常，代码2在编译的时候会出现连接性错误。
结论：
  一个全局变量被static修饰，使得这个全局变量只能在本源文件内使用，不能在其他源文件内使用。

11.2.3 修饰函数

代码1：没有修饰之前，extern 声明外部函数

代码2：修饰之后，会报错（原因和修饰全局变量一样）

  代码1正常，代码2在编译的时候会出现连接性错误.
结论：
  一个函数被static修饰，使得这个函数只能在本源文件内使用，不能在其他源文件内使用。

 
 

十二、#define 定义常量和宏

  宏：计算机科学里的宏是一种抽象(Abstraction),它根据一系列预定义的规则替换一定的文本横式、解释器或编译器在遇到定时会自动进行这一模式替换
例子：

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

这里在定义宏的时候要注意表达式得括起来

 
 

十三、指针

13.1 内存

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

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

取出变量地址如下：

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

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

int a= 10;
int *pa;//pa为一个整形指针变量,用来存放地址的
pa = &a;

13.2 指针的使用实例

//指针 就是 地址

13.3 指针变量的大小

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

  结论：指针大小在32位平台是4个字节，64位平台是8个字节。

 
 

十四、结构体

  结构体是C语言中特别重要的知识点，结构体使得C语言有能力描述复杂类型。比如描述学生，学生包含： 名字+年龄+性别+学号 这几项信息。这里只能使用结构体来描述了。

例如：结构体可以让C语言创建新的类型出来

创建一个学生的类型

struct Stu
{
	//成员变量
    char name[20];	//名字
	int age;		//年龄
	double score;	//成绩
};

创建一个的书的类型

struct Book
{
	char name[20];
	float price;
	char id[30];
};

结构体的初始化：

int main()
{
	struct Stu s = { "张三", 20, 85.5 };//结构体的创建和初始化
	
	//结构体变量.成员变量
	printf("1: %s %d %lf\n", s.name, s.age, s.score);

	// .操作符的使用
	struct Stu* ps = &s;
	printf("2: %s %d %lf\n", (*ps).name, (*ps).age, (*ps).score);

	// ->操作符的使用
	printf("3: %s %d %lf\n", ps->name, ps->age, ps->score);

	return 0;
}

运行结果