初识C语言_Part 1(零基础超详解!)

初识C语言 （1）

1.第一个C语言程序

1.1 hello world

#include
int main()
{
	printf("hello world");
	return 0;
}

这段代码成功在屏幕上打印出了 hello world

1.2代码介绍

1.2.1 main函数介绍

首先，下面这段代码是该.c源文件的主函数，也称main函数

int main()
{
	printf("hello world");
	return 0;
}

注意：
1.一个C语言程序是从main函数开始执行的，所以main函数是整个程序的入口。
2.C语言源程序只能含有一个main函数。(若含有多个main函数，C程序不知道该从哪里开始执行了，可以暂时这样理解)
3.C语言的main函数不仅有这一种写法

写法二：

void main()
{
	printf("hello world");
	return ;
}

4.对于写法二并不推荐，这种写法是在C语言诞生之初的写法，现在不太适用了。
5.main函数还有一个带参数的写法，现在暂时不谈，后续会讲解。

1.2.2 printf函数介绍

printf也是个函数，其功能是在屏幕上输出数据。但是这个函数并不是由我们自己进行底层实现的

注意：
1.printf这个函数是包含在一个库(stdio.h)中的，该库（也称为头文件）包含了很多函数，并且包含了相关函数的实现代码，所以，我们在使用printf函数时，要包含该头文件
2.头文件的包含方法： #include 其中#不能少，include是“包含”的意思，stdio.h代表 Standard input output.header 译为“标准输入输出头文件"。

1.2.3 "hello world"介绍

被""括起来的内容称之为字符串,该字符串放置于printf的括号内部可以直接在屏幕上
打印双引号里的内容,后续会深入讲解printf函数，这里大家先记住就好
注意："hello world"此处的双引号必须是英文输入法下的,不仅仅这里要用英文中的双引号，在我们写C语言代码时，所有的符号都必须是英文输入法下对应的符号。

1.2.4 return 0;介绍

return 0;这里的分号不能省略

此处return 0；代表程序正常退出，这里的0刚好与 main函数前的int(整型）相对应。

2.数据类型

2.1为什么存在数据类型？

在日常生活中，有各种各样的数据，例如，一个人的身高，体重，考试的成绩分数，
班上的人数，这些数据我们都有可能会用到，所以便产生了不同的数据类型。

2.2数据类型的分类

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

例如：一个人的升高1.78米就可以用float这个浮点型数据来表示，班上的人数就可以用int类型表示。

2.3 各种数据类型的大小

一般而言，不同的数据类型有着不同的大小，所以在内存中占用的空间自然也是不同的，那我们如何获取不同数据类型在内存中占用的空间内存呢？接下来就要用到sizeof操作符。
sizeof操作符的用法：sizeof(数据类型)/sizeof(变量名）通过sizeof运算符，我们可以求出不同数据类型在内存的占用内存的大小
我们看下边一段代码

include <stdio.h>
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;
}

运行结果：

那么这些数字的单位是什么呢？ 是字节。

我们要先了解：各种数据在内存中都是以二进制保存的，每个二进制位占用一个比特位（bit），八个二进制位占用的空间是八个位，称之为字节(Byte)。
1024个Byte就是1KB
1024KB就是1MB
1024MB就是GB
1024GB就是TB
1024TB就是PB
……

但是为什么数据会有这么多种类呢？
1.因为不同数据在内存中占用的空间不同，所以不同的数据类型的表示的数据范围是不一样的，一般而言，占用内存越大的数据，其能表示的数据范围越大
2.当我们想要表示一个班上的人数时，这个数据一般不会很大，所以就可以用char数据类型表示。这样做能更好的节省内存的空间。

3.变量

3.1变量的初始化

我们看下面这段代码:

#include
int main()
{
    int age = 18;//定义了一个age变量
    return 0;
}

上面这段代码定义了age这个变量并且为其赋值为18，这叫做变量的初始化。
其中，int 为age变量的类型，相当于age变量在内存中占用四个字节。

3.2变量的赋值

#include
int main()
{
    int age = 18;//定义了一个age变量
    age = 20；
    return 0;
}

其中age = 20;这条语句代表为变量赋值为20，用20覆盖了之前的18.

3.3变量的打印

#include
int main()
{
    int age = 18;
    int money = 100;
    age = 20；
    printf("%d %d\n", age,money);
    return 0;
}

上面这段代码会在屏幕上打印20，其中%d是一个转义字符，可以理解为占位符

int类型的占位符是%d,相当于第一个%d为age占位，第二个%d为money占位，呈现出一一对应的关系，但是不同的数据类型的占位不同(%后面跟的字母不同),后续会详细讲解。

3.4利用变量做个小测试

看下面一段代码：

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

scanf(“%d%d”, &num1, &num2);这行代码会通过scanf函数让我们输入两个数据，其中这两个数据用空格间隔，输入的数据会分别赋值给num1和num2，并将其相加的和赋值给sum，最后打印sum。

注意：
1.scanf(“%d%d”, &num1, &num2);这行代码中num1和num2前面的&(取地址符)不可省略
2.有些用户可能会出现报错，可以尝试将

define _CRT_SECURE_NO_WARNINGS 1

这段代码写在程序的第一行

现在只需要了解scanf函数的功能是从键盘上读入数据，scanf函数的返回值是读取到的数据的个数。后续会进行详细讲解。

3.5 全局变量和局部变量

3.5.1 全局变量：

#include
int age = 18;
int main()
{
    age = 20;
    printf("%d\n", age);
    return 0;
}

首先，要知道这段代码只有main函数这一个函数，而age这个变量是定义在这段代码中仅有的main函数之外的，所以，定义在所有函数之外的变量称之为全局变量对于全局变量，我们也可对其进行正常的赋值操作。

3.5.1 局部变量

#include
int main()
{
    int age = 18;
    int money = 100;
    age = 20；
    printf("%d %d\n", age,money);
    return 0;
}

像age和money这种定义在函数的大括号内部的变量称之为局部变量

注意：当全局变量和局部变量的变量名重复时，我们这时优先使用的是局部变量(局部优先原则)，看下面这段演示

#include
int age = 18;
int main()
{
    int age = 20;
    printf("%d\n", age);
    return 0;
}

运行结果：

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

3.6.1.作用域

定义：作用域（scope）是程序设计概念，通常来说，一段程序代码中所用到的名字并不总是有效/可用 的而限定这个名字的可用性的代码范围就是这个名字的作用域。

举个例子：

int main()
{
	{
		int a = 10;
		printf("%d\n", a);
	}
	//printf("%d\n", a); 这里会编译出错
	return 0;
}

我们在运行这段代码时，会编译出错，这是因为a这个变量是在3-6行这个大括号之内定义的，所以变量a的作用域就是其开始创建开始，直到第6行，在其他的区域就无法使用这个变量a了。

注意：全局变量的作用域是整个工程，只要语法符合要求，在main函数运行完毕之前，全局变量在程序的任何地方都可以使用。

3.6.2. 生命周期

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

1.局部变量的生命周期

相同的例子：

int main()
{
	{
		int a = 10;
		printf("%d\n", a);
	}
	//printf("%d\n", a); 这里会编译出错
	return 0;
}

因为a是在第4行定义的，所以其生命周期是在4-6行，所以当代码程序运行到了第7行时，a变量在内存中所占用的空间就被程序回收了，

即变量被销毁。

2.全局变量的生命周期是整个工程，全局变量当整个工程结束才会被销毁。

4.常量

分类：

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

4.1 字面常量

定义:例如：我们日常生活中人的血型，人的身高，这些都是字面常量。

int main()
{
    //字面常量
	"o型血";
	1.78;
	return 0;
}

4.2 const 修饰的常变量

例如;

int main()
{
	const int a = 10;
	//a = 20;//编译出错
	return 0;
}

注意：被const修饰的变量拥有了常属性，但其本质上还是变量。举个例子：

int main()
{
	const int a = 10;
	//int arr[a] = {1,2,3};//编译出错
	int arr1[10] = {1,2,3};
	return 0;
}

这里第4行编译出错，因为a本质上还是变量。

4.3 #define 定义的标识符常量

//定义了两个常量
#define MAX 1000
#define NAME "李四"

#include
int main()
{
	printf("%d", MAX);
	printf("%s",NAME);
	return 0;
}

注意：#define定义的常量就是真正意义上的常量,所以下面这段代码 并不会报错。

#define MAX 1000
#include
int main()
{
	const int a = 10;
	int arr[MAX] = { 1,2,3 };
	int arr1[1000] = {1,2,3};
	return 0;
}

4.4 枚举常量

枚举常量要使用enum关键字，当我们想要描述一个类型并且这个类型有很多分支时，就可以使用枚举，大括号中的每个量都是常量，只能在定义的时候对其值进行改变，其余情况均不可以。

#include 
//举例
enum Sex
{
 MALE,//只能在定义的时候改变其值。
 FEMALE,
 SECRET=4
};
//括号中的MALE,FEMALE,SECRET是枚举常量
int main()
{
    printf("%d\n", MALE);//打印0
    printf("%d\n", FEMALE);//打印1
    printf("%d\n", SECRET);//打印4
    return 0;
}

上述打印结果后面写枚举部分的文章的时候再进行解释。

5. 字符串

定义：类似于 “hello” 这种被双引号引起来的一串字符称为字符串字面值（String Literal），或者简称字符串。

注意：字符串是以’\0’这个转义字符结尾的。我们来看下面的示例代码：

int main()
{
	char arr1[] = { 'a','b','c' };//将'a' 'b' 'c' 这三个字符存放在arr1数组中
	char arr2[] = { "abc" };//将"abc"这个字符串存放于arr2数组中

	printf("%s\n", arr1);//打印出abc和一堆乱码
	printf("%s\n", arr2);//正常打印abc
	return 0;
}

上述代码第6行在abc之后为何会出现乱码的情况呢？

因为字符串是以’\0’这个转义字符结尾，并且以’\0’作为结束标志，arr1存放的一个一个的字符，并没有将’\0’这个结束标志加在末尾，而arr2存放的字符串，自带’\0’,所以当printf函数打印字符串时，遇到’\0’就停止打印，arr2正常打印，打印arr1时会一直向后打印，直到遇到’\0’才停止，所以会出现乱码的情况。

怎么才能让arr1正常打印呢？我们只需要在arr1这个数组的末尾主动添加一个’\0’即可。

int main()
{
	char arr1[] = { 'a','b','c' ,'\0'};
	char arr2[] = { "abc" };
	printf("%s\n", arr1);
	printf("%s\n", arr2);
	return 0;
}

我们看下面一个例子：

#include
#include//使用strlen函数要引用头文件
int main()
{
	char arr1[] = { 'a','b','c' };
	char arr2[] = { "abc" };
    //strlen用于计算字符串长度
	printf("%d\n", strlen(arr1));//打印一个大于3的随机数
	printf("%d\n", strlen(arr2));//打印3
	return 0;
}

第8行为何会打印一个随机数呢？其实这里更加印证了字符串以’\0’作为结束标志这个知识点，不过’\0’本身只是一个结束标志，不会被算作字符串的内容。

6 转义字符

当我们想通过printf函数打印 c:\code\test.c 这样一个文件目录时，我们试试下面这个方法：

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

却打印出了这个内容

显然，不是我们想要的，之所以出现这种情况，是因为这里的 ‘\t’ 被解释成为了其他的意义，也就是说，这里的t被转义了。所以，这里的 ‘\t’ 就是一个转义字符。

定义：在字符集中,以一个反斜杠 \ 开头,后面跟一个特定字符的形式被称为转义字符（又称：反斜杠字符），常见的转义字符大家可以去找找，也不用全部都记住，了解就可以。

这里我们重点讲解两个转义字符

• \ddd d d d表示1~3个八进制的数字。 如： \130 表示字符X
• \xdd d d表示2个十六进制数字。 如： \x30 表示字符0

看下边一段代码：

int main()
{
	printf("%c\n", '\130');//打印X
	printf("%c", '\x30');//打印0
	return 0;
}

这里打印出了X和0的原因是：我们日常生活中的每个字符都无法直接放入到内存之中，所以人们为了方便表示每个字符，就给每个字符设计一个编号，将常用的字符统计起来，就构成了ASCLL码表。

代码分析：我们将 ‘\130’ 转为10进制就是88，再去ASCLL码表中找到对应的字符就是X，因为是以%c的格式打印，所以就打印X这个字符，若是%d，则打印88。 ‘\x30’ 转为10进制就是48，对应字符0，最后将0打印出来。

注意：

• ‘\ddd’ 这里的d代表的是八进制数，只能是0-7的数字。
• ‘\xdd’ 这里的d代表的是十六进制数，只能是0-f。

7 注释

注释的分类：

1. /*xxxxxx*/ 这种注释无论中间有多少行代码，都会被注释掉，但是不能嵌套注释。
2. //xxxxxxxx 这种只能注释一行代码

注释的作用：

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

• 代码中有些代码比较难懂，可以加一下注释文字

• 被注释掉的内容是不会被编译器编译的，编译器在编译时会将这部分内容忽视掉

8 函数

当我们想要完成两个数的相加时，我们可以用下面这段代码：

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

而假如我们有很多组数据等着我们相加，我们就得每一次都使用这段代码，这样显得过于冗杂，对此，我们可以将两个数相加这种功能封装起来，组成一个函数，一般而言，一个函数对应完成一种功能。

我们将上面的代码改进一下：

//定义了一个Add函数
int Add(int x, int y)
{
	int z = x + y;
	return z;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	int sum = Add(a, b);//调用Add函数
	printf("%d", sum);
	return 0;
}

这段代码不理解没关系，后期会讲解函数的相关部分。

9 数组

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

//数组的定义方式
int arr[3] = {1,2,3};//定义了能存放三个元素的整型数组，

数组元素的访问：

int main()
{
	int arr[3] = { 1,2,3 };
    //分别访问数组的三个元素
	printf("%d\n", arr[0]);
	printf("%d\n", arr[1]);
	printf("%d\n", arr[2]);
	return 0;
}

注意：数组中的元素是连续存储的，并且数组的下标是从0开始的，数组的最后的一个元素的下标就是元素个数-1，

10 操作符

操作符的分类：

• 算术操作符：+ - * / %

• 移位操作符： >> <<

• 位操作符：& ^ |

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

• 单目操作符：

  1: !（逻辑反操作）

  C语言中，0表示假，非0表示真，我们来看下面一段示例代码：

  int main()
  {
  	printf("%d", 1 > 2);//在屏幕上打印0
  	return 0;
  }
  

  上述的代码的原因是因为：1>2这个条件的结果是假，所以最后用0表示，最终就会打印0.

  那当我们在1>2之前加一个!会怎样呢？

  int main()
  {
  	printf("%d",! (1 > 2));//打印1
  	return 0;
  }
  

  !会将表达式的逻辑值进行取反操作，只要是一个非0的数，经过这个!的操作，就会变成0，反之，表达式为0的经过!的操作，就会变成0。

  2：- （负值） +（正值）

  3：&（取地址符）

  4：sizeof ( 操作数的类型长度,以字节为单位) ,有关sizeof，我们来看下边一段示例代码：

  int main()
  {
  	int a = 10;
  	printf("%d", sizeof(a));//4
  	printf("%d", sizeof(int));//4
  	//printf("%d", sizeof int); 报错
  	return 0;
  }
  

  注意：用sizeof操作符时，当操作对象是关键字时括号不可以省略，但操作对象是变量时就可以省略，由此可见，sizeof并不总是需要括号的，所以，更加印证了sizeof并不是一个函数，因为函数的括号是不可以省略的。

  5：~ ( 对一个数的二进制按位取反)

  6: – 前置、后置–

  7：++ 前置、后置++

  关于前置和后置的++和–，我们看下面一段代码：

  int main()
  {
  	int a = 10;
  	int b = a++;
  	printf("%d %d\n", a, b);//11 10
  	b = ++a;
  	printf("%d %d", a, b);//12 12
  	return 0;
  }
  

  注意：

  • 后置++是先运算，再++，所以第4行先将10赋值给b，a再++变成11.
  • 前置++是先++，再运算，所以第6行，a先++变成12，再将12赋值给b。
  • 前置后置–运算符类似，这里就不作过多解释了。

• 关系操作符：>，>=，<,<=,==,!=.

• 逻辑操作符:&& ||

• 条件操作符: exp1 ? exp2 : exp3

  注意：条件表达式的执行逻辑是先判断exp1是否为真，为真则执行exp2，否则执行exp3。我们看下边一段示例代码：

  int main()
  {
  	int a = 2;
  	int b = 3;
  	a > b ? printf("%d", a) : printf("%d", b);//用于判断a b中的较大值。
  	return 0;
  }
  

• 逗号表达式: exp1, exp2, exp3, …expN

  注意：逗号表达式会从左至右依次执行，但是整个表达式的结果是最后一个表达式的结果。例如：

  int main()
  {
  	int a = 3;
  	int b = 2;
  	int c = 5;
  		//逗号表达式，是从左向右依次计算的，逗号表达式的结果是最后一个表达式的结果
  	int d = (a+=3, b=5, c=a+b, c-4);
  	//      a=6    b=5  c=11   7
  	printf("%d\n", d);
  	return 0;
  

  所以这段代码最终打印 7

10.总结

本章的内容就到这里啦，若有不足，欢迎评论区指正，最后，希望大佬们多多三连吧，下期见！