C基础系列教程 – 第 2 页 – HYL Studio

C基础系列教程8——指针2

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=
如果你觉得进度太快，可以等你熟悉了前面的内容后再继续往下看

上次我们说到，指针的一个用途，可以当作参数传递给函数进行使用，废话不说，直接上代码


void swap2(int *pa, int *pb) {
	int t = *pa;
	*pa = *pb;
	*pb = t;
}

void swap2(int *pa, int *pb) {

int t = *pa;

*pa = *pb;

*pb = t;

}

一定要记的上次说的，星号的两种使用，一种是在声明的时候，代表变量类型为指针，第二种是使用的时候根据指针所指的地址间接取值。同理，在参数的声明时候也一样。在上面的代码中，声明了两个参数，类型都是整数指针，也就是将要储存整数变量所在地址的变量（有点绕，配合上次的内存截图理解），接下来的三行是整数交换的操作。注意，t是一个局部的整数变量，pa是个整数指针，只有间接取值的结果才是一个整数。同理，*pb代表的是pb指向位置的内容，这是第三个星号的使用：间接的存储。这三行看似简单，但是如果不能理解指针就会非常容易出错，究竟是不是应该加星号是最容易纠结的地方。接下来的几张图将表示函数执行的过程（图中的地址只是为了便于理解，并不符合真实内存的分配规律，上次的截图才是真实的内存状态）。

假设两个数 a = 1， b = 2，调用语句是这样的swap2(&a, &b); 这样就传入了两个变量的地址。

传入的地址的值会被原封不动复制到pa和pb两个新的指针变量的内容中，如上图

第1行，分配一块内存当作t，并且存入pa所指向的内容，如上图

第2行，改写pa指向地址的值，如上图

第3行，改写pb指向地址的值，如上图

最后，函数结束，回收pa，pb，t三个变量占用的内存，如上图

这就是通过传入地址来间接交换两个变量，你可以用下面的代码观察结果


#include <stdio.h>
void swap1(int a, int b) {
	int t = a;
	printf("In swap1:\n");
	printf("a = %d, b = %d\n", a, b);
	a = b;
	b = t;
	printf("a = %d, b = %d\n", a, b);
	printf("swap1 end\n");
}
void swap2(int *pa, int *pb) {
	int t = *pa;
	printf("In swap2:\n");
	printf("a = %d, b = %d\n", *pa, *pb);
	*pa = *pb;
	*pb = t;
	printf("a = %d, b = %d\n", *pa, *pb);
	printf("swap2 end\n");
}
int main() {
	int a = 1;
	int b = 2;
	//int *pa = &a, pb = &pb;(注意这是错误的写法，每个变量声明都要加星号)
	int *pa = &a, *pb = &b;
	printf("In main:\n");
	printf("Before swap1\n");
	printf("a = %d, b = %d\n", a, b);
	swap1(a, b);
	printf("a = %d, b = %d\n", a, b);
	printf("Before swap2\n");
	printf("a = %d, b = %d\n", a, b);
	swap2(&a, &b);
	printf("a = %d, b = %d\n", a, b);
	printf("main end\n");
	system("pause");
	return 0;
}

#include <stdio.h>

void swap1(int a, int b) {

int t = a;

printf("In swap1:\n");

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

a = b;

b = t;

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

printf("swap1 end\n");

}

void swap2(int *pa, int *pb) {

int t = *pa;

printf("In swap2:\n");

printf("a = %d, b = %d\n", *pa, *pb);

*pa = *pb;

*pb = t;

printf("a = %d, b = %d\n", *pa, *pb);

printf("swap2 end\n");

}

int main() {

int a = 1;

int b = 2;

//int *pa = &a, pb = &pb;(注意这是错误的写法，每个变量声明都要加星号)

int *pa = &a, *pb = &b;

printf("In main:\n");

printf("Before swap1\n");

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

swap1(a, b);

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

printf("Before swap2\n");

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

swap2(&a, &b);

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

printf("main end\n");

system("pause");

return 0;

}

为了更好的理解值传递，下面的几张图将表示上一次的交换函数执行过程，也就是上面代码中的swap1，一样假设两个数a = 1, b = 2(图中的地址只是为了便于理解，并不符合真实内存的分配规律，上次的截图才是真实的内存状态）。

—————————我是萌萌哒分割线 ●▽● ———————————

参数传入后会像上次说的那样原封不动的复制一份到新的参数中，虽然同名（也可以不同名），但是本质上已经不是同一个变量了，如上图所示
—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

—————————我是萌萌哒分割线 ●▽● ———————————

最后，函数结束，回收a，b，t三个变量占用的内存，如上图
—————————我是萌萌哒分割线 ●▽● ———————————
下次介绍指针与数组的关系

C基础系列教程7——指针1

接下来主要是指针和结构体的使用，以及堆内存的分配。这些内容非常非常非常重要，将会在数据结构中大量使用，如果这些不懂，写数据结构的代码会比较困难。

首先是指针的使用，请思考，如何写一个函数，实现两个参数内容的交换？
比如我传入a = 1, b = 2,要求用函数交换这两个内容，你可能会写出这样的代码


void swap1(int a, int b) {
    int t = a;
    a = b;
    b = t;
}

void swap1(int a, int b) {

int t = a;

a = b;

b = t;

}

最初的想法一定是这样的，你肯定会想，直接把两个变量交换一下不就结了- –
你可以使用这段代码来测试这个函数


#include <stdio.h>
void swap1(int a, int b) {
	int t = a;
	printf("In swap1:\n");
	printf("a = %d, b = %d\n", a, b);
	a = b;
	b = t;
	printf("a = %d, b = %d\n", a, b);
	printf("swap1 end\n");
}
int main() {
	int a = 1;
	int b = 2;
	printf("Before swap1\n");
	printf("a = %d, b = %d\n", a, b);
	swap1(a, b);
	printf("a = %d, b = %d\n", a, b);
	system("pause");
	return 0;
}

#include <stdio.h>

void swap1(int a, int b) {

int t = a;

printf("In swap1:\n");

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

a = b;

b = t;

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

printf("swap1 end\n");

}

int main() {

int a = 1;

int b = 2;

printf("Before swap1\n");

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

swap1(a, b);

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

system("pause");

return 0;

}

你会发现运行结果是这样的
当swap1之中结束之前，两个变量的值还是被交换的，但是当回到主函数中的时候，两个变量的值又回到了交换前的状态。
原因是这样的，函数的参数在主程序时候传入的那个a，和函数中的a，在这个例子中名字都是a，但实际上确实两个不同的变量，当传入一个参数给函数时候，电脑会把传入的参数变量原封不动的复制一遍，当函数执行完毕后，复制出来的那份变量会被电脑销毁。所以当你在swap1中交换两个变量的时候，实际操作的是复制出来的那份a和b，原来的那份a和b根本就没被交换，所以才会出现函数执行之后回到交换之前的状态。

那么怎么解决这个问题呢？
变量实际上是存在内存中的，你可以想象成一个巨大的表格，每个单元格有自己的地址，如图所示，左侧的0xXXXXXXXX是个16进制的数字，就是这个单元格的地址，可以理解为这个格子的编号。执行完int a = 1;之后，电脑就会分配4个单元格（4个字节）当作变量a，并且把内容改为00000001（从下往上看，栈内存分配是从高到低分配，不懂也没关系，不要在意这些细节）
想一下，函数参数的传递既然都是值传递（也就是刚才说的原封不动的复制一份以前的内容放到一个新的地方），那么可不可以把单元格的地址传给函数，在函数内部更改指定地址的内容呢？答案是可以的，这样就引出了指针，我们把储存内存地址的变量叫做指针，如下图，储存了上图中变量a的地址。接下来介绍指针的基本语法
在C语言中，我们使用*来声明一个指针变量（也可以称作地址变量），使用&符号取一个变量的地址（这下知道为什么scanf的时候不能忘记&符号了吧），使用*来取出指针所指向地址中的内容（也就是取值），示例代码如下


#include<stdio.h>
int main() {
	int a = 5;
	int* pa = &a;
	printf("&a = %p\n", &a);
	printf("a = %d\n", a);
	printf("&pa = %p\n", &pa);
	printf("pa = %p\n", pa);
	printf("*pa = %d\n", *pa);
	system("pause");
	return 0;
}

#include<stdio.h>

int main() {

int a = 5;

int* pa = &a;

printf("&a = %p\n", &a);

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

printf("&pa = %p\n", &pa);

printf("pa = %p\n", pa);

printf("*pa = %d\n", *pa);

system("pause");

return 0;

}

需要注意的是，要注意区分两次星号的意义，第一个星号是声明一个整数类型的指针（四个字节，储存的是地址），第二个星号的意思是，先取出pa中的地址，再取出这个地址中的内容，是个间接的访问。（补充一点，在printf中%p用来显示内存地址，%d就不用说了吧）
你可以多次运行这段代码观察结果的规律，内存状态如下图所示。需要注意的是，你的运行结果和我图中结果一样的几率很小，但是规律肯定是一样的，因为每次运行电脑分配的内存都不一样。后两张是内存的状态，注意观察规律。

下一次介绍指针的应用之一，当作参数传递给函数，这样就可以解决开始提出的问题。。。
转载请注明出处，谢谢！

C基础系列教程6——函数


//上一篇文章中有一个打印指定数量的素数的题
//其中一种实现方法是这样的
/*
#include <stdio.h>

int main(int argc, const char * argv[]) {
	int n, i, j, flag;
	printf("Please input the extreme number you want to check: ");
	scanf("%d", &n);
	for (i = 2; i <= n; ++i) {
		flag = 1;
		for (j = 2; j <= i / 2; ++j) {
			if (i % j == 0) {
				flag = 0;
				break;
			}
		}
		if (flag == 1) {
			printf("%d is a prime number.\n", i);
		} else {
			printf("%d is not a prime number.\n", i);
		}
	}
	return 0;
}
*/
/*
你会发现for里面的内容越来越多
并且如果你尝试做了后几道题
会发现你的代码中会重复出现判断素数的代码
为了偷懒，接下来介绍函数
这里的函数类似数学上的函数，但是又有一些不一样
基本语法如下

声明语法:
返回值 函数名(参数列表);

定义语法:
返回值 函数名(参数列表) {
	函数体
}
参数列表可以有多个参数，用逗号隔开
格式是：
参数类型 参数

函数的使用方法是  函数名(参数1);
在使用之前必需在main函数前面声明
以素数判断为例
*/

#include <stdio.h>
//声明一个名叫Prime的函数
//要求一个整数型参数
//叫做number，返回值是int类型
//预想，如果是素数返回1，否则返回0
int isPrime(int number);
//主程序
int main(int argc, const char * argv[]) {
	int n, i;
	printf("argc = %d", argc);
	printf("Please input the extreme number you want to check: ");
	scanf("%d", &n);
	for (i = 2; i <= n; ++i) {
		//拿返回值和1对比，如果是1代表i是素数
		//if (isPrime(i) == 1) { //这是最好理解的写法
		//但是通常来说都会写成下面这样，请自行体会
		if (isPrime(i)) {
			printf("%d is a prime number.\n", i);
		} else {
			printf("%d is not a prime number.\n", i);
		}
	}
	system("pause");
	return 0;
}

//函数的定义
int isPrime(int number) {
//这里的number代表着其他函数传入的那个整数
//教材通常称之为形参，但是很多人分不清形参实参什么的
//你可以理解为是传入的那个变量的一个分身
//内容相同但是叫不同的名字，参数传递的细节会在后面教程说明
	int i;
	int ret = 1;
	for (i = 2; i <= number / 2; ++i) {
		if (number % i == 0) {
			ret = 0;
			break;
		}
	}
	//在写函数时候最好写成单一出口的结构
	//即只在函数结束有一个return
	//具体返回的值由一个变量代表
	//如果你的函数没有返回值，类型要写成void
	return ret;
}

/*
到这里你应该明白为什么main的样子是这样了吧？
int main(int argc, const char * argv[]) {
	return 0;
}

main函数作为C语言的入口函数，由系统调用
通常不写后面的参数，因为你运行程序时候没有给程序传参数
但是却一定要有一个int的返回值
是要告诉操作系统这个函数的执行状态，返回0代表正常结束
*/

100

101

102

103

104

105

106

107

108

//上一篇文章中有一个打印指定数量的素数的题

//其中一种实现方法是这样的

#include <stdio.h>

int main(int argc, const char * argv[]) {

int n, i, j, flag;

printf("Please input the extreme number you want to check: ");

scanf("%d", &n);

for (i = 2; i <= n; ++i) {

flag = 1;

for (j = 2; j <= i / 2; ++j) {

if (i % j == 0) {

flag = 0;

break;

}

if (flag == 1) {

printf("%d is a prime number.\n", i);

} else {

printf("%d is not a prime number.\n", i);

}

return 0;

}

你会发现for里面的内容越来越多

并且如果你尝试做了后几道题

会发现你的代码中会重复出现判断素数的代码

为了偷懒，接下来介绍函数

这里的函数类似数学上的函数，但是又有一些不一样

基本语法如下

声明语法:

返回值函数名(参数列表);

定义语法:

返回值函数名(参数列表) {

函数体

}

参数列表可以有多个参数，用逗号隔开

格式是：

参数类型参数

函数的使用方法是函数名(参数1);

在使用之前必需在main函数前面声明

以素数判断为例

#include <stdio.h>

//声明一个名叫Prime的函数

//要求一个整数型参数

//叫做number，返回值是int类型

//预想，如果是素数返回1，否则返回0

int isPrime(int number);

//主程序

int main(int argc, const char * argv[]) {

int n, i;

printf("argc = %d", argc);

printf("Please input the extreme number you want to check: ");

scanf("%d", &n);

for (i = 2; i <= n; ++i) {

//拿返回值和1对比，如果是1代表i是素数

//if (isPrime(i) == 1) { //这是最好理解的写法

//但是通常来说都会写成下面这样，请自行体会

if (isPrime(i)) {

printf("%d is a prime number.\n", i);

} else {

printf("%d is not a prime number.\n", i);

}

system("pause");

return 0;

}

//函数的定义

int isPrime(int number) {

//这里的number代表着其他函数传入的那个整数

//教材通常称之为形参，但是很多人分不清形参实参什么的

//你可以理解为是传入的那个变量的一个分身

//内容相同但是叫不同的名字，参数传递的细节会在后面教程说明

int i;

int ret = 1;

for (i = 2; i <= number / 2; ++i) {

if (number % i == 0) {

ret = 0;

break;

}

//在写函数时候最好写成单一出口的结构

//即只在函数结束有一个return

//具体返回的值由一个变量代表

//如果你的函数没有返回值，类型要写成void

return ret;

}

到这里你应该明白为什么main的样子是这样了吧？

int main(int argc, const char * argv[]) {

return 0;

}

main函数作为C语言的入口函数，由系统调用

通常不写后面的参数，因为你运行程序时候没有给程序传参数

但是却一定要有一个int的返回值

是要告诉操作系统这个函数的执行状态，返回0代表正常结束

C基础系列教程5——多重循环


//嵌套循环
//也就是循环里面还有循环
//最常用的是两个循环套在一起
//比如二维数组的初始化
//思路是这样的，你可以理解为首先先初始化一行的内容
//然后再套一个循环重复五次，也就是五行
#include <stdio.h>
int main() {
	int a[5][5];
	int i, j;
	for (i = 0; i < 5; i++) {
		for (j = 0; j < 5; j++) {
			a[i][j] = 10 * i + j;
		}
	}
	//同理输出二维数组
	for (i = 0; i < 5; i++) {
		for (j = 0; j < 5; j++) {
			printf("%02d ", a[i][j]);
		}
		printf("\n");//内层循环代表每行结束，所以加个换行
	}
	system("pause");
	return 0;
}
//同理，while 和 do-while也可以嵌套
//练习题
/*
要求：
输出指定大小的星号矩阵

输入格式：
两个数字，第一个数字指定宽度，第二个指定高度

输出格式：
指定大小的*矩阵

示例输入：
3 5

示例输出：
* * *
* * *
* * *
* * *
* * *
(注意每行最后一个星号后面没有多余的空格！)
*/











/*
答案
int x, y, i, j;
scanf("%d %d", &x, &y);
for (i = 1; i <= y; ++i) {
	for (j = 1; j <= x; ++j) {
		if (j != 1)printf(" ");
		printf("*");
	}
	printf("\n");
}
return 0;
*/

/*
课后习题：
1.输入一个数，判断它是否为素数
2.输入一个数字，输出指定数量的素数

拓展练习：
输入一个整数x，判断它是否是素数
如果不是则打印出提示
否则要求用户输入第二个整数y
输出x之后第y个素数
*/

//嵌套循环

//也就是循环里面还有循环

//最常用的是两个循环套在一起

//比如二维数组的初始化

//思路是这样的，你可以理解为首先先初始化一行的内容

//然后再套一个循环重复五次，也就是五行

#include <stdio.h>

int main() {

int a[5][5];

int i, j;

for (i = 0; i < 5; i++) {

for (j = 0; j < 5; j++) {

a[i][j] = 10 * i + j;

}

//同理输出二维数组

for (i = 0; i < 5; i++) {

for (j = 0; j < 5; j++) {

printf("%02d ", a[i][j]);

}

printf("\n");//内层循环代表每行结束，所以加个换行

}

system("pause");

return 0;

}

//同理，while 和 do-while也可以嵌套

//练习题

要求：

输出指定大小的星号矩阵

输入格式：

两个数字，第一个数字指定宽度，第二个指定高度

输出格式：

指定大小的*矩阵

示例输入：

3 5

示例输出：

* * *

(注意每行最后一个星号后面没有多余的空格！)

答案

int x, y, i, j;

scanf("%d %d", &x, &y);

for (i = 1; i <= y; ++i) {

for (j = 1; j <= x; ++j) {

if (j != 1)printf(" ");

printf("*");

}

printf("\n");

}

return 0;

课后习题：

1.输入一个数，判断它是否为素数

2.输入一个数字，输出指定数量的素数

拓展练习：

输入一个整数x，判断它是否是素数

如果不是则打印出提示

否则要求用户输入第二个整数y

输出x之后第y个素数

C基础系列教程4——简单循环


//有了数组，你会发现给数组指定初始值是一件十分麻烦的事情
//这是一件重复且有规律的事情，这种事是电脑最擅长做的事
//接下来介绍循环，主要有三种
//
// while循环 
// while (available conditon) {
//     Do something.
// }
//这种循环会首先判断available conditon这个逻辑表达式是否成立
//如果成立，就去做代码块里面的事情
//做完一次后再次检查条件是否符合
//直到逻辑表达式真值为假后退出循环

// do while循环
// do {
//     Do something.
// } while (available condition);
//这个循环只是在第一次判断之前先做一次代码块里面的事情
//然后在进行判断，也就是相当于第一种之前加了Do something


//
// for循环
// for(start status; ending status; changing status) {
//     Do something.
// } 
//需要注意的是三个条件是都是根据选填的
//中间用分号隔开！中间用分号隔开！中间用分号隔开！
//这个循环是最常用的循环之一，等价形式是这样的
/*
start status;
while (ending status) {
	Do something//这代表可能是一坨代码
	changing status;
}
*/
//来看两个例子
//第一个是打印用户指定数量的*
#include <stdio.h>

int main(int argc, const char * argv[]) {
	int time, i;
	printf("Please input how many stars do you want: ");
	scanf("%d", &time);
	for (i = 1; i <= time; ++i) {
		printf("*");
	}
	//执行步骤如下
	/*
	1.初始让i为1
	2.检查1 <= time是否成立
	  成立继续向下执行，否则退出
	4.打印一个*
	5.让i自增1
	6.执行2
	*/
	printf("\n");
	return 0;
}
//例2 初始化数组
/*
int i;
int a[10];
for (i = 0; i < 10; i++) {
	a[i] = i;
}
这样就完成了
a[0] = 0;
a[1] = 1;
...
a[9] = 9;
这10条语句
*/

/*
练习题
要求：
求等差数列1 + 2 + 3 +··· + n的值

输入格式
一个整数n，保证计算结果不会超出int范围

输出格式
一个整数

示例输入
100

示例输出
5050
答案在最后
*/











/*
答案
int a = 1, max, sum = 0;
scanf("%d", &max);
sum = (max + 1) * max / 2;

//while (a <= max) {
//	sum += a;
//	a++;
//}
	
//do {
//	sum += a;
//	a++;
//} while (a <= max);
	
printf("%d", sum);
*/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

//有了数组，你会发现给数组指定初始值是一件十分麻烦的事情

//这是一件重复且有规律的事情，这种事是电脑最擅长做的事

//接下来介绍循环，主要有三种

// while循环

// while (available conditon) {

// Do something.

// }

//这种循环会首先判断available conditon这个逻辑表达式是否成立

//如果成立，就去做代码块里面的事情

//做完一次后再次检查条件是否符合

//直到逻辑表达式真值为假后退出循环

// do while循环

// do {

// Do something.

// } while (available condition);

//这个循环只是在第一次判断之前先做一次代码块里面的事情

//然后在进行判断，也就是相当于第一种之前加了Do something

// for循环

// for(start status; ending status; changing status) {

// Do something.

// }

//需要注意的是三个条件是都是根据选填的

//中间用分号隔开！中间用分号隔开！中间用分号隔开！

//这个循环是最常用的循环之一，等价形式是这样的

start status;

while (ending status) {

Do something//这代表可能是一坨代码

changing status;

}

//来看两个例子

//第一个是打印用户指定数量的*

#include <stdio.h>

int main(int argc, const char * argv[]) {

int time, i;

printf("Please input how many stars do you want: ");

scanf("%d", &time);

for (i = 1; i <= time; ++i) {

printf("*");

}

//执行步骤如下

1.初始让i为1

2.检查1 <= time是否成立

成立继续向下执行，否则退出

4.打印一个*

5.让i自增1

6.执行2

printf("\n");

return 0;

}

//例2 初始化数组

int i;

int a[10];

for (i = 0; i < 10; i++) {

a[i] = i;

}

这样就完成了

a[0] = 0;

a[1] = 1;

...

a[9] = 9;

这10条语句

练习题

要求：

求等差数列1 + 2 + 3 +··· + n的值

输入格式

一个整数n，保证计算结果不会超出int范围

输出格式

一个整数

示例输入

100

示例输出

5050

答案在最后

答案

int a = 1, max, sum = 0;

scanf("%d", &max);

sum = (max + 1) * max / 2;

//while (a <= max) {

// sum += a;

// a++;

//}

//do {

// sum += a;

// a++;

//} while (a <= max);

printf("%d", sum);

C基础系列教程3——switch和数组基础

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧


//第二种分支结构，switch
/*
当你阅读到这的使用，你应该知道
当多层if else级联的时候如果
程序会逐层判断的条件
发现每次都不满足才会执行最里面一层
如果你的程序出现多层的ifelse嵌套
那么建议你使用switch
*/
/*
基础语法如下
switch (一个整数) {
case 情况1:语句1;break;
case 情况2:语句2;
case 情况3:语句3;break;
case 情况4:
	语句4;
	语句5;
	break;
case 情况5:语句6;break;
default:语句6;break;
}

首先，switch只能判断整数(字符也是整数，原因自己度娘)
对应的case后面的情况也只能写整数
这个语句会判断括号里的整数
去和底下你列出的所有case对比
飞快的找到对应的case后
从那个case后面的冒号开始执行
遇到第一个break跳出
遇到第一个break跳出
遇到第一个break跳出
重要的事情说三遍
也就是说如果你的情况匹配到了情况2
那么程序会一直执行到语句3结束
如果没有匹配的case就会执行default后面的东西
自行更改下面代码中的a，查看结果
*/
/*
#include <stdio.h>
int main() {
	int a = 500;
	switch (a) {
	case 1:printf("语句%d\n", a); break;
	case 2:printf("语句%d\n", a);
	case 3:printf("语句%d\n", a); break;
	case 4:
		printf("语句%d\n", a);
		printf("多余的一个语句\n"); break;
	case 5:printf("%d\n", a); break;
	default:printf("default", a); break;
	}
	system("pause");
	return 0;
}
*/
//接下来要介绍的是数组
//首先是最简单的一维数组

#include <stdio.h>
int main() {
	//定义方法是 类型名 数组名[长度];
	//常用的方法是这么几种
	int array0[10];
	//如果你不指定长度，后面的长度会由C编译器自己数
	int array1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };
	//最后一个逗号不会影响你程序的编译，但这是一个好的习惯，方便继续添加数据
	//你可以把数组想象成一个表格，每个单元格一个编号
	//编号从0开始
	//编号从0开始
	//编号从0开始
	//读取和修改对应内容可以通过 数组名[编号]来读取或修改
	array0[0] = 5;
	printf("array1[7] = %d", array1[7]);

	//同理，二维数组可以看作是一维数组的数组，定义方法如下
	int intArray0[5][5];
	//需要注意的是，如果你要用这种定义方式，必需指定第二维的长度
	int intArray1[][5]={
		{ 00, 01, 02, 03, 04 },
		{ 10, 11, 12, 13, 14 },
		{ 20, 21, 22, 23, 24 },
		{ 30, 31, 32, 33, 34 },
		{ 40, 41, 42, 43, 44 },
	};
	system("pause");
	return 0;
}

//第二种分支结构，switch

当你阅读到这的使用，你应该知道

当多层if else级联的时候如果

程序会逐层判断的条件

发现每次都不满足才会执行最里面一层

如果你的程序出现多层的ifelse嵌套

那么建议你使用switch

基础语法如下

switch (一个整数) {

case 情况1:语句1;break;

case 情况2:语句2;

case 情况3:语句3;break;

case 情况4:

语句4;

语句5;

break;

case 情况5:语句6;break;

default:语句6;break;

}

首先，switch只能判断整数(字符也是整数，原因自己度娘)

对应的case后面的情况也只能写整数

这个语句会判断括号里的整数

去和底下你列出的所有case对比

飞快的找到对应的case后

从那个case后面的冒号开始执行

遇到第一个break跳出

重要的事情说三遍

也就是说如果你的情况匹配到了情况2

那么程序会一直执行到语句3结束

如果没有匹配的case就会执行default后面的东西

自行更改下面代码中的a，查看结果

#include <stdio.h>

int main() {

int a = 500;

switch (a) {

case 1:printf("语句%d\n", a); break;

case 2:printf("语句%d\n", a);

case 3:printf("语句%d\n", a); break;

case 4:

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

printf("多余的一个语句\n"); break;

case 5:printf("%d\n", a); break;

default:printf("default", a); break;

}

system("pause");

return 0;

}

//接下来要介绍的是数组

//首先是最简单的一维数组

#include <stdio.h>

int main() {

//定义方法是类型名数组名[长度];

//常用的方法是这么几种

int array0[10];

//如果你不指定长度，后面的长度会由C编译器自己数

int array1[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, };

//最后一个逗号不会影响你程序的编译，但这是一个好的习惯，方便继续添加数据

//你可以把数组想象成一个表格，每个单元格一个编号

//编号从0开始

//读取和修改对应内容可以通过数组名[编号]来读取或修改

array0[0] = 5;

printf("array1[7] = %d", array1[7]);

//同理，二维数组可以看作是一维数组的数组，定义方法如下

int intArray0[5][5];

//需要注意的是，如果你要用这种定义方式，必需指定第二维的长度

int intArray1[][5]={

{ 00, 01, 02, 03, 04 },

{ 10, 11, 12, 13, 14 },

{ 20, 21, 22, 23, 24 },

{ 30, 31, 32, 33, 34 },

{ 40, 41, 42, 43, 44 },

};

system("pause");

return 0;

}

C基础系列教程2——逻辑表达式和判断语句

该系列文章内容可能来源我本人或者zhrmoe（他的主页：https://zhr.moe）的编写。文章如果有错误欢迎批评指正，谢谢！转载请注明来自本站，另外，本系列教程中的代码建议初学者自己手打一遍，不要直接复制（由于某些奇怪的原因可能会导致你复制的代码出现错误！相信自己的双手吧=-=


//逻辑表达式以及判断语句(第一种分支结构)
//在C语言中，逻辑表达式主要表达逻辑关系
//相等，不等，大于，小于之类的
#include <stdio.h>
int main() {
	/*
	比如下面这些都是C语言中的逻辑表达式
	C语言中的逻辑值用数字来代表，
	0代表假，非0都代表真(通常用1)

	请尝试计算以下逻辑表达式的计算结果(这个结果叫做真值)
	1 == 1
	1 == 2
	1 != 2
	3 < 4
	3 > 4
	3 <= 4
	3 >= 4
	2 <= 1 <= 3
	你可以用下面的代码来验证你的结果
	如果发现不一样，请思考为什么
	*/
	printf("1 == 1  -> %d\n", 1 == 1);
	printf("1 == 2  -> %d\n", 1 == 2);
	printf("1 != 2  -> %d\n", 1 != 2);
	printf("3 < 4  -> %d\n", 3 < 4);
	printf("3 > 4  -> %d\n", 3 > 4);
	printf("3 <= 4  -> %d\n", 3 <= 4);
	printf("3 >= 4  -> %d\n", 3 >= 4);
	printf("2 <= 1 <= 3  -> %d\n", 2 <= 1 <= 3);

	system("pause");
	return 0;
}

//把上面的这些简单逻辑表达式组合就可以组合出复合逻辑表达式
//两个简单表达式之间用这这两种符号进行连接 与&&  或|| 
//与运算结果为真当且仅当两个表达式同时为真
//或运算结果为真当且仅当两个表达式至少一个为真
// 另外，还有一个非运算：! 效果是取反,例如
//!1 == 0
//!0 == 1

//有了逻辑表达式我们就可以进行一些简单的判断了
//基本语法是这样的
/*
if (逻辑表达式) {
	语句1;
	语句2;
	语句3;
} else {
	语句4;
	语句5;
	语句6;
}
*/

//如果括号中的逻辑表达式真值为真
//那么将执行依次执行语句123，否则执行456

//阅读下面的2段代码，预测输出结果，并验证你的猜想是否正确
//如果不一样，请思考原因

//第一段
/*
int x = 1;
if (x = 2) {
	printf("hello1");
} else {
	printf("hello2");
}
*/


//第二段
/*
int x = -1;
if (x > 0);
printf("x > 0");
*/

//另外，if还有偷懒的写法
//比如
/*
if (1 < 5) printf("1");
else printf("2");
*/
//这样使用有一个条件，
//就是只有if后面只有一条语句的情况下才可以
//也就是说当你不写大括号的时候只会执行一条语句

//下面的代码格式是不建议使用的
//因为你无法清晰的知道逻辑的层次结构

/*
if (1 < 5)
	if (2 >= 1)
		printf("1");
	else
		printf("2");
*/
//如果你不写大括号，那么else会与和它最近的一个if组合在一起

//另外，如果有多个if else的逻辑结构是这样的
/*
if (逻辑表达式1) {
	语句块1;
} else {
	if (逻辑表达式2) {
		语句块2;
	} else {
		语句块3;
	}
}
*/
//那么就可以简写成这样
/*
if (逻辑表达式1) {
	语句块1;
} else if (逻辑表达式2) {
	语句块2;
} else {
	语句块3;
}
*/
//这称为if else的级联
/*
练习题：时间的转换
要求：
输入一个24小时制的时间，转换为12小时进制输出

输入格式：
两个数字，冒号隔开，第一个数字不会大于23
第二个数字不会大于59

输出格式:
如果是上午，输出时间加AM
如果是下午，输出时间加PM
规定中午12点整是下午

示例输入：
13:00

示例输出：
1:00 PM
答案在最后

*/
/*/

总结
1.注意数学表达式和 C语言表达式的区别，
尤其是“==”和“=”的区别。不要少打或多打等号。

2.连续不等式的表示问题0<=x<=10在C语言中应表达为
0 <= x && x <= 10， 不要想当然沿用数学的习惯写法

3.复杂逻辑表达式的运算问题，计算机会按照优先级从高
到底依次运算，逐层运算后输出结果，除了逻辑非都是双目
运算，电脑只会根据运算优先级从左往右运算。

4.注意if语句简写带来的逻辑歧义问题，细节决定成败，有
时候只差一个分号。当没有大括号并且满足条件时，if和else
执行到它后面第条语句为止

逻辑的基础：与&&  或||  非!  与运算要求两个表达式同时
为真，或运算要求两个表达式至少一个是真的，非运算是取反
。在C语言中，非零的值都被认为真

if的语句除非必要，否则不要轻易省略大括号
//*/
//答案
/*
int hour, minute;
scanf("%d:%d", &hour, &minute);
if (hour >= 12) {
	printf("%d:%02d PM", hour - 12, minute);
} else {
	printf("%d:%02d AM", hour, minute);
}
*/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

//逻辑表达式以及判断语句(第一种分支结构)

//在C语言中，逻辑表达式主要表达逻辑关系

//相等，不等，大于，小于之类的

#include <stdio.h>

int main() {

比如下面这些都是C语言中的逻辑表达式

C语言中的逻辑值用数字来代表，

0代表假，非0都代表真(通常用1)

请尝试计算以下逻辑表达式的计算结果(这个结果叫做真值)

1 == 1

1 == 2

1 != 2

3 < 4

3 > 4

3 <= 4

3 >= 4

2 <= 1 <= 3

你可以用下面的代码来验证你的结果

如果发现不一样，请思考为什么

printf("1 == 1 -> %d\n", 1 == 1);

printf("1 == 2 -> %d\n", 1 == 2);

printf("1 != 2 -> %d\n", 1 != 2);

printf("3 < 4 -> %d\n", 3 < 4);

printf("3 > 4 -> %d\n", 3 > 4);

printf("3 <= 4 -> %d\n", 3 <= 4);

printf("3 >= 4 -> %d\n", 3 >= 4);

printf("2 <= 1 <= 3 -> %d\n", 2 <= 1 <= 3);

system("pause");

return 0;

}

//把上面的这些简单逻辑表达式组合就可以组合出复合逻辑表达式

//两个简单表达式之间用这这两种符号进行连接与&& 或||

//与运算结果为真当且仅当两个表达式同时为真

//或运算结果为真当且仅当两个表达式至少一个为真

// 另外，还有一个非运算：! 效果是取反,例如

//!1 == 0

//!0 == 1

//有了逻辑表达式我们就可以进行一些简单的判断了

//基本语法是这样的

if (逻辑表达式) {

语句1;

语句2;

语句3;

} else {

语句4;

语句5;

语句6;

}

//如果括号中的逻辑表达式真值为真

//那么将执行依次执行语句123，否则执行456

//阅读下面的2段代码，预测输出结果，并验证你的猜想是否正确

//如果不一样，请思考原因

//第一段

int x = 1;

if (x = 2) {

printf("hello1");

} else {

printf("hello2");

}

//第二段

int x = -1;

if (x > 0);

printf("x > 0");

//另外，if还有偷懒的写法

//比如

if (1 < 5) printf("1");

else printf("2");

//这样使用有一个条件，

//就是只有if后面只有一条语句的情况下才可以

//也就是说当你不写大括号的时候只会执行一条语句

//下面的代码格式是不建议使用的

//因为你无法清晰的知道逻辑的层次结构

if (1 < 5)

if (2 >= 1)

printf("1");

else

printf("2");

//如果你不写大括号，那么else会与和它最近的一个if组合在一起

//另外，如果有多个if else的逻辑结构是这样的

if (逻辑表达式1) {

语句块1;

} else {

if (逻辑表达式2) {

语句块2;

} else {

语句块3;

}

//那么就可以简写成这样

if (逻辑表达式1) {

语句块1;

} else if (逻辑表达式2) {

语句块2;

} else {

语句块3;

}

//这称为if else的级联

练习题：时间的转换

要求：

输入一个24小时制的时间，转换为12小时进制输出

输入格式：

两个数字，冒号隔开，第一个数字不会大于23

第二个数字不会大于59

输出格式:

如果是上午，输出时间加AM

如果是下午，输出时间加PM

规定中午12点整是下午

示例输入：

13:00

示例输出：

1:00 PM

答案在最后

/*/

总结

1.注意数学表达式和 C语言表达式的区别，

尤其是“==”和“=”的区别。不要少打或多打等号。

2.连续不等式的表示问题0<=x<=10在C语言中应表达为

0 <= x && x <= 10，不要想当然沿用数学的习惯写法

3.复杂逻辑表达式的运算问题，计算机会按照优先级从高

到底依次运算，逐层运算后输出结果，除了逻辑非都是双目

运算，电脑只会根据运算优先级从左往右运算。

4.注意if语句简写带来的逻辑歧义问题，细节决定成败，有

时候只差一个分号。当没有大括号并且满足条件时，if和else

执行到它后面第条语句为止

逻辑的基础：与&& 或|| 非! 与运算要求两个表达式同时

为真，或运算要求两个表达式至少一个是真的，非运算是取反

。在C语言中，非零的值都被认为真

if的语句除非必要，否则不要轻易省略大括号

//*/

//答案

int hour, minute;

scanf("%d:%d", &hour, &minute);

if (hour >= 12) {

printf("%d:%02d PM", hour - 12, minute);

} else {

printf("%d:%02d AM", hour, minute);

}

课后习题：HDOJ 2001 2003
链接：http://acm.hdu.edu.cn/showproblem.php?pid=2001
http://acm.hdu.edu.cn/showproblem.php?pid=2003