BeginnersBook-C-语言教程-一-
BeginnersBook C 语言教程（一）
C 中的循环
C 编程中for的循环
循环用于重复执行语句块，直到给定条件返回false。
C for循环
这是 C 编程中最常用的循环之一。
for循环语法：
for (initialization; condition test; increment or decrement)
{
//Statements to be executed repeatedly
}
for循环流程图
步骤 1：首次初始化发生，计数器变量初始化。
步骤 2：在第二步中检查条件，其中计数器变量由给定条件测试，如果条件返回true则执行for循环体内的 C 语句，如果条件返回false，则for循环终止，控制流退出循环。
步骤 3：成功执行循环体内语句后，计数器变量会递增或递减，具体取决于操作（++或--）。
for循环的示例
#include <stdio.h>
int main()
{
int i;
for (i=1; i<=3; i++)
{
printf("%d\n", i);
}
return 0;
}
输出：
1
2
3
C 中的各种形式的for循环
我在以下所有例子中使用变量num作为计数器：
1）这里使用num = num + 1而不是num ++。
for (num=10; num<20; num=num+1)
2）初始化部分可以从循环中跳过，如下所示，计数器变量在循环之前声明。
int num=10;
for (;num<20;num++)
注意：即使我们可以跳过初始化部分但是分号（;）必须保留，否则你将得到编译错误。
3）与初始化一样，您也可以跳过增量部分，如下所示。在这种情况下，分号（;）必须在条件逻辑之后。在这种情况下，增量或减量部分在循环内完成。
for (num=10; num<20; )
{
//Statements
num++;
}
4）这也是可能的。计数器变量在循环之前初始化并在循环内递增。
int num=10;
for (;num<20;)
{
//Statements
num++;
}
5）如上所述，计数器变量也可以递减。在下面的示例中，每次循环运行时变量都会递减，直到条件num > 10返回false。
for(num=20; num>10; num--)
C 中的嵌套for循环
循环嵌套也是可能的。让我们举个例子来理解这个：
#include <stdio.h>
int main()
{
for (int i=0; i<2; i++)
{
for (int j=0; j<4; j++)
{
printf("%d, %d\n",i ,j);
}
}
return 0;
}
输出：
0, 0
0, 1
0, 2
0, 3
1, 0
1, 1
1, 2
1, 3
在上面的例子中，我们在另一个for循环中有一个for循环，这称为循环嵌套。我们使用嵌套for循环的示例之一是二维数组。
在 C 中循环内部进行多次初始化
我们可以在for循环中进行多次初始化，如下所示。
for (i=1,j=1;i<10 && j<10; i++, j++)
上面的循环和简单的for循环有什么区别？
-
它正在初始化两个变量。注意：两者都用逗号（
,）分隔。 -
它有使用 与（
&&）逻辑运算符连接在一起的两个测试条件。注意：您不能使用以逗号分隔的多个测试条件，您必须使用逻辑运算符，例如&&或||连接条件。 -
增量部分有两个变量。注意：应以逗号分隔。
具有多个测试条件的for循环的示例
#include <stdio.h>
int main()
{
int i,j;
for (i=1,j=1 ; i<3 || j<5; i++,j++)
{
printf("%d, %d\n",i ,j);
}
return 0;
}
C 编程中的while循环
循环用于重复执行语句块，直到给定条件返回false。在上一个教程中，我们学习了for循环。在本指南中，我们将学习while循环。
C - while循环
while循环的语法：
while (condition test)
{
//Statements to be executed repeatedly
// Increment (++) or Decrement (--) Operation
}
while循环流程图
while循环的示例
#include <stdio.h>
int main()
{
int count=1;
while (count <= 4)
{
printf("%d ", count);
count++;
}
return 0;
}
输出：
1 2 3 4
步骤 1：变量计数初始化为值 1，然后测试该条件。
步骤 2：如果条件返回true，则执行while循环体内的语句，否则控制退出循环。
步骤 3：使用++运算符递增计数值，然后再次测试循环条件。
猜测这个while循环的输出
#include <stdio.h>
int main()
{
int var=1;
while (var <=2)
{
printf("%d ", var);
}
}
该程序是无限循环的一个例子。由于变量var的值相同（此变量上没有使用++或 --运算符，因此在循环体内）条件var <= 2将永远为真，循环永远不会终止。
无限while循环的例子
例 1：
#include <stdio.h>
int main()
{
int var = 6;
while (var >=5)
{
printf("%d", var);
var++;
}
return 0;
}
无限循环： var将始终具有值>= 5，因此循环永远不会结束。
例 2：
#include <stdio.h>
int main()
{
int var =5;
while (var <=10)
{
printf("%d", var);
var--;
}
return 0;
}
无限循环：由于--运算符，var值将继续减小，因此它总是<= 10。
在while循环中使用逻辑运算符
就像关系运算符（< > <= >= == !=）一样，我们也可以在while循环中使用逻辑运算符。以下方案有效：
while(num1<=10 && num2<=10)
使用与（&&）运算符，这意味着两个条件都应该为真。
while(num1<=10||num2<=10)
或（||）运算符，此循环将运行，直到两个条件都返回false。
while(num1!=num2 &&num1 <=num2)
这里我们使用两个逻辑运算符 NOT（!）和 AND（&&）。
while(num1!=10 ||num2>=num1)
使用逻辑运算符的while循环示例
在这个例子中，我们在while循环中使用逻辑运算符测试多个条件。
#include <stdio.h>
int main()
{
int i=1, j=1;
while (i <= 4 || j <= 3)
{
printf("%d %d\n",i, j);
i++;
j++;
}
return 0;
}
输出：
1 1
2 2
3 3
4 4
C 编程的do-while循环
在上一个教程中，我们在 C 中学习while循环。do while循环类似于while循环，但有一个例外，它在检查条件之前执行do体内的语句。另一方面，在while循环中，首先检查条件，然后执行while循环中的语句。所以你可以说如果条件最初是假的那么do while会运行一次，但是while循环根本不会运行。
C - do..while循环
do-while循环的语法：
do
{
//Statements
}while(condition test);
do..while循环的流程图
do..while循环的示例
#include <stdio.h>
int main()
{
int j=0;
do
{
printf("Value of variable j is: %d\n", j);
j++;
}while (j<=3);
return 0;
}
输出：
Value of variable j is: 0
Value of variable j is: 1
Value of variable j is: 2
Value of variable j is: 3
C 中的while vs do..while循环
使用while循环：
#include <stdio.h>
int main()
{
int i=0;
while(i==1)
{
printf("while vs do-while");
}
printf("Out of loop");
}
输出：
Out of loop
使用do-while循环的相同示例：
#include <stdio.h>
int main()
{
int i=0;
do
{
printf("while vs do-while\n");
}while(i==1);
printf("Out of loop");
}
输出：
while vs do-while
Out of loop
说明：正如我在本指南开头所提到的，do-while至少运行一次，即使条件为false，因为条件被求值，执行循环体之后也是如此。
C - 循环控制语句
C 编程中的break语句
break语句用于循环内部和switch case 。
C - break语句
它用于立即退出循环。当在循环内遇到break语句时，控制流直接退出循环并且循环终止。它与if语句一起使用，只能在循环内使用。
这也可用于switch-case控制结构。每当在switch-case中遇到它时，控制器都会从switch-case中出来（参见下面的例子）。
break语句的流程图
语法：
break;
示例 - 在while循环中使用break
#include <stdio.h>
int main()
{
int num =0;
while(num<=100)
{
printf("value of variable num is: %d\n", num);
if (num==2)
{
break;
}
num++;
}
printf("Out of while-loop");
return 0;
}
输出：
value of variable num is: 0
value of variable num is: 1
value of variable num is: 2
Out of while-loop
示例 - 在for循环中使用break
#include <stdio.h>
int main()
{
int var;
for (var =100; var>=10; var --)
{
printf("var: %d\n", var);
if (var==99)
{
break;
}
}
printf("Out of for-loop");
return 0;
}
输出：
var: 100
var: 99
Out of for-loop
示例 - 在switch-case中使用break语句
#include <stdio.h>
int main()
{
int num;
printf("Enter value of num:");
scanf("%d",&num);
switch (num)
{
case 1:
printf("You have entered value 1\n");
break;
case 2:
printf("You have entered value 2\n");
break;
case 3:
printf("You have entered value 3\n");
break;
default:
printf("Input value is other than 1,2 & 3 ");
}
return 0;
}
输出：
Enter value of num:2
You have entered value 2
您总是希望在switch case块中使用break语句，否则一旦执行了case块，其余的后续 case 块就会执行。例如，如果我们不在每个case块之后使用break语句，那么这个程序的输出将是：
Enter value of num:2
You have entered value 2
You have entered value 3
Input value is other than 1,2 & 3
C - continue语句
continue语句用于循环。当在循环内遇到 continue语句时，控制流跳转到循环的开头以进行下一次迭代，跳过当前迭代循环体内语句的执行。
C - continue语句
语法：
continue;
continue语句的流程图
示例：for循环中的continue语句
#include <stdio.h>
int main()
{
for (int j=0; j<=8; j++)
{
if (j==4)
{
/* The continue statement is encountered when
* the value of j is equal to 4.
*/
continue;
}
/* This print statement would not execute for the
* loop iteration where j ==4 because in that case
* this statement would be skipped.
*/
printf("%d ", j);
}
return 0;
}
输出：
0 1 2 3 5 6 7 8
输出中缺少值 4，为什么？当变量j的值为 4 时，程序遇到一个continue语句，它使控制流跳转到for循环的开头以进行下一次迭代，跳过当前迭代的语句（这就是printf在j等于 4 时没有执行的原因）。
示例：在while循环中使用continue
在这个例子中，我们在while循环中使用continue。当使用while或do-while循环时，需要在continue上方放置一个递增或递减语句，以便在下一次迭代时更改计数器值。例如，如果我们不在if的正文中放置语句，那么counter的值将无限期地保持为 7。
#include <stdio.h>
int main()
{
int counter=10;
while (counter >=0)
{
if (counter==7)
{
counter--;
continue;
}
printf("%d ", counter);
counter--;
}
return 0;
}
输出：
10 9 8 6 5 4 3 2 1 0
当计数器值为 7 时，将跳过print语句。
do-While循环的continue的另一个例子
#include <stdio.h>
int main()
{
int j=0;
do
{
if (j==7)
{
j++;
continue;
}
printf("%d ", j);
j++;
}while(j<10);
return 0;
}
输出：
0 1 2 3 4 5 6 8 9
C - goto语句
goto语句很少使用，因为它会使程序混乱，不可读和复杂。而且，当使用它时，程序的控制将不容易跟踪，因此它使测试和调试变得困难。
C - goto语句
当在 C 程序中遇到goto语句时，控制流直接跳转到goto语句中提到的标签。
C 语言中goto的语法
goto label_name;
..
..
label_name: C-statements
goto流程图
goto语句的示例
#include <stdio.h>
int main()
{
int sum=0;
for(int i = 0; i<=10; i++){
sum = sum+i;
if(i==5){
goto addition;
}
}
addition:
printf("%d", sum);
return 0;
}
输出：
15
说明：在这个例子中，我们有一个标签addition，当i的值（内部循环）等于 5 时，我们使用goto跳转到这个标签。这就是sum显示直到 5 的数字之和的原因，即使循环设置为从 0 到 10 遍历。
C 中的数组教程
C 编程中的数组
数组是相同数据类型的分组（或集合）。例如，int数组包含int类型的元素，而float数组包含float类型的元素。
为什么我们需要在 C 编程中使用数组？
考虑一种情况，您需要找出用户输入的 100 个整数的平均值。在 C 中，您有两种方法可以执行此操作：1）使用int数据类型定义 100 个变量，然后执行 100 次scanf()操作以将输入的值存储在变量中，然后最后计算它们的平均值。 2）使用单个整数数组来存储所有值，循环数组以将所有输入的值存储在数组中，然后计算平均值。
依你来看哪种解决方案更好？ 显然是第二种解决方案，将相同的数据类型存储在一个变量中以及稍后使用数组索引访问它们很方便（我们将在本教程后面讨论）。
如何在 C 中声明数组
int num[35]; /* An integer array of 35 elements */
char ch[10]; /* An array of characters for 10 elements */
类似地，数组可以是任何数据类型，例如double，float，short等。
如何在 C 中访问数组的元素
您可以使用数组下标（或索引）来访问存储在数组中的任何元素。下标从 0 开始，这意味着arr[0]代表数组arr中的第一个元素。
通常，arr[n-1]可用于访问数组的第n个元素。其中n是任何整数。
例如：
int mydata[20];
mydata[0] /* first element of array mydata*/
mydata[19] /* last (20th) element of array mydata*/
数组示例：在 C 编程中找出 4 个整数的平均值
#include <stdio.h>
int main()
{
int avg = 0;
int sum =0;
int x=0;
/* Array- declaration – length 4*/
int num[4];
/* We are using a for loop to traverse through the array
* while storing the entered values in the array
*/
for (x=0; x<4;x++)
{
printf("Enter number %d \n", (x+1));
scanf("%d", &num[x]);
}
for (x=0; x<4;x++)
{
sum = sum+num[x];
}
avg = sum/4;
printf("Average of entered number is: %d", avg);
return 0;
}
输出：
Enter number 1
10
Enter number 2
10
Enter number 3
20
Enter number 4
40
Average of entered number is: 20
让我们讨论上述程序的重要部分：
将数据输入数组
这里我们将数组从 0 迭代到 3，因为数组的大小是 4。在循环内部，我们向用户显示一条消息以输入值。使用scanf函数将所有输入值存储在相应的数组元素中。
for (x=0; x<4;x++)
{
printf("Enter number %d \n", (x+1));
scanf("%d", &num[x]);
}
从数组中读出数据
假设，如果我们想要显示数组的元素，那么我们就可以在 C 中使用for循环。
for (x=0; x<4;x++)
{
printf("num[%d]\n", num[x]);
}
各种初始化数组的方法
在上面的例子中，我们刚刚声明了数组，然后我们用用户输入的值初始化它。但是，您也可以在声明期间初始化数组，如下所示：
int arr[5] = {1, 2, 3, 4 ,5};
或（两者都相同）
int arr[] = {1, 2, 3, 4, 5};
未初始化的数组始终包含垃圾值。
C 数组 - 内存表示
关于 C 中数组的更多主题：
2D 数组 - 我们可以在 C 中使用多维数组，如 2D 和 3D 数组。然而，最流行和最常用的数组是 2D - 二维数组。在这篇文章中，您将学习如何在 2D 数组中声明，读取和写入数据以及它的各种其他功能。
将数组传递给函数 - 通常我们在调用函数时传递值和变量，同样我们也可以将数组传递给函数。您可以将数组的元素以及整个数组（通过仅指定数组名称，它用作指针）传递给函数。
指向数组的指针 - 可以使用 C 中的指针访问和操作数组元素。使用指针可以轻松处理数组。只需将数组的基址分配给指针变量，就可以访问数组的所有元素。
首先学习 C 基础知识
C 编程中的二维（2D）数组
原文： https://beginnersbook.com/2014/01/2d-arrays-in-c-example/
数组数组称为 2D 数组。C 编程中的二维（2D）数组也称为矩阵。矩阵可以表示为行和列的表。在我们讨论更多关于二维数组之前，让我们来看看下面的 C 程序。
简单的二维（2D）数组示例
现在不用担心如何初始化二维数组，我们稍后会讨论该部分。该程序演示了如何将用户输入的元素存储在二维数组中以及如何显示二维数组的元素。
#include<stdio.h>
int main(){
/* 2D array declaration*/
int disp[2][3];
/*Counter variables for the loop*/
int i, j;
for(i=0; i<2; i++) {
for(j=0;j<3;j++) {
printf("Enter value for disp[%d][%d]:", i, j);
scanf("%d", &disp[i][j]);
}
}
//Displaying array elements
printf("Two Dimensional array elements:\n");
for(i=0; i<2; i++) {
for(j=0;j<3;j++) {
printf("%d ", disp[i][j]);
if(j==2){
printf("\n");
}
}
}
return 0;
}
输出：
Enter value for disp[0][0]:1
Enter value for disp[0][1]:2
Enter value for disp[0][2]:3
Enter value for disp[1][0]:4
Enter value for disp[1][1]:5
Enter value for disp[1][2]:6
Two Dimensional array elements:
1 2 3
4 5 6
2D 数组的初始化
在声明期间有两种方法初始化二维数组。
int disp[2][4] = {
{10, 11, 12, 13},
{14, 15, 16, 17}
};
要么
int disp[2][4] = { 10, 11, 12, 13, 14, 15, 16, 17};
虽然上述两个声明都是有效的，但我建议您使用第一个方法，因为它更具可读性，因为您可以在此方法中可视化 2d 数组的行和列。
初始化 2D 数组时必须考虑的事项
我们已经知道，当我们在声明期间初始化一个普通的数组（或者你可以说是一维数组）时，我们不需要指定它的大小。但是，对于 2D 数组而言，情况并非如此，即使在声明期间指定元素，也必须始终指定第二个维度。让我们在几个例子的帮助下理解这一点 -
/* Valid declaration*/
int abc[2][2] = {1, 2, 3 ,4 }
/* Valid declaration*/
int abc[][2] = {1, 2, 3 ,4 }
/* Invalid declaration – you must specify second dimension*/
int abc[][] = {1, 2, 3 ,4 }
/* Invalid because of the same reason mentioned above*/
int abc[2][] = {1, 2, 3 ,4 }
如何将用户输入数据存储到 2D 数组中
我们可以使用这个公式计算二维数组可以有多少元素：
数组arr[n1][n2]可以有n1 * n2个元素。我们在下面的示例中具有的数组具有尺寸 5 和 4。这些尺寸称为下标。所以这个数组的第一个下标值为 5，第二个下标值为 4。
因此数组abc[5][4]可以有5 * 4 = 20个元素。
为了存储用户输入的元素，我们使用两个for循环，其中一个是嵌套循环。外循环从 0 到（第一个下标减一），内部for循环从 0 到（第二个下标减一）。这样，用户输入元素的顺序将是abc[0][0]，abc[0][1]，abc[0][2]......等等。
#include<stdio.h>
int main(){
/* 2D array declaration*/
int abc[5][4];
/*Counter variables for the loop*/
int i, j;
for(i=0; i<5; i++) {
for(j=0;j<4;j++) {
printf("Enter value for abc[%d][%d]:", i, j);
scanf("%d", &abc[i][j]);
}
}
return 0;
}
在上面的例子中，我有一个整数类型的 2D 数组abc。从概念上讲，你可以像这样想象上面的数组：
然而，这个数组在内存中的实际表示将是这样的：
指针和二维数组
我们知道一维数组名称作为指向数组的基本元素（第一个元素）的指针。然而，在 2D 数组的情况下，逻辑略有不同。您可以将 2D 数组视为多个一维数组的集合。
所以 abc[0]将拥有第一行第一个元素的地址（如果我们考虑上面的图表编号 1）。
类似地abc[1]将具有第二行的第一个元素的地址。为了更好地理解它，让我们编写一个 C 程序 -
#include <stdio.h>
int main()
{
int abc[5][4] ={
{0,1,2,3},
{4,5,6,7},
{8,9,10,11},
{12,13,14,15},
{16,17,18,19}
};
for (int i=0; i<=4; i++)
{
/* The correct way of displaying an address would be
* printf("%p ",abc[i]); but for the demonstration
* purpose I am displaying the address in int so that
* you can relate the output with the diagram above that
* shows how many bytes an int element uses and how they
* are stored in contiguous memory locations.
*
*/
printf("%d ",abc[i]);
}
return 0;
}
输出：
1600101376 1600101392 1600101408 1600101424 1600101440
实际地址表示应为十六进制，我们使用%p而不是%d，如注释中所述。这只是为了表明元素存储在连续的内存位置。您可以将输出与上图相关联，以查看这些地址之间的差异实际上是该行元素消耗的字节数。
输出中显示的地址属于每行的第一个元素abc[0][0]，abc[1][0]，abc[2][0]，abc[3][0]和abc[4][0]。
C 编程中的指针和数组
原文： https://beginnersbook.com/2014/01/c-pointer-to-array-example/
在本指南中，我们将学习如何在 C 程序中使用指针和数组。我建议你在阅读本指南之前参考数组和指针教程，这样你就可以很容易地理解这里解释的概念了。
打印数组元素地址的简单示例
#include <stdio.h>
int main( )
{
int val[7] = { 11, 22, 33, 44, 55, 66, 77 } ;
/* for loop to print value and address of each element of array*/
for ( int i = 0 ; i < 7 ; i++ )
{
/* The correct way of displaying the address would be using %p format
* specifier like this:
* printf("val[%d]: value is %d and address is %p\n", i, val[i], &val[i]);
* Just to demonstrate that the array elements are stored in contiguous
* locations, I m displaying the addresses in integer
*/
printf("val[%d]: value is %d and address is %d\n", i, val[i], &val[i]);
}
return 0;
}
输出：
val[0]: value is 11 and address is 1423453232
val[1]: value is 22 and address is 1423453236
val[2]: value is 33 and address is 1423453240
val[3]: value is 44 and address is 1423453244
val[4]: value is 55 and address is 1423453248
val[5]: value is 66 and address is 1423453252
val[6]: value is 77 and address is 1423453256
请注意，每个元素之间存在 4 个字节的差异，因为这是整数的大小。这意味着所有元素都存储在内存中的连续位置。（参见下图）
在上面的例子中，我使用&val[i]来获取数组的第i个元素的地址。我们也可以使用指针变量而不是使用&符号来获取地址。
示例 - C 中的数组和指针示例
#include <stdio.h>
int main( )
{
/*Pointer variable*/
int *p;
/*Array declaration*/
int val[7] = { 11, 22, 33, 44, 55, 66, 77 } ;
/* Assigning the address of val[0] the pointer
* You can also write like this:
* p = var;
* because array name represents the address of the first element
*/
p = &val[0];
for ( int i = 0 ; i<7 ; i++ )
{
printf("val[%d]: value is %d and address is %p\n", i, *p, p);
/* Incrementing the pointer so that it points to next element
* on every increment.
*/
p++;
}
return 0;
}
输出：
val[0]: value is 11 and address is 0x7fff51472c30
val[1]: value is 22 and address is 0x7fff51472c34
val[2]: value is 33 and address is 0x7fff51472c38
val[3]: value is 44 and address is 0x7fff51472c3c
val[4]: value is 55 and address is 0x7fff51472c40
val[5]: value is 66 and address is 0x7fff51472c44
val[6]: value is 77 and address is 0x7fff51472c48
注意事项：
1）使用数组和指针时，指针的数据类型必须与数组的数据类型匹配。
2）你也可以使用数组名来初始化指针，如下所示：
p = var;
因为数组名称本身就等于数组的基址。
val==&val[0];
3）在循环中，对指针变量执行递增操作（p++）以获取下一个位置（下一个元素的位置），此算法对于所有类型的数组都是相同的（对于所有数据类型double，char，int等）即使每种数据类型消耗的字节不同。
指针逻辑
你必须已经理解了上面代码中的逻辑，所以现在是时候玩几个指针算术和表达式了。
if p = &val[0] which means
*p ==val[0]
(p+1) == &val[2] & *(p+1) == val[2]
(p+2) == &val[3] & *(p+2) == val[3]
(p+n) == &val[n+1) & *(p+n) == val[n+1]
使用这个逻辑，我们可以用更好的方式重写我们的代码：
#include <stdio.h>
int main( )
{
int *p;
int val[7] = { 11, 22, 33, 44, 55, 66, 77 } ;
p = val;
for ( int i = 0 ; i<7 ; i++ )
{
printf("val[%d]: value is %d and address is %p\n", i, *(p+i), (p+i));
}
return 0;
}
我们在这个程序中不需要p++语句。
在 C 编程中将数组传递给函数
原文： https://beginnersbook.com/2014/01/c-passing-array-to-function-example/
就像变量一样，数组也可以作为参数传递给函数。在本指南中，我们将学习如何使用按值调用和按引用调用方法将数组传递给函数。
要理解本指南，您应该具有以下 C 编程主题的知识：
使用按值调用方法将数组传递给函数
正如我们在这种类型的函数调用中已经知道的那样，实际参数被复制到形式参数中。
#include <stdio.h>
void disp( char ch)
{
printf("%c ", ch);
}
int main()
{
char arr[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'};
for (int x=0; x<10; x++)
{
/* I’m passing each element one by one using subscript*/
disp (arr[x]);
}
return 0;
}
输出：
a b c d e f g h i j
使用按引用调用将数组传递给函数
当我们在调用函数的同时传递数组的地址，然后这就是按引用函数调用。当我们传递一个地址作为参数时，函数声明应该有一个指针作为接收传递地址的参数。
#include <stdio.h>
void disp( int *num)
{
printf("%d ", *num);
}
int main()
{
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
for (int i=0; i<10; i++)
{
/* Passing addresses of array elements*/
disp (&arr[i]);
}
return 0;
}
输出：
1 2 3 4 5 6 7 8 9 0
如何将整个数组作为参数传递给函数？
在上面的例子中，我们在 C 中使用for循环逐个传递每个数组元素的地址。但是，您也可以将整个数组传递给这样的函数：
注意：数组名称本身是该数组的第一个元素的地址。例如，如果数组名称为
arr，则可以说arr等同于&arr[0]。
#include <stdio.h>
void myfuncn( int *var1, int var2)
{
/* The pointer var1 is pointing to the first element of
* the array and the var2 is the size of the array. In the
* loop we are incrementing pointer so that it points to
* the next element of the array on each increment.
*
*/
for(int x=0; x<var2; x++)
{
printf("Value of var_arr[%d] is: %d \n", x, *var1);
/*increment pointer for next element fetch*/
var1++;
}
}
int main()
{
int var_arr[] = {11, 22, 33, 44, 55, 66, 77};
myfuncn(var_arr, 7);
return 0;
}
输出：
Value of var_arr[0] is: 11
Value of var_arr[1] is: 22
Value of var_arr[2] is: 33
Value of var_arr[3] is: 44
Value of var_arr[4] is: 55
Value of var_arr[5] is: 66
Value of var_arr[6] is: 77
C - 字符串
C - 字符串和字符串函数
原文： https://beginnersbook.com/2014/01/c-strings-string-functions/
字符串是一个字符数组。在本指南中，我们将学习如何声明字符串，如何在 C 编程中使用字符串以及如何使用预定义的字符串处理函数。
我们将看到如何比较两个字符串，连接字符串，将一个字符串复制到另一个字符串，以及执行各种字符串操作。我们可以使用string.h头文件的预定义函数执行此类操作。要使用这些字符串函数，必须在 C 程序中包含string.h文件。
字符串声明
方法 1：
char address[]={'T', 'E', 'X', 'A', 'S', '\0'};
方法 2：上面的字符串也可以定义为：
char address[]="TEXAS";
在上面的声明中，空字符（\0）将自动插入字符串的末尾。
什么是空字符\0？
'\0'表示字符串的结尾。它也被称为字符串结尾或空字符。
C 编程中的字符串 I/O
使用printf()和scanf()函数在 C 中读取和编写字符串
#include <stdio.h>
#include <string.h>
int main()
{
/* String Declaration*/
char nickname[20];
printf("Enter your Nick name:");
/* I am reading the input string and storing it in nickname
* Array name alone works as a base address of array so
* we can use nickname instead of &nickname here
*/
scanf("%s", nickname);
/*Displaying String*/
printf("%s",nickname);
return 0;
}
输出：
Enter your Nick name:Negan
Negan
注意：%s格式说明符用于字符串输入/输出
使用gets()和puts()函数在 C 中读取和编写字符串
#include <stdio.h>
#include <string.h>
int main()
{
/* String Declaration*/
char nickname[20];
/* Console display using puts */
puts("Enter your Nick name:");
/*Input using gets*/
gets(nickname);
puts(nickname);
return 0;
}
C - 字符串函数
C 字符串函数 - strlen
语法：
size_t strlen(const char *str)
size_t 表示无符号短整数，它返回字符串的长度而不包括结束字符（终止字符\0）。
strlen的例子：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "BeginnersBook";
printf("Length of string str1: %d", strlen(str1));
return 0;
}
输出：
Length of string str1: 13
strlen vs sizeof
strlen返回存储在数组中的字符串的长度，但sizeof返回分配给数组的总大小。因此，如果我再次考虑上述示例，则以下语句将返回以下值。
strlen(str1)返回值 13。sizeof(str1)将返回值 20，因为数组大小为 20（请参阅main函数中的第一个语句）。
C 字符串函数 - strnlen
语法：
size_t strnlen(const char *str, size_t maxlen)
size_t表示无符号短整数。如果字符串小于为maxlen指定的值（最大长度），则返回字符串的长度，否则返回maxlen值。
strnlen的例子：
#include <stdio.h>
#include <string.h>
int main()
{
char str1[20] = "BeginnersBook";
printf("Length of string str1 when maxlen is 30: %d", strnlen(str1, 30));
printf("Length of string str1 when maxlen is 10: %d", strnlen(str1, 10));
return 0;
}
输出：
Length of string str1 when maxlen is 30: 13
Length of string str1 when maxlen is 10: 10
您是否注意到第二个printf语句的输出，即使字符串长度为 13，它只返回 10，因为maxlen为 10。
C 字符串函数 - strcmp
int strcmp(const char *str1, const char *str2)
它比较两个字符串并返回一个整数值。如果两个字符串相同（相等），则此函数将返回 0，否则它可能会根据比较返回负值或正值。
如果string1<string2或者string1是string2的子字符串，它会产生负值。如果string1>string2它将返回正值。
如果string1 == string2 ，那么当你将此函数用于比较字符串时，你会得到 0。
strcmp示例：
#include <stdio.h>
#include <string.h>
int main()
{
char s1[20] = "BeginnersBook";
char s2[20] = "BeginnersBook.COM";
if (strcmp(s1, s2) ==0)
{
printf("string 1 and string 2 are equal");
}else
{
printf("string 1 and 2 are different");
}
return 0;
}
输出：
string 1 and 2 are different
C 字符串函数 - strncmp
int strncmp(const char *str1, const char *str2, size_t n)
size_t用于无符号短整数。它比较字符串直到n个字符，或者换句话说，它比较两个字符串的前n个字符。
strncmp示例：
#include <stdio.h>
#include <string.h>
int main()
{
char s1[20] = "BeginnersBook";
char s2[20] = "BeginnersBook.COM";
/* below it is comparing first 8 characters of s1 and s2*/
if (strncmp(s1, s2, 8) ==0)
{
printf("string 1 and string 2 are equal");
}else
{
printf("string 1 and 2 are different");
}
return 0;
}
输出：
string1 and string 2 are equal
C 字符串函数 - strcat
char *strcat(char *str1, char *str2)
它连接两个字符串并返回连接的字符串。
strcat示例：
#include <stdio.h>
#include <string.h>
int main()
{
char s1[10] = "Hello";
char s2[10] = "World";
strcat(s1,s2);
printf("Output string after concatenation: %s", s1);
return 0;
}
输出：
Output string after concatenation: HelloWorld
C 字符串函数 - strncat
char *strncat(char *str1, char *str2, int n)
它将str2的n个字符连接到字符串str1。终结符（\0）将始终附加在连接字符串的末尾。
strncat示例：
#include <stdio.h>
#include <string.h>
int main()
{
char s1[10] = "Hello";
char s2[10] = "World";
strncat(s1,s2, 3);
printf("Concatenation using strncat: %s", s1);
return 0;
}
输出：
Concatenation using strncat: HelloWor
C 字符串函数 - strcpy
char *strcpy( char *str1, char *str2)
它将字符串str2复制到字符串str1中，包括结束字符（终结符\0）。
strcpy示例：
#include <stdio.h>
#include <string.h>
int main()
{
char s1[30] = "string 1";
char s2[30] = "string 2 : I’m gonna copied into s1";
/* this function has copied s2 into s1*/
strcpy(s1,s2);
printf("String s1 is: %s", s1);
return 0;
}
输出：
String s1 is: string 2: I’m gonna copied into s1
C 字符串函数 - strncpy
char *strncpy(char *str1, char *str2, size_t n)
size_t是无符号short，n是数字。
情况 1：如果str2的长度>n然后它只是将str2的前n个字符复制到str1中。
情况 2：如果str2的长度<n。然后它将str2的所有字符复制到str1中，并附加几个终结符字符（\0）以填充str1的长度使其成为n。
strncpy的例子：
#include <stdio.h>
#include <string.h>
int main()
{
char first[30] = "string 1";
char second[30] = "string 2: I’m using strncpy now";
/* this function has copied first 10 chars of s2 into s1*/
strncpy(s1,s2, 12);
printf("String s1 is: %s", s1);
return 0;
}
输出：
String s1 is: string 2: I’m
C 字符串函数 - strchr
char *strchr(char *str, int ch)
它在字符串str中搜索字符ch（您可能想知道在上面的定义中我已经将ch的数据类型赋予了int，不要担心我没有犯任何错误它应该只是int。事情是当我们将任何值给strchr时，它会在内部转换为整数以便更好地搜索。
strchr的例子：
#include <stdio.h>
#include <string.h>
int main()
{
char mystr[30] = "I’m an example of function strchr";
printf ("%s", strchr(mystr, 'f'));
return 0;
}
输出：
f function strchr
C 字符串函数 - strrchr
char *strrchr(char *str, int ch)
它类似于strchr函数，唯一的区别是它以相反的顺序搜索字符串，现在你已经理解为什么我们在strrchr中有额外的r，是的你猜对了它，它只是反向的。
现在让我们采用相同的上述示例：
#include <stdio.h>
#include <string.h>
int main()
{
char mystr[30] = "I’m an example of function strchr";
printf ("%s", strrchr(mystr, 'f'));
return 0;
}
输出：
function strchr
为什么输出与strchr不同？ 这是因为它从字符串的末尾开始搜索并在函数中找到第一个'f'而不是'of'。
C 字符串函数 - strstr
char *strstr(char *str, char *srch_term)
它类似于strchr，除了它搜索字符串srch_term而不是单个字符。
strstr示例：
#include <stdio.h>
#include <string.h>
int main()
{
char inputstr[70] = "String Function in C at BeginnersBook.COM";
printf ("Output string is: %s", strstr(inputstr, 'Begi'));
return 0;
}
输出：
Output string is: BeginnersBook.COM
您也可以使用此函数代替strchr，因为您也可以使用单个字符代替search_term字符串。
C 中的函数
C 编程中的函数
函数是执行特定任务的语句块。假设您正在使用 C 语言构建应用，并且在某个程序中，您需要多次执行相同的任务。在这种情况下，您有两种选择：
a）每次要执行任务时都使用相同的语句集
b）创建一个执行该任务的函数，并在每次需要执行该任务时调用它。
使用选项（b）是一种很好的做法，优秀的程序员总是在用 C 编写代码时使用函数。
函数类型
1）预定义的标准库函数 - 如puts()，gets()，printf()，scanf()等 - 这些函数已经在头文件中有定义（.h文件如stdio.h），所以我们只要在需要使用它们时调用它们。
2）用户定义函数 - 我们在程序中创建的函数称为用户定义函数。
在本指南中，我们将学习如何创建用户定义的函数以及如何在 C 编程中使用它们。
为什么我们需要 C 中的函数
由于以下原因使用函数：
a）提高代码的可读性。
b）提高代码的可重用性，可以在任何程序中使用相同的函数，而不是从头开始编写相同的代码。
c）如果使用函数，代码的调试会更容易，因为错误很容易被跟踪。
d）减少代码的大小，重复的语句集被函数调用替换。
函数的语法
return_type function_name (argument list)
{
Set of statements – Block of code
}
return_type：返回类型可以是任何数据类型，如int，double，char，void，short等。一旦你完成下面的例子，不要担心你会更好地理解这些术语。
function_name：它可以是任何东西，但建议为函数设置一个有意义的名称，这样只要看到它的名字就可以很容易地理解函数的用途。
参数列表：参数列表包含变量名称及其数据类型。这些参数是函数的一种输入。例如 - 用于相加两个整数变量的函数将具有两个整数参数。
代码块：C 语句集，只要对函数进行调用，就会执行。
您觉得上述术语令人困惑吗？ - 不要担心，在你学会了所有这些之前我不会结束本指南 😃
让我们举一个例子 - 假设你想创建一个函数来相加两个整数变量。
让我们分解问题，以便它易于理解：
函数将添加两个数字，因此它应该有一些有意义的名称，如sum，addition等。例如，让我们为这个函数取名。
return_type addition(argument list)
这个函数相加了两个整数变量，这意味着我需要两个整数变量作为输入，让我们在函数签名中提供两个整数参数。函数签名是：
return_type addition(int num1, int num2)
两个整数之和的结果仅为整数。因此函数应该返回一个整数值 - 我得到了我的返回类型 - 它将是整数：
int addition(int num1, int num2);
所以你得到了你的函数原型或签名。现在你可以在 C 程序中实现这样的逻辑：
如何在 C 中调用函数？
考虑以下 C 程序：
示例 1：创建用户定义的函数addition()
#include <stdio.h>
int addition(int num1, int num2)
{
int sum;
/* Arguments are used here*/
sum = num1+num2;
/* Function return type is integer so we are returning
* an integer value, the sum of the passed numbers.
*/
return sum;
}
int main()
{
int var1, var2;
printf("Enter number 1: ");
scanf("%d",&var1);
printf("Enter number 2: ");
scanf("%d",&var2);
/* Calling the function here, the function return type
* is integer so we need an integer variable to hold the
* returned value of this function.
*/
int res = addition(var1, var2);
printf ("输出： %d", res);
return 0;
}
输出：
Enter number 1: 100
Enter number 2: 120
输出： 220
示例 2：创建一个不返回任何内容的void用户定义函数
#include <stdio.h>
/* function return type is void and it doesn't have parameters*/
void introduction()
{
printf("Hi\n");
printf("My name is Chaitanya\n");
printf("How are you?");
/* There is no return statement inside this function, since its
* return type is void
*/
}
int main()
{
/*calling function*/
introduction();
return 0;
}
输出：
Hi
My name is Chaitanya
How are you?
有关 C 中函数的注意事项：
1）C 程序中的main()也是一个函数。
2）每个 C 程序必须至少有一个函数，即main()。
3）函数数量没有限制; C 程序可以具有任意数量的函数。
4）一个函数可以调用自身，它被称为“递归”。我已经为它写了一份单独的指南。
C 函数必须记住的术语
返回类型：返回值的数据类型。它也可以是void的，在这种情况下，函数不返回任何值。
注意：例如，如果函数返回类型是 char，那么函数应该返回char类型的值，并且在调用此函数时main()函数应该有一个char数据类型的变量来存储返回的值。
结构看起来像：
char abc(char ch1, char ch2)
{
char ch3;
…
…
return ch3;
}
int main()
{
…
char c1 = abc('a', 'x');
…
}
关于 C 中函数的更多主题
1） 函数 - 按值调用方法 - 在按值调用方法中，实际参数被复制到形式参数，因此函数对形式参数执行的任何操作都不会影响实际参数。
2） 函数 - 按引用调用方法 - 与按值调用不同，在此方法中，实际参数的地址被传递给形式参数，这意味着对形式参数执行的任何操作会影响实际参数的值。
C 编程中的按值函数调用
原文： https://beginnersbook.com/2014/01/c-function-call-by-value-example/
按值调用函数是在 C 编程中调用函数的默认方式。在我们按值讨论函数调用之前，让我们理解在解释这个时我们将使用的术语：
实际参数：函数调用中出现的参数。
形式参数：函数声明中出现的参数。
例如：
#include <stdio.h>
int sum(int a, int b)
{
int c=a+b;
return c;
}
int main(
{
int var1 =10;
int var2 = 20;
int var3 = sum(var1, var2);
printf("%d", var3);
return 0;
}
在上面的例子中，变量a和b是形式参数。变量var1和var2是实际参数。实际参数也可以是值。像sum(10,20)一样，这里 10 和 20 是实际参数。
在本指南中，我们将讨论按值函数调用。如果您想阅读按引用调用方法，请参考本指南：按引用函数调用。
让我们回到原点。
什么是按值函数调用？
当我们在调用函数的同时传递实际参数，这称为按值函数调用。在这种情况下，实际参数的值被复制到形式参数。因此，对形式参数执行的操作不反映在实际参数中。
函数按值调用的示例
如上所述，在按值调用时，实际参数被复制到形式参数，因此函数对参数执行的任何操作都不会影响实际参数。让我们举个例子来理解这个：
#include <stdio.h>
int increment(int var)
{
var = var+1;
return var;
}
int main()
{
int num1=20;
int num2 = increment(num1);
printf("num1 value is: %d", num1);
printf("\nnum2 value is: %d", num2);
return 0;
}
输出：
num1 value is: 20
num2 value is: 21
说明
我们在调用方法时传递变量num1，但由于我们使用按值调用方法调用函数，因此只将num1的值复制到形式参数var。因此，对var的更改不会反映在num1中。
示例 2：使用按值函数调用交换数字
#include <stdio.h>
void swapnum( int var1, int var2 )
{
int tempnum ;
/*Copying var1 value into temporary variable */
tempnum = var1 ;
/* Copying var2 value into var1*/
var1 = var2 ;
/*Copying temporary variable value into var2 */
var2 = tempnum ;
}
int main( )
{
int num1 = 35, num2 = 45 ;
printf("Before swapping: %d, %d", num1, num2);
/*calling swap function*/
swapnum(num1, num2);
printf("\nAfter swapping: %d, %d", num1, num2);
}
输出：
Before swapping: 35, 45
After swapping: 35, 45
为什么变量在交换后仍保持不变？
原因相同 - 函数由num1和num2的值调用。实际上var1和var2实际上是交换的（不是num1和num2）。在按值调用时，实际参数只是复制到形式参数中。
C 编程中的按引用函数调用
原文： https://beginnersbook.com/2014/01/c-function-call-by-reference-example/
在我们讨论按引用函数调用之前，让我们理解我们将在解释这个时使用的术语：
实际参数：函数调用中出现的参数。
形式参数：函数声明中出现的参数。
例如：我们有这样的函数声明：
int sum(int a, int b);
a和b参数是形式参数。
我们正在调用这样的函数：
int s = sum(10, 20); //Here 10 and 20 are actual parameters
or
int s = sum(n1, n2); //Here n1 and n2 are actual parameters
在本指南中，我们将讨论按引用函数调用方法。如果要阅读按值调用方法，请参考本指南：按值函数调用。
让我们回到原点。
什么是按引用函数调用？
当我们通过传递实际参数的地址来调用函数时，这种调用函数的方式称为按引用调用。在按引用调用时，对形式参数执行的操作会影响实际参数的值，因为对值执行的所有操作都存储在实际参数的地址中。它可能听起来很混乱，但下面的例子将清除你的怀疑。
按引用函数调用的示例
让我们举一个简单的例子。阅读以下程序中的注释。
#include <stdio.h>
void increment(int *var)
{
/* Although we are performing the increment on variable
* var, however the var is a pointer that holds the address
* of variable num, which means the increment is actually done
* on the address where value of num is stored.
*/
*var = *var+1;
}
int main()
{
int num=20;
/* This way of calling the function is known as call by
* reference. Instead of passing the variable num, we are
* passing the address of variable num
*/
increment(&num);
printf("Value of num is: %d", num);
return 0;
}
输出：
Value of num is: 21
示例 2：按引用函数调用 - 交换数字
这里我们使用按引用调用来交换数字。正如您所看到的，在调用swapnum()函数后，变量的值已经更改，因为交换发生在变量num1和num2的地址上。
#include
void swapnum ( int *var1, int *var2 )
{
int tempnum ;
tempnum = *var1 ;
*var1 = *var2 ;
*var2 = tempnum ;
}
int main( )
{
int num1 = 35, num2 = 45 ;
printf("Before swapping:");
printf("\nnum1 value is %d", num1);
printf("\nnum2 value is %d", num2);
/*calling swap function*/
swapnum( &num1, &num2 );
printf("\nAfter swapping:");
printf("\nnum1 value is %d", num1);
printf("\nnum2 value is %d", num2);
return 0;
}
输出：
Before swapping:
num1 value is 35
num2 value is 45
After swapping:
num1 value is 45
num2 value is 35
结构体
如何安装 Turbo C++：编译并运行 C 程序
您需要了解的第一件事是计算机（机器）只能理解机器语言（0 和 1 流）。为了将您的 C 程序源代码转换为机器代码，您需要编译它。编译器是将源代码转换为机器代码的东西。简单来说，您可以说编译器将人类可读代码转换为机器可读格式。
安装 Turbo C++：分步指南
下载链接：下载适用于 Windows 的 Turbo C++
步骤 1：找到TC.exe文件并将其打开。你会在位置C:\TC\BIN\找到它。
步骤 2：文件 -> 新建（如上图所示）然后编写 C 程序
#include<stdio.h>
int main()
{
printf("hello World!");
return 0;
}
步骤 3：使用F2（或者文件 -> 保存）保存程序，记住扩展名应为.c。在下面的屏幕截图中，我将它命名为helloworld.c。
步骤 4：使用Alt + F9或编译 -> 编译程序。编译（如下面的屏幕截图所示）。
步骤 5：按Ctrl + F9运行（或在菜单栏中选择运行 -> 运行）C 程序。
步骤 6 ：Alt + F5查看输出到屏幕上的程序输出。
使用 gcc 编译器编译和运行 C 程序
我们已经看到了使用 Turbo C++ 编译和执行 C 程序的步骤。我们也可以使用 gcc 编译器来做同样的事情。步骤如下：
源代码 Helloworld.c（文件应始终以.c扩展名保存）
# include<stdio.h>
int main()
{
puts ("hello World");
return 0;
}
编译它（它基本上是将helloworld.c文件转换为helloworld文件）
>gcc helloworld.c –o helloworld
>
如果您在 Windows 上编译，生成的文件将是helloworld.exe。
运行已编译的程序
一旦你给出了上面的命令，如果你在 Windows 上就会创建一个.exe文件，然后输入以下命令来运行源代码。
适用于 Windows
>helloworld
适用于 Mac 和 Linux 操作系统
>./helloworld
gcc 编译器采用人类可读格式（helloworld.c文件）并转换为 Windows，Linux 和 Mac OS X 的机器代码。
C 编程中的结构
原文： https://beginnersbook.com/2014/01/c-structures-examples/
结构是由单个名称表示的不同数据类型的一组变量。让我们举一个例子来理解 C 编程中结构的需要。
让我们说我们需要存储学生的数据，如学生姓名，年龄，地址，身份证等。这样做的一种方法是为每个属性创建一个不同的变量，但是当你需要存储多个学生的数据时，那么例如，您需要为每个学生再次创建这几个变量。以这种方式存储数据非常令人头疼。
我们可以通过使用结构轻松解决这个问题。我们可以创建一个具有name，id，address和age成员的结构，然后我们可以为每个学生创建这个结构的变量。这可能听起来令人困惑，不要担心我们会在示例的帮助下理解这一点。
如何在 C 编程中创建一个结构
我们使用 struct 关键字在 C 中创建结构。struct关键字是结构化数据类型的简短形式。
struct struct_name {
DataType member1_name;
DataType member2_name;
DataType member3_name;
…
};
这里struct_name可以是你选择的任何东西。成员数据类型可以相同或不同。一旦我们声明了结构，我们就可以使用struct name作为数据类型，如int，float等。
首先，我们将看到创建
struct变量，访问struct成员等的语法，然后我们将看到一个完整的示例。
如何声明结构的变量？
struct struct_name var_name;
或者：
struct struct_name {
DataType member1_name;
DataType member2_name;
DataType member3_name;
…
} var_name;
如何使用结构变量访问结构的数据成员？
var_name.member1_name;
var_name.member2_name;
…
如何为结构成员赋值？
有三种方法可以做到这一点。
1）使用点（.）运算符
var_name.memeber_name = value;
2）在一个声明中赋值所有成员
struct struct_name var_name =
{value for memeber1, value for memeber2 …so on for all the members}
3）指定初始值设定项 - 我们将在本文末尾讨论这个问题。
C 中的结构示例
#include <stdio.h>
/* Created a structure here. The name of the structure is
* StudentData.
*/
struct StudentData{
char *stu_name;
int stu_id;
int stu_age;
};
int main()
{
/* student is the variable of structure StudentData*/
struct StudentData student;
/*Assigning the values of each struct member here*/
student.stu_name = "Steve";
student.stu_id = 1234;
student.stu_age = 30;
/* Displaying the values of struct members */
printf("Student Name is: %s", student.stu_name);
printf("\nStudent Id is: %d", student.stu_id);
printf("\nStudent Age is: %d", student.stu_age);
return 0;
}
输出：
Student Name is: Steve
Student Id is: 1234
Student Age is: 30
C 中的嵌套结构：另一个结构中的结构
您可以在另一个结构中使用结构，这是相当可能的。正如我上面所解释的，一旦你声明了一个结构， struct struct_name 就像一个新的数据类型，所以你可以把它包含在另一个结构中，就像其他数据成员的数据类型一样。听起来很混乱？别担心。以下示例将清除您的疑问。
C 编程中嵌套结构的例子
假设我们有两个这样的结构：
结构 1：stu_address
struct stu_address
{
int street;
char *state;
char *city;
char *country;
}
结构 2：stu_data
struct stu_data
{
int stu_id;
int stu_age;
char *stu_name;
struct stu_address stuAddress;
}
正如你在这里看到的那样，我在另一个结构中嵌套了一个结构。
结构内部结构的赋值（嵌套结构）
让我们以上面看到的两个结构为例来理解逻辑
struct stu_data mydata;
mydata.stu_id = 1001;
mydata.stu_age = 30;
mydata.stuAddress.state = "UP"; //Nested struct assignment
..
如何访问嵌套结构成员？
使用.运算符链。
假设你想从嵌套结构中单独显示城市：
printf("%s", mydata.stuAddress.city);
在结构中使用typedef
typedef使代码简短并提高了可读性。在上面的讨论中，我们已经看到，每次使用结构时我们都必须使用冗长的语法，这会使代码混乱，冗长，复杂且可读性降低。这个问题的简单解决方案是使用typedef。它就像struct的别名。
没有typedef的代码
struct home_address {
int local_street;
char *town;
char *my_city;
char *my_country;
};
...
struct home_address var;
var.town = "Agra";
使用typedef的代码
typedef struct home_address{
int local_street;
char *town;
char *my_city;
char *my_country;
}addr;
..
..
addr var1;
var.town = "Agra";
每次需要声明struct变量时，不必使用struct home_address，只需使用addr，即我们定义的typedef。
指定初始值设定项以设置结构成员的值
我们已经学会了两种设置struct成员值的方法，还有另一种方法可以使用指定的初始化器来完成相同的操作。当我们只赋值结构的少数成员时，这很有用。在以下示例中，结构变量s2只有一个赋值的成员。
#include <stdio.h>
struct numbers
{
int num1, num2;
};
int main()
{
// Assignment using using designated initialization
struct numbers s1 = {.num2 = 22, .num1 = 11};
struct numbers s2 = {.num2 = 30};
printf ("num1: %d, num2: %d\n", s1.num1, s1.num2);
printf ("num1: %d", s2.num2);
return 0;
}
输出：
num1: 11, num2: 22
num1: 30
C 编程中的指针
C 编程中的指针
指针是存储另一个变量的地址的变量。与保存某种类型值的其他变量不同，指针保存变量的地址。例如，整数变量保存（或者可以说是存储）整数值，但整数指针保存整数变量的地址。在本指南中，我们将在示例的帮助下讨论 C 编程中的指针。
在我们讨论 C 中的指针之前，让我们举一个简单的例子来理解变量地址的含义。
一个简单的例子，了解如何在没有指针的情况下访问变量的地址？
在这个程序中，我们有一个int类型的变量。num的值是 10，这个值必须存储在内存中的某个地方，对吧？为保存该变量值的变量分配一个内存空间，该内存空间有一个地址。例如，我们住在一所房子里，我们的房子有一个地址，帮助其他人找到我们的房子。同样，变量的值存储在内存地址中，这有助于 C 程序在需要时找到该值。
因此，假设分配给变量num的地址是0x7fff5694dc58，这意味着我们应该将赋给num的任何值存储在以下位置：0x7fff5694dc58。见下图。
#include <stdio.h>
int main()
{
int num = 10;
printf("Value of variable num is: %d", num);
/* To print the address of a variable we use %p
* format specifier and ampersand (&) sign just
* before the variable name like &num.
*/
printf("\nAddress of variable num is: %p", &num);
return 0;
}
输出：
Value of variable num is: 10
Address of variable num is: 0x7fff5694dc58
C 中指针的一个简单例子
该程序显示如何声明和使用指针。我们可以使用指针做其他一些事情，我们在本指南后面讨论过它们。现在，我们只需要知道如何将指针链接到变量的地址。
需要注意的重点是：指针的数据类型和变量必须匹配，
int指针可以保存int变量的地址，类似地用float数据类型声明的指针可以保存float变量的地址。在下面的示例中，指针和变量都是int类型。
#include <stdio.h>
int main()
{
//Variable declaration
int num = 10;
//Pointer declaration
int *p;
//Assigning address of num to the pointer p
p = #
printf("Address of variable num is: %p", p);
return 0;
}
输出：
Address of variable num is: 0x7fff5694dc58
C 指针 - 与指针一起使用的运算符
让我们讨论一下用于 C 中的指针的运算符。
&地址运算符
我们在第一个例子中已经看到，我们可以使用&符号显示变量的地址。我用&num来访问变量num的地址。&运算符也称为地址运算符。
printf("Address of var is: %p", &num);
注意事项：%p是一种格式说明符，用于以十六进制格式显示地址。
既然您知道如何获取变量的地址，但如何将该地址存储在其他变量中？ 这就是指针有用的地方。如本指南开头所述，C 编程中的指针用于保存另一个变量的地址。
指针就像另一个变量，主要区别在于它存储另一个变量的地址而不是值。
“地址值”（*）运算符
*运算符也称为地址值运算符。
如何声明指针？
int *p1 /*Pointer to an integer variable*/
double *p2 /*Pointer to a variable of data type double*/
char *p3 /*Pointer to a character variable*/
float *p4 /*pointer to a float variable*/
以上是指针声明的几个例子。 如果你需要一个指针来存储整数变量的地址，那么指针的数据类型应该是 int 。同样的情况与其他数据类型有关。
通过使用*运算符，我们可以通过指针访问变量的值。
例如：
double a = 10;
double *p;
p = &a;
*p会给我们变量a的值。以下语句将显示 10 作为输出。
printf("%d", *p);
同样，如果我们像这样为*指针赋值：
*p = 200;
它会改变变量a的值。上面的语句会将a的值从 10 更改为 200。
使用&和*的指针示例
#include <stdio.h>
int main()
{
/* Pointer of integer type, this can hold the
* address of a integer type variable.
*/
int *p;
int var = 10;
/* Assigning the address of variable var to the pointer
* p. The p can hold the address of var because var is
* an integer type variable.
*/
p= &var;
printf("Value of variable var is: %d", var);
printf("\nValue of variable var is: %d", *p);
printf("\nAddress of variable var is: %p", &var);
printf("\nAddress of variable var is: %p", p);
printf("\nAddress of pointer p is: %p", &p);
return 0;
}
输出：
Value of variable var is: 10
Value of variable var is: 10
Address of variable var is: 0x7fff5ed98c4c
Address of variable var is: 0x7fff5ed98c4c
Address of pointer p is: 0x7fff5ed98c50
让我们举更多的例子来更好地理解它，让我们说我们有一个char变量ch和一个指向它的指针ptr。
char ch='a';
char *ptr;
读取ch 的值
printf("Value of ch: %c", ch);
or
printf("Value of ch: %c", *ptr);
改变ch 的值
ch = 'b';
or
*ptr = 'b';
上面的代码会将值'a'替换为'b'。
您能猜出以下 C 程序的输出吗？
#include <stdio.h>
int main()
{
int var =10;
int *p;
p= &var;
printf ( "Address of var is: %p", &var);
printf ( "\nAddress of var is: %p", p);
printf ( "\nValue of var is: %d", var);
printf ( "\nValue of var is: %d", *p);
printf ( "\nValue of var is: %d", *( &var));
/* Note I have used %p for p's value as it represents an address*/
printf( "\nValue of pointer p is: %p", p);
printf ( "\nAddress of pointer p is: %p", &p);
return 0;
}
输出：
Address of var is: 0x7fff5d027c58
Address of var is: 0x7fff5d027c58
Value of var is: 10
Value of var is: 10
Value of var is: 10
Value of pointer p is: 0x7fff5d027c58
Address of pointer p is: 0x7fff5d027c50
关于指针的更多主题
1） 指向指针的指针 - 一个指针可以指向另一个指针（这意味着它可以存储另一个指针的地址），这样的指针称为双重指针或者指针的指针。
2） 将指针传递给函数 - 指针也可以作为参数传递给函数，使用此功能可以按引用调用函数，并且可以将数组传递给函数。
3） 函数指针 - 函数指针就像另一个指针，它用于存储函数的地址。函数指针也可用于调用 C 程序中的函数。
C - 指向指针的指针（双重指针）
我们已经知道指针保存了同一类型的另一个变量的地址。当指针保存另一个指针的地址时，这种类型的指针称为指针的指针或双重指针。在本指南中，我们将学习什么是双重指针，如何声明它们以及如何在 C 编程中使用它们。要理解这个概念，你应该知道指针的基础知识。
如何在 C 中声明指针的指针（双重指针）？
int **pr;
这里pr是一个双重指针。在双重指针的声明中必须有两个*。
让我们借助图表来理解双重指针的概念：
根据图表，pr2是一个普通指针，它保存整数变量num的地址。图中还有另一个指针pr1，它保存另一个指针pr2的地址，这里的指针pr1是一个指向指针的指针（或双重指针）。
上图中的数值：
Variable num has address: XX771230
Address of Pointer pr1 is: XX661111
Address of Pointer pr2 is: 66X123X1
双重指针示例
让我们根据上面看到的图表编写一个 C 程序。
#include <stdio.h>
int main()
{
int num=123;
//A normal pointer pr2
int *pr2;
//This pointer pr2 is a double pointer
int **pr1;
/* Assigning the address of variable num to the
* pointer pr2
*/
pr2 = #
/* Assigning the address of pointer pr2 to the
* pointer-to-pointer pr1
*/
pr1 = &pr2;
/* Possible ways to find value of variable num*/
printf("\n Value of num is: %d", num);
printf("\n Value of num using pr2 is: %d", *pr2);
printf("\n Value of num using pr1 is: %d", **pr1);
/*Possible ways to find address of num*/
printf("\n Address of num is: %p", &num);
printf("\n Address of num using pr2 is: %p", pr2);
printf("\n Address of num using pr1 is: %p", *pr1);
/*Find value of pointer*/
printf("\n Value of Pointer pr2 is: %p", pr2);
printf("\n Value of Pointer pr2 using pr1 is: %p", *pr1);
/*Ways to find address of pointer*/
printf("\n Address of Pointer pr2 is:%p",&pr2);
printf("\n Address of Pointer pr2 using pr1 is:%p",pr1);
/*Double pointer value and address*/
printf("\n Value of Pointer pr1 is:%p",pr1);
printf("\n Address of Pointer pr1 is:%p",&pr1);
return 0;
}
输出：
Value of num is: 123
Value of num using pr2 is: 123
Value of num using pr1 is: 123
Address of num is: XX771230
Address of num using pr2 is: XX771230
Address of num using pr1 is: XX771230
Value of Pointer pr2 is: XX771230
Value of Pointer pr2 using pr1 is: XX771230
Address of Pointer pr2 is: 66X123X1
Address of Pointer pr2 using pr1 is: 66X123X1
Value of Pointer pr1 is: 66X123X1
Address of Pointer pr1 is: XX661111
关于此程序的输出存在一些混淆，当您运行此程序时，您将看到类似于此的地址：
0x7fff54da7c58。我以不同格式提供地址的原因，是我希望您将此程序与上图相关联。我已经使用了上图中的确切地址值，因此您可以轻松地将此程序的输出与上图相关联。
您还可以使用以下简单公式了解程序逻辑：
num == *pr2 == **pr1
&num == pr2 == *pr1
&pr2 == pr1
C - 函数指针
在 C 编程语言中，我们可以有一个概念，称为指向函数的指针。在本教程中，我们将学习如何声明函数指针以及如何使用此指针调用函数。要理解这个概念，你应该具备函数和指针的基本知识。**
如何声明函数指针？
function_return_type(*Pointer_name)(function argument list)
例如：
double (*p2f)(double, char)
这里double是函数的返回类型，p2f是函数指针的名称，(double, char)是这个函数的参数列表。这意味着此函数的第一个参数是double类型，第二个参数是char类型。
让我们借助一个例子来理解这一点：这里我们有一个函数sum，它计算两个数字的总和并返回总和。我们创建了一个指向此函数的指针f2p，我们使用此函数指针f2p调用该函数。
int sum (int num1, int num2)
{
return num1+num2;
}
int main()
{
/* The following two lines can also be written in a single
* statement like this: void (*fun_ptr)(int) = &fun;
*/
int (*f2p) (int, int);
f2p = sum;
//Calling function using function pointer
int op1 = f2p(10, 13);
//Calling function in normal way using function name
int op2 = sum(10, 13);
printf("Output1: Call using function pointer: %d",op1);
printf("\nOutput2: Call using function name: %d", op2);
return 0;
}
输出：
Output1: Call using function pointer: 23
Output2: Call using function name: 23
关于函数指针的一些要点：
- 如注释中所述，您可以在单个语句中声明一个函数指针并为其赋值函数，如下所示：
void (*fun_ptr)(int) = &fun;
- 您甚至可以从此语句中删除
&符号，因为单独的函数名称表示函数地址。这意味着上面的语句也可以这样写：
void (*fun_ptr)(int) = fun;
将指针传递给 C 中的函数
原文： https://beginnersbook.com/2014/01/c-passing-pointers-to-functions/
在本教程中，您将学习如何将指针作为参数传递给函数。要理解这个概念，你必须对 C 编程中的指针和函数有基本的了解。
就像任何其他参数一样，指针也可以作为参数传递给函数。让我们举一个例子来了解这是如何完成的。
示例：在 C 编程中将指针传递给函数
在这个例子中，我们传递一个指向函数的指针。当我们将指针而不是变量作为参数传递时，则传递变量的地址而不是值。因此，使用指针的函数所做的任何更改，都是在传递的变量的地址处永久进行的。这种技术在 C 中称为按引用调用。
尝试没有指针的同一个程序，你会发现奖金金额不会反映在工资中，这是因为函数所做的更改将对函数的局部变量进行。当我们使用指针时，值会在变量的地址处更改。
#include <stdio.h>
void salaryhike(int *var, int b)
{
*var = *var+b;
}
int main()
{
int salary=0, bonus=0;
printf("Enter the employee current salary:");
scanf("%d", &salary);
printf("Enter bonus:");
scanf("%d", &bonus);
salaryhike(&salary, bonus);
printf("Final salary: %d", salary);
return 0;
}
输出：
Enter the employee current salary:10000
Enter bonus:2000
Final salary: 12000
示例 2：使用指针交换两个数字
这是最流行的示例之一，显示如何使用按引用调用交换数字。
尝试没有指针的程序，你会看到数字没有交换。原因与我们在第一个例子中看到的相同。
#include <stdio.h>
void swapnum(int *num1, int *num2)
{
int tempnum;
tempnum = *num1;
*num1 = *num2;
*num2 = tempnum;
}
int main( )
{
int v1 = 11, v2 = 77 ;
printf("Before swapping:");
printf("\nValue of v1 is: %d", v1);
printf("\nValue of v2 is: %d", v2);
/*calling swap function*/
swapnum( &v1, &v2 );
printf("\nAfter swapping:");
printf("\nValue of v1 is: %d", v1);
printf("\nValue of v2 is: %d", v2);
}
输出：
Before swapping:
Value of v1 is: 11
Value of v2 is: 77
After swapping:
Value of v1 is: 77
Value of v2 is: 11
文件 I/O
在 C 编程中进行文件 I/O
在本指南中，我们将学习如何使用 C 编程语言对文件执行输入/输出（I/O）操作。
在我们详细讨论每个操作之前，让我们来看一个简单的 C 程序：
一个简单的 C 程序，用于打开，读取和关闭文件
#include <stdio.h>
int main()
{
/* Pointer to the file */
FILE *fp1;
/* Character variable to read the content of file */
char c;
/* Opening a file in r mode*/
fp1= fopen ("C:\\myfiles\\newfile.txt", "r");
/* Infinite loop –I have used break to come out of the loop*/
while(1)
{
c = fgetc(fp1);
if(c==EOF)
break;
else
printf("%c", c);
}
fclose(fp1);
return 0;
}
在上面的程序中，我们在r模式下打开文件newfile.txt，读取文件内容并在控制台上显示。让我们详细了解每个操作：
1. 打开文件
fopen()函数用于打开文件。
语法：
FILE pointer_name = fopen ("file_name", "Mode");
pointer_name可以是您选择的任何东西。
file_name是您要打开的文件的名称。在此处指定完整路径，如C:\\myfiles\\newfile.txt。
打开文件时，需要指定模式。我们用来读取文件的模式是r，它是“只读模式”。
例如：
FILE *fp;
fp = fopen("C:\\myfiles\\newfile.txt", "r");
第一个字符的地址存储在pointer fp中。
如何检查文件是否已成功打开？
如果文件未成功打开，则指针将被赋予NULL值，因此您可以编写如下逻辑：
此代码将检查文件是否已成功打开。如果文件未打开，则会向用户显示错误消息。
..
FILE fpr;
fpr = fopen("C:\\myfiles\\newfile.txt", "r");
if (fpr == NULL)
{
puts("Error while opening file");
exit();
}
各种文件打开模式：
使用fopen()函数打开文件，打开时可以根据需要使用以下任何一种模式。
模式r：这是一种只读模式，这意味着如果文件在r模式下打开，它将不允许您编写和修改它的内容。当fopen()成功打开文件时，它返回文件第一个字符的地址，否则返回NULL。
模式w：这是一种只写模式。fopen()函数在指定文件不存在时创建新文件，如果无法打开文件，则返回NULL。
模式a：使用此模式，内容可以附加在现有文件的末尾。与模式w类似，如果文件不存在，fopen()会创建一个新文件。在打开不成功时，它返回NULL。文件指针指向：文件的最后一个字符。
模式r+：此模式与模式r相同；但是，您可以对在此模式下打开的文件执行各种操作。您可以读取，写入和修改以r+模式打开的文件内容。文件指针指向：文件的第一个字符。
模式w+：与可以执行的操作相同的模式w相同；可以在此模式下读取，写入和修改文件。
模式a+：与模式a相同;您可以在文件中读取和附加数据，但在此模式下不允许进行内容修改。
2. 读取文件
要读取文件，我们必须首先使用任何模式打开它，例如，如果您只想读取文件，然后以r模式打开它。根据文件打开期间选择的模式，我们可以对文件执行某些操作。
C 程序：读取文件
fgetc()：该函数从当前指针的位置读取字符，成功读取后，将指针移动到文件中的下一个字符。一旦指针到达文件的末尾，该函数返回 EOF（文件结束）。我们在程序中使用了 EOF 来确定文件的结尾。
#include <stdio.h>
int main()
{
/* Pointer to the file */
FILE *fp1;
/* Character variable to read the content of file */
char c;
/* Opening a file in r mode*/
fp1= fopen ("C:\\myfiles\\newfile.txt", "r");
/* Infinite loop –I have used break to come out of the loop*/
while(1)
{
c = fgetc(fp1);
if(c==EOF)
break;
else
printf("%c", c);
}
fclose(fp1);
return 0;
}
3.写入文件
要写入文件，我们必须以支持写入的模式打开文件。例如，如果以r模式打开文件，则无法写入文件，因为r是只允许读取的只读模式。
示例：C 程序写入文件
该程序要求用户输入一个字符并将该字符写在文件的末尾。如果该文件不存在，则该程序将创建具有指定名称的文件，并将输入字符写入文件。
#include <stdio.h>
int main()
{
char ch;
FILE *fpw;
fpw = fopen("C:\\newfile.txt","w");
if(fpw == NULL)
{
printf("Error");
exit(1);
}
printf("Enter any character: ");
scanf("%c",&ch);
/* You can also use fputc(ch, fpw);*/
fprintf(fpw,"%c",ch);
fclose(fpw);
return 0;
}
4. 关闭文件
fclose(fp);
fclose()函数用于关闭打开的文件。作为参数，您必须提供指向要关闭的文件的指针。
在 C 中显示打开，读取，写入和关闭操作的示例
#include <stdio.h>
int main()
{
char ch;
/* Pointer for both the file*/
FILE *fpr, *fpw;
/* Opening file FILE1.C in “r” mode for reading */
fpr = fopen("C:\\file1.txt", "r");
/* Ensure FILE1.C opened successfully*/
if (fpr == NULL)
{
puts("Input file cannot be opened");
}
/* Opening file FILE2.C in “w” mode for writing*/
fpw= fopen("C:\\file2.txt", "w");
/* Ensure FILE2.C opened successfully*/
if (fpw == NULL)
{
puts("Output file cannot be opened");
}
/*Read & Write Logic*/
while(1)
{
ch = fgetc(fpr);
if (ch==EOF)
break;
else
fputc(ch, fpw);
}
/* Closing both the files */
fclose(fpr);
fclose(fpw);
return 0;
}
如何在文件中读/写（I/O）字符串 - fgets和fputs
在这里，我们将讨论如何读字符串和将其写到文件中。
char *fgets(char *s, int rec_len, FILE *fpr)
s ：存储字符串的字符数组。
rec_len ：输入记录的长度。
fpr ：指向输入文件的指针。
让我们举一个例子：
在 C 编程中从文件中读取字符串的示例
#include <stdio.h>
int main()
{
FILE *fpr;
/*Char array to store string */
char str[100];
/*Opening the file in "r" mode*/
fpr = fopen("C:\\mynewtextfile.txt", "r");
/*Error handling for file open*/
if (fpr == NULL)
{
puts("Issue in opening the input file");
}
/*Loop for reading the file till end*/
while(1)
{
if(fgets(str, 10, fpr) ==NULL)
break;
else
printf("%s", str);
}
/*Closing the input file after reading*/
fclose(fpr);
return 0;
}
在上面的例子中，我们使用了这样的fgets函数：
fgets(str, 10, fpr)
这里 str表示从文件中读取字符串后，存储字符串的缓冲区（char数组）。10 是每次需要读取的字符串的长度。fpr 是指向文件的指针，将被读取。
为什么我用if(fgets(str, 10, fpr) ==NULL)作为判断文件结尾的逻辑？
在上面的例子中，我们用ch == EOF来知道文件的结尾。这里我们使用了这个逻辑，因为当没有更多的记录可供读取时，fgets返回NULL。
C 程序 - 将字符串写入文件
int fputs ( const char * s, FILE * fpw );
char *s - char数组。
FILE *fpw - 指向文件的指针（FILE类型），将被写入。
#include <stdio.h>
int main()
{
FILE *fpw;
/*Char array to store strings */
char str[100];
/*Opening the file FILEW.TXT in "w" mode for writing*/
fpw = fopen("C:\\mynewtextfile2.txt", "w");
/*Error handling for output file*/
if (fpw== NULL)
{
puts("Issue in opening the Output file");
}
printf("Enter your string:");
/*Stored the input string into array – str*/
gets(str);
/* Copied the content of str into file –
* mynewtextfile2.txt using pointer – fpw
*/
fputs(str, fpw);
/*Closing the Output file after successful writing*/
fclose(fpw);
return 0;
}
fputs有两个参数：
fputs(str, fpw)
str - str表示存储字符串的数组。
fpw - 指向输出文件的FILE指针，需要在其中写入记录。
关于fputs的注意事项：默认情况下
fputs在写入每条记录后不会添加新行，为了手动执行此操作 - 每次写入文件后都可以使用以下语句。
fputs("\n", fpw);
C 文件 I/O：二进制文件
到目前为止，我们已经学习了文本文件的文件操作，如果文件是二进制文件（例如.exe文件）。上述程序不适用于二进制文件，但处理二进制文件时有一些细微的变化。主要区别在于文件名和模式。 让我们在一个例子的帮助下理解这一点。可以说我有两个二进制文件bin1.exe和bin2.exe- 我想将bin1.exe的内容复制到bin2.exe：
示例：在 C 中读取和写入二进制文件
#include <stdio.h>
int main()
{
char ch;
/* Pointers for both binary files*/
FILE *fpbr, *fpbw;
/* Open for bin1.exe file in rb mode */
fpbr = fopen("bin1.exe", "rb");
/* test logic for successful open*/
if (fpbr == NULL)
{
puts("Input Binary file is having issues while opening");
}
/* Opening file bin2.exe in “wb” mode for writing*/
fpbw= fopen("bin2.exe", "wb");
/* Ensure bin2.exe opened successfully*/
if (fpbw == NULL)
{
puts("Output binary file is having issues while opening");
}
/*Read & Write Logic for binary files*/
while(1)
{
ch = fgetc(fpbr);
if (ch==EOF)
break;
else
fputc(ch, fpbw);
}
/* Closing both the binary files */
fclose(fpbr);
fclose(fpbw);
return 0;
}
注意：文件打开模式为rb和wb而不是r和w
运算符优先级表
C 编程语言中的运算符优先级和关联性
原文： https://beginnersbook.com/2014/01/c-operator-precedence-table/
在本指南中，我们将学习 C 编程中的运算符优先级和关联性。
C 中的运算符优先级
运算符优先级确定当表达式具有多个运算符时，首先计算哪个运算符。例如，100-2 * 30将产生 40，因为它被求值为100 - (2 * 30)而不是(100-2)* 30。原因是乘法*的优先级高于减法（-）。
C 中的关联性
当表达式中存在两个或多个具有相同优先级的运算符时，使用关联性。例如，乘法和除法算术运算符具有相同的优先级，假设我们有一个表达式5 * 2/10，这个表达式将被计算为(5 * 2)/ 10，因为这些运算符的关联性是从左到右。类似地，20/2 * 5将被计算为(20 * 2)/ 5。
C 编程中的运算符优先级和关联表
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 函数表达式 | () |
左到右 |
| 数组表达式 | [] |
左到右 |
| 结构运算符 | -> |
左到右 |
| 一元减 | - |
右到左 |
| 递增递减 | -- ++ |
右到左 |
| 一元补 | ~ |
右到左 |
| 指针运算符 | & * |
右到左 |
| 输入 | （数据类型） | 右到左 |
| 尺寸运算符 | sizeof |
右到左 |
| 左右移位 | >> << |
算术运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 乘法、除法、模数运算符 | * / % |
左到右 |
| 加法、减法 | + - |
左到右 |
关系运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 小于 | < |
左到右 |
| 大于 | > |
左到右 |
| 小于等于 | <= |
左到右 |
| 大于等于 | >= |
左到右 |
| 等于 | == |
左到右 |
| 不等于 | != |
左到右 |
逻辑运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 与 | && |
左到右 |
| 或 | || |
左到右 |
| 非 | ! |
右到左 |
按位运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 与 | & |
左到右 |
| 异或 | ^ |
左到右 |
| 或 | | |
左到右 |
赋值运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
= |
右到左 | |
*= |
右到左 | |
/= |
右到左 | |
%= |
右到左 | |
+= |
右到左 | |
-= |
右到左 | |
& = |
右到左 | |
^= |
右到左 | |
|= |
右到左 | |
<<= |
右到左 | |
>>= |
右到左 |
其他运算符
| 描述 | 运算符 | 关联性 |
|---|---|---|
| 逗号 | , |
右到左 |
| 条件运算符 | ?: |
右到左 |
C 程序结构 - 第一个 C 程序
C 程序源代码可以在任何文本编辑器中编写；但是文件应该以.c扩展名保存。让我们编写第一个 C 程序。
第一个 C 程序
/* Demo Program written by Chaitanya on BeginnersBook.com*/
#include<stdio.h>
int main()
{
int num;
printf("Enter your age: ");
scanf("%d", &num);
if (num <18)
{
printf("you are not eligible for voting");
}
else
{
printf("You can vote!!");
}
return 0;
}
输出：
Enter your age:25
You can vote!!
让我们了解这个程序：
注释： 注释以/*开头，以*/结尾。注释不是强制性的，但如果您使用它们仍然是一个很好的做法，它提高了代码的可读性。程序可以包含任意数量的注释。
包含部分： 在编写程序时，我们使用了几个关键字、语句和函数，如 printf()，scanf()等。具有这些函数定义的文件需要包含在程序中。在上面的程序中我们使用了stdio.h。有几个库，stdio.h就是其中之一，用于从终端读取数据并在终端上显示数据。
显示语句： printf函数用于上述代码中的几个地方。无论你在双引号内给出什么，它都会在控制台上打印出来。您还可以对printf使用格式说明符（如%d，%c，%p）来显示变量和指针的值。
从用户那里获取输入： scanf函数用于从用户那里获取输入。当您运行此程序时，它等待用户输入（年龄），一旦用户输入年龄，它将根据用户输入的年龄来处理其余的语句。
main()函数： 它是所有 C 程序的起点。C 源代码的执行始于此函数。
有关 C 程序中main()函数的更多信息
main()函数应存在于所有 C 程序中，因为如果没有此函数，程序将无法启动。
main()函数的返回类型： main()函数的返回类型应始终为int。
为什么它有一个返回类型，它有什么用途呢？
编译器应该知道您的程序是成功执行还是失败。为了知道这一点，它检查函数main()的返回值。如果返回值为 0 则表示程序成功，否则它假定存在问题，这就是我们在main函数末尾有一个return 0语句的原因。
主函数的结构： 函数名称后跟返回类型。函数名后应该有一个紧密的括号。如果有参数或参数，则它必须在此括号内。大括号内的代码块是函数体。我们将在单独的教程中讨论更多关于函数的内容： C 编程中的函数。
C 示例
带输出的 C 编程示例
这里我们分享关于 C 编程的各种主题的 C 程序，例如数组，字符串，序列，面积和几何图形，数学计算，排序和搜索算法等等。我们的目标是为您提供在面试或课堂作业中可能遇到的所有 C 编程问题的完美解决方案。如果您没有找到您要找的内容，请在下面的评论部分中添加一行，以便我们可以将其添加到下面的 C 程序集中。学习快乐!!
C 教程
如果您对上述课程感到满意，并且能够理解和成功运行它们，没有任何问题，然后是时候让您更进一步，并借助示例和流程图详细了解 C 编程概念。这是链接：C 编程教程。
C 编程书籍
如果你想用 C 语言掌握编程，那么这些是你最好的书。参考他们并练习我上面分享的程序。
- K.N. King 的《C 编程：现代方法》
- Brian W. Kernighan 和 Dennis M. Ritchie 的《C 编程语言》
- Yashavant Kanetkar 的《Let Us C》
C 库函数教程
C strcat()函数
原文： https://beginnersbook.com/2017/11/c-strcat-function-with-example/
strcat()函数用于字符串连接。它在另一个指定字符串的末尾连接指定的字符串。在本教程中，我们将看到带示例的 strcat()函数。
C strcat()声明
char *strcat(char *str1, const char *str2)
此函数将两个指针作为参数，并在连接后返回指向目标字符串的指针。
str1 - 指向目标字符串的指针。
str2 - 指向附加到目标字符串的源字符串的指针。
示例：C strcat()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[50], str2[50];
//destination string
strcpy(str1, "This is my initial string");
//source string
strcpy(str2, ", add this");
//concatenating the string str2 to the string str1
strcat(str1, str2);
//displaying destination string
printf("String after concatenation: %s", str1);
return(0);
}
输出：
String after concatenation: This is my initial string, add this
正如您所看到的，我们在字符串str1的末尾添加了字符串str2。我们将参数传递给函数strcpy的顺序很重要，第一个参数指定输出字符串，而第二个参数指定附加在输出字符串末尾的另一个字符串。
正如文章开头所讨论的那样，该函数返回指向目标字符串的指针。这意味着如果我们显示此函数的返回值，那么它应该显示目标字符串（在我们的示例中为字符串str1）。让我们稍微修改我们的代码来验证这一点。
#include <stdio.h>
#include <string.h>
int main () {
char str1[50], str2[50];
//destination string
strcpy(str1, "This is my initial string");
//source string
strcpy(str2, ", add this");
//displaying destination string
printf("String after concatenation: %s", strcat(str1, str2));
return(0);
}
输出：
String after concatenation: This is my initial string, add this
C strncat()函数
在上一个教程中，我们讨论了 strcat()函数，它用于将一个字符串连接到另一个字符串。在本指南中，我们将看到类似的strncat()函数，它与 strcat()相同，只是 strncat()只将指定数量的字符附加到目标字符串。
C strncat()函数声明
char *strncat(char *str1, const char *str2, size_t n)
str1 - 目标字符串。
str2 - 附加在目标字符串str1末尾的源字符串。
n - 需要追加的源字符串str2的字符数。例如，如果这是 5，则只有源字符串str2的前 5 个字符将附加在目标字符串str1的末尾。
返回值：该函数返回指向目标字符串str1的指针。
示例：C 中的strncat()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[50], str2[50];
//destination string
strcpy(str1, "This is my initial string");
//source string
strcpy(str2, ", add this");
//displaying destination string
printf("String after concatenation: %s\n", strncat(str1, str2, 5));
// this should be same as return value of strncat()
printf("Destination String str1: %s", str1);
return 0;
}
输出：
String after concatenation: This is my initial string, add
Destination String str1: This is my initial string, add
正如您所看到的，在字符串str1的末尾只连接了字符串str2的 5 个字符，因为我们在 strncat()函数中将count指定为 5。
另一个需要注意的重点是这个函数返回指向目标字符串的指针，这就是为什么当我们显示 strncat()的返回值时，它与目标字符串str1相同。
C strchr()函数
函数strchr()在给定字符串中搜索指定字符的出现，并返回指向它的指针。
C strchr()函数
char *strchr(const char *str, int ch)
str - 在其中搜索字符的字符串。
ch - 在字符串str中搜索的字符。
strchr()的返回值
它返回指向给定字符串中字符的第一次出现的指针，这意味着如果我们显示指针的字符串值，那么它应该显示从指定字符的第一次出现开始的输入字符串部分。
示例：C 中的strchr()函数
在这个例子中，我们有一个字符串，我们正在使用strchr()函数在字符串中搜索字符'u'。当我们显示函数返回指针的字符串值时，它显示从字符'u'开始的字符串，这是因为函数返回的指针指向字符串中的字符'u'。
#include <stdio.h>
#include <string.h>
int main () {
const char str[] = "This is just a String";
const char ch = 'u';
char *p;
p = strchr(str, ch);
printf("String starting from %c is: %s", ch, p);
return 0;
}
输出：
String starting from u is: ust a String
相关文章：
C strcmp()函数
strcmp()函数比较两个字符串并根据结果返回一个整数值。
C strcmp()函数声明
int strcmp(const char *str1, const char *str2)
str1 - 第一个字符串
str2 - 第二个字符串
strcmp()的返回值
此函数根据比较结果返回以下值：
- 0：如果两个字符串相等
> 0：如果字符串str1的第一个不匹配字符的 ASCII 值大于字符串str2中的字符< 0：如果字符串str1的第一个不匹配字符的 ASCII 值小于字符串str2中的字符
根据许多在线教程，当第一个字符串大于第二个字符串时，此函数返回正值，这绝对是不是真的，或者你可以说没有正确表达，因为当我们说一个字符串大于第二个字符串时我们在谈论长度。但是，此函数不比较长度，它将第一个字符串的每个字符的 ASCII 值与第二个字符串匹配，如果第一个字符串中第一个不匹配字符的 ASCII 值大于第二个字符串的不匹配字符的 ASCII 值，则返回正数。
让我们举一个例子来理解这一点。
示例：C 中的strcmp()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[20];
int result;
//Assigning the value to the string str1
strcpy(str1, "hello");
//Assigning the value to the string str2
strcpy(str2, "hEllo");
result = strcmp(str1, str2);
if(result > 0) {
printf("ASCII value of first unmatched character of str1 is greater than str2");
} else if(result < 0) {
printf("ASCII value of first unmatched character of str1 is less than str2");
} else {
printf("Both the strings str1 and str2 are equal");
}
return 0;
}
输出：
ASCII value of first unmatched character of str1 is greater than str2
在上面的例子中，我们使用函数strcmp()比较两个字符串str1和str2。在这种情况下，strcmp()函数返回一个大于 0 的值，因为第一个不匹配字符'e'的 ASCII 值是 101，它大于'E'的 ASCII 值 69。
相关文章：
C strncmp()函数
在上一个教程中，我们讨论了strcmp()函数，它用于比较两个字符串。在本指南中，我们将讨论 strncmp()函数，它与strcmp()相同，但strncmp()比较仅限于函数调用期间指定的字符数。例如，strncmp(str1, str2, 4)仅比较字符串str1和str2的前四个字符。
C strncmp()函数声明
int strncmp(const char *str1, const char *str2, size_t n)
str1 - 第一个字符串
str2 - 第二个字符串
n - 需要比较的字符数。
strncmp()的返回值
此函数仅比较字符串的前n个（指定数量）字符，并根据比较返回以下值。
0，如果字符串str1和str2都相等> 0，如果str1的第一个不匹配字符的 ASCII 值大于str2< 0，如果str1的第一个不匹配字符的 ASCII 值小于str2
例 1：C 中的strncmp()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[20];
int result;
//Assigning the value to the string str1
strcpy(str1, "hello");
//Assigning the value to the string str2
strcpy(str2, "helLO WORLD");
//This will compare the first 3 characters
result = strncmp(str1, str2, 3);
if(result > 0) {
printf("ASCII value of first unmatched character of str1 is greater than str2");
} else if(result < 0) {
printf("ASCII value of first unmatched character of str1 is less than str2");
} else {
printf("Both the strings str1 and str2 are equal");
}
return 0;
}
输出：
Both the strings str1 and str2 are equal
strncmp()函数的示例 2
让我们稍微改变上面的例子。这里我们比较字符串的前四个字符。
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[20];
int result;
strcpy(str1, "hello");
strcpy(str2, "helLO WORLD");
//This will compare the first 4 characters
result = strncmp(str1, str2, 4);
if(result > 0) {
printf("ASCII value of first unmatched character of str1 is greater than str2");
} else if(result < 0) {
printf("ASCII value of first unmatched character of str1 is less than str2");
} else {
printf("Both the strings str1 and str2 are equal");
}
return 0;
}
输出：
ASCII value of first unmatched character of str1 is greater than str2
C strcoll()函数
strcoll()函数类似于strcmp()函数，它比较两个字符串并根据比较结果返回一个整数。
C strcoll()声明
int strcoll(const char *str1, const char *str2)
str1 - 第一个字符串
str2 - 第二个字符串
strcoll()的返回值
> 0：如果字符串str1中第一个不匹配字符的 ASCII 值大于str2。< 0：如果字符串str1中第一个不匹配字符的 ASCII 值小于str2。= 0：如果两个字符串相等
C strcoll()函数示例
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[20];
int result;
strcpy(str1, "HELLO");
strcpy(str2, "hello world!");
result = strcoll(str1, str2);
if(result > 0) {
printf("ASCII value of first unmatched character of str1 is greater than str2");
} else if(result < 0) {
printf("ASCII value of first unmatched character of str1 is less than str2");
} else {
printf("Both the strings str1 and str2 are equal");
}
return 0;
}
输出：
ASCII value of first unmatched character of str1 is less than str2
在这个例子中，我们比较两个不同的字符串。strcoll()函数区分大小写。 'H'的 ASCII 值小于'h'，这就是此函数返回负值的原因。
如果我们反转strcoll()函数中的参数，让我们说strcoll(str2, str1)，那么函数将返回一个正值。
相关文章：
C strcpy()函数
strcpy()函数将一个字符串复制到另一个字符串。
C strcpy()函数声明
char *strcpy(char *str1, const char *str2)
str1 - 这是复制其他字符串str2的值的目标字符串。函数的第一个参数。
str2 - 这是源字符串，该字符串的值被复制到目标字符串。这是函数的第二个参数。
strcpy()的返回值
此函数返回指向目标字符串的指针，或者您可以说它返回目标字符串str1。
示例：strcpy()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[20];
//copying the string "Apple" to the str1
strcpy(str1, "Apple");
printf("String str1: %s\n", str1);
//copying the string "Banana" to the str2
strcpy(str2, "Banana");
printf("String str2: %s\n", str2);
//copying the value of str2 to the string str1
strcpy(str1, str2);
printf("String str1: %s\n", str1);
return 0;
}
输出：
String str1: Apple
String str2: Banana
String str1: Banana
正如我在帖子的开头所提到的，这个函数返回指向目标字符串的指针，这意味着如果我们显示函数的返回值，它应该在将源字符串复制到目标字符串后显示目标字符串的值。让我们举一个例子来理解这一点。
#include <stdio.h>
#include <string.h>
int main () {
char str[20];
/* copying the string "Apple" to the str and
* displaying the return value of strcpy()
*/
printf("Return value of function: %s\n", strcpy(str, "Apple"));
printf("String str1: %s\n", str);
return 0;
}
输出：
Return value of function: Apple
String str1: Apple
相关文章：
C 关键词 - 保留字
原文： https://beginnersbook.com/2014/01/c-keywords-reserved-words/
在 C 中，我们有 32 个关键字，它们具有预定义的含义，不能用作变量名。这些词也被称为“保留词”。最好避免将这些关键字用作变量名。这些是：
这些关键字的基础用法
if，else，switch，case，default- 用于决策控制编程结构。break- 用于任何循环或者switch-case。int，float，char，double，long- 这些是数据类型，在变量声明期间使用。for，while- C 中的循环结构类型。void- 其中一种返回类型。goto- 用于重定向执行流程。auto，signed，const，extern，register，unsigned- 定义一个变量。return- 该关键字用于返回值。continue- 它通常与for，while和do-while循环一起使用，当编译器遇到此语句时，它执行循环的下一次迭代，跳过当前迭代的其余语句。enum- 常量集。sizeof- 用于了解尺寸。struct，typedef- 结构中使用的这两个关键字（单个记录中的数据类型分组）。union- 它是一组变量，它们共享相同的内存位置和内存存储。volatile
C strncpy()函数
strncpy()函数类似于strcpy()函数，不同之处在于它只从源字符串复制指定数量的字符到目标字符串。
C strncpy()声明
char *strncpy(char *str1, const char *str2, size_t n)
str1 - 目标字符串。复制源字符串str2的前n个字符到其中的字符串。
str2 - 源字符串
`n - 需要复制的源字符串的字符数。
strncpy()的返回值
在将源字符串的n个字符复制到其中之后，它返回指向目标字符串的指针。
示例：strncpy()函数
#include <stdio.h>
#include <string.h>
int main () {
char str1[20];
char str2[25];
/* The first argument in the function is destination string.
* In this case we are doing full copy using the strcpy() function.
* Here string str2 is destination string in which we are copying the
* specified string
*/
strcpy(str2, "welcome to beginnersbook.com");
/* In this case we are doing a limited copy using the strncpy()
* function. We are copying only the 7 characters of string str2 to str1
*/
strncpy(str1, str2, 7);
printf("String str1: %s\n", str1);
printf("String str2: %s\n", str2);
return 0;
}
输出：
String str1: welcome
String str2: welcome to beginnersbook.com
相关文章：
C strrchr()函数
strrchr()函数在给定字符串中搜索指定字符的最后一次出现。此函数与函数strchr()完全相反，后者在字符串中搜索字符的第一次出现。
C strrchr()函数声明
char *strrchr(const char *str, int ch)
str - 搜索字符ch的字符串。
ch - 需要搜索的字符
strrchr()的返回值
它返回指向字符串中字符的最后一次出现的指针。这意味着如果我们显示strrchr()的返回值，那么它应该显示从指定字符的最后一次出现开始的字符串部分。
示例：strrchr()函数
#include <stdio.h>
#include <string.h>
int main () {
const char str[] = "This-is-just-a-test-string";
const char ch = '-';
char *p, *p2;
p = strrchr(str, ch);
printf("String starting from last occurrence of %c is: %s\n", ch, p);
p2 = strrchr(str, 'i');
printf("String starting from last occurrence of 'i' is: %s\n", p2);
return 0;
}
输出：
String starting from last occurrence of - is: -string
String starting from last occurrence of 'i' is: ing
相关文章：
C strspn()函数
函数strspn()在给定字符串中搜索指定的字符串，并返回给定字符串中匹配的字符数。
C strspn()声明
size_t strspn(const char *str1, const char *str2)
str1 - 搜索字符串str2的字符的字符串。
str2 - 另一个字符串，在str1中搜索该字符串的字符。
strspn()的返回值
它返回给定字符串中匹配的字符数。
示例：strspn()函数
#include <stdio.h>
#include <string.h>
int main () {
int len;
const char str1[] = "abcdefgh";
const char str2[] = "abXXcdeZZh";
/* Searching the string str2 in the string str1.
* It returns the count of characters of str2 that
* are matched in the str1
*/
len = strspn(str1, str2);
printf("Number of matched characters: %d\n", len );
return 0;
}
输出：
Number of matched characters: 5
相关文章：
C strstr()函数
strstr()函数在指定主字符串中搜索给定字符串，并返回指向给定字符串第一次出现的指针。
C strstr()函数声明
char *strstr(const char *str, const char *searchString)
str - 要搜索的字符串。
searchString - 我们需要在其中搜索字符串str的字符串
strstr()的返回值
此函数返回指向给定字符串第一次出现的指针，这意味着如果我们打印此函数的返回值，它应显示主字符串的一部分，从给定字符串开始直到主字符串末尾。
示例：C 中的strstr()函数
#include <stdio.h>
#include <string.h>
int main () {
const char str[20] = "Hello, how are you?";
const char searchString[10] = "you";
char *result;
/* This function returns the pointer of the first occurrence
* of the given string (i.e. searchString)
*/
result = strstr(str, searchString);
printf("The substring starting from the given string: %s", result);
return 0;
}
输出：
The substring starting from the given string: you?
正如您所看到的那样，我们正在使用函数strstr()在字符串"Hello, how are you?"中搜索字符串"you"。由于函数将返回字符串"you"的第一次出现的指针，因此字符串str的从"you"开始的子字符串已被打印为输出。
相关文章：
C strcspn()函数
strcspn()函数在主字符串中扫描给定字符串，并返回主字符串中从开头到第一个匹配字符的字符数。
C strcspn()声明
size_t strcspn(const char *str1, const char *str2)
str1 - 要搜索的主字符串
str2 - 在主字符串中搜索此字符串的字符，直到找到第一个匹配的字符
函数strcspn()的返回值
此函数返回在找到第一个匹配字符之前，找到的主字符串中的字符数。
C 中的函数strcspn()例子
#include <stdio.h>
#include <string.h>
int main () {
const char str[20] = "aabbccddeeff";
const char searchString[10] = "dxz";
int loc;
/* This function returns the number of characters present in the main string
* from beginning till the first matched character is found
*/
loc = strcspn(str, searchString);
printf("The first matched char in string str1 is at: %d", (loc+1));
return 0;
}
输出：
The first matched char in string str1 is at: 7
我们在主字符串str中搜索的字符是'd'，'x'和'z'，第一个匹配的字符位于主字符串中的第 7 位。
相关文章：
C strlen()函数
函数 strlen()返回给定字符串的长度（字符数）。
函数 strlen()声明
size_t strlen(const char *str)
str - 这是我们需要计算长度的给定字符串
strlen()的返回值
此函数返回表示给定字符串中字符数的整数值。
C strlen()示例
#include <stdio.h>
#include <string.h>
int main () {
char str[50];
int length;
strcpy(str, "Welcome to Beginnersbook.com");
//returns the number of characters in the string
length = strlen(str);
printf("Length of string - %s is: %d", str, length);
return 0;
}
输出：
Length of string - Welcome to Beginnersbook.com is: 28
相关文章：
C 中的决策控制语句
C 编程中的if语句
当我们只在给定条件为真时才需要执行一个语句块，那么我们使用if语句。在下一个教程中，我们将学习 C if..else，嵌套if..else和else..if 。
C - if语句
if语句的语法：
if正文中的语句仅在给定条件返回true时才执行。如果条件返回false，则跳过if内的语句。
if (condition)
{
//Block of C statements here
//These statements will only execute if the condition is true
}
if语句的流程图
if语句的示例
#include <stdio.h>
int main()
{
int x = 20;
int y = 22;
if (x<y)
{
printf("Variable x is less than y");
}
return 0;
}
输出：
Variable x is less than y
多个if语句的示例
我们可以使用多个if语句来检查多个条件。
#include <stdio.h>
int main()
{
int x, y;
printf("enter the value of x:");
scanf("%d", &x);
printf("enter the value of y:");
scanf("%d", &y);
if (x>y)
{
printf("x is greater than y\n");
}
if (x<y)
{
printf("x is less than y\n");
}
if (x==y)
{
printf("x is equal to y\n");
}
printf("End of Program");
return 0;
}
在上面的示例中，输出取决于用户输入。
输出：
enter the value of x:20
enter the value of y:20
x is equal to y
End of Program
C - if..else，嵌套if..else 和 else..if语句
原文： https://beginnersbook.com/2014/01/c-if-else-statement-example/
在上一个教程中，我们学习了如何在 C 中使用if语句。在本指南中，我们将学习如何使用 C 语句中的if else，嵌套if else和else语句。
C if-else语句
if else语句的语法：
如果条件返回true，则执行if正文内的语句，并跳过else正文内的语句。
如果条件返回false，则跳过if正文中的语句，并执行else中的语句。
if(condition) {
// Statements inside body of if
}
else {
//Statements inside body of else
}
if-else语句的流程图
if-else语句的示例
在此程序中，要求用户输入年龄，并根据输入，if..else语句检查输入的年龄是否大于或等于 18。如果满足此条件，则显示消息“您有资格投票”，但是，如果条件不符合，则显示不同的消息“您没有资格投票”。
#include <stdio.h>
int main()
{
int age;
printf("Enter your age:");
scanf("%d",&age);
if(age >=18)
{
/* This statement will only execute if the
* above condition (age>=18) returns true
*/
printf("You are eligible for voting");
}
else
{
/* This statement will only execute if the
* condition specified in the "if" returns false.
*/
printf("You are not eligible for voting");
}
return 0;
}
输出：
Enter your age:14
You are not eligible for voting
注意：如果只有一个语句出现在if或else正文中，那么你不需要使用大括号（括号）。例如，上面的程序可以像这样重写：
#include <stdio.h>
int main()
{
int age;
printf("Enter your age:");
scanf("%d",&age);
if(age >=18)
printf("You are eligible for voting");
else
printf("You are not eligible for voting");
return 0;
}
C 嵌套if-else语句
当if else语句出现在另一个if或else的正文内时，则称为嵌套if-else。
嵌套if语句的语法：
if(condition) {
//Nested if else inside the body of "if"
if(condition2) {
//Statements inside the body of nested "if"
}
else {
//Statements inside the body of nested "else"
}
}
else {
//Statements inside the body of "else"
}
嵌套if-else的示例
#include <stdio.h>
int main()
{
int var1, var2;
printf("Input the value of var1:");
scanf("%d", &var1);
printf("Input the value of var2:");
scanf("%d",&var2);
if (var1 != var2)
{
printf("var1 is not equal to var2\n");
//Nested if else
if (var1 > var2)
{
printf("var1 is greater than var2\n");
}
else
{
printf("var2 is greater than var1\n");
}
}
else
{
printf("var1 is equal to var2\n");
}
return 0;
}
输出：
Input the value of var1:12
Input the value of var2:21
var1 is not equal to var2
var2 is greater than var1
C - else..if语句
当需要检查程序中的多个条件时，else..if语句很有用，可以使用else..if 语句避免嵌套if-else块。
else..if语法的语法：
if (condition1)
{
//These statements would execute if the condition1 is true
}
else if(condition2)
{
//These statements would execute if the condition2 is true
}
else if (condition3)
{
//These statements would execute if the condition3 is true
}
.
.
else
{
//These statements would execute if all the conditions return false.
}
else..if语句的示例
让我们在讨论嵌套的if..else时采用我们在上面看到的相同示例。我们将使用else..if语句重写相同的程序。
#include <stdio.h>
int main()
{
int var1, var2;
printf("Input the value of var1:");
scanf("%d", &var1);
printf("Input the value of var2:");
scanf("%d",&var2);
if (var1 !=var2)
{
printf("var1 is not equal to var2\n");
}
else if (var1 > var2)
{
printf("var1 is greater than var2\n");
}
else if (var2 > var1)
{
printf("var2 is greater than var1\n");
}
else
{
printf("var1 is equal to var2\n");
}
return 0;
}
输出：
Input the value of var1:12
Input the value of var2:21
var1 is not equal to var2
正如您所看到的那样，只执行
if正文中的语句。这是因为在该语句中，只要满足条件，就会执行该块内的语句，并忽略其余的块。
重要事项：
else和else..if是可选语句，只有if语句的程序运行正常。- 否则，如果没有
if，则无法使用。 if else..if块中可以有任意数量的else..if语句。- 如果没有满足任何条件，则执行
else块中的语句。 - 就像关系运算符一样，我们也可以使用逻辑运算符，如 AND（
&&），OR（||）和 NOT（!）。
C 编程的switch-case语句
原文： https://beginnersbook.com/2014/01/switch-case-statements-in-c/
当我们有多个选项时，使用switch-case语句，我们需要为每个选项执行不同的任务。
C - switch-case语句
语法：
switch (variable or an integer expression)
{
case constant:
//C Statements
;
case constant:
//C Statements
;
default:
//C Statements
;
}
switch-case流程图
C 中的switch-case示例
#include <stdio.h>
int main()
{
int num=2;
switch(num+2)
{
case 1:
printf("Case1: Value is: %d", num);
case 2:
printf("Case1: Value is: %d", num);
case 3:
printf("Case1: Value is: %d", num);
default:
printf("Default: Value is: %d", num);
}
return 0;
}
输出：
Default: value is: 2
说明：在switch中我给出了一个表达式，你也可以给变量。我给了num + 2，其中num值是 2，并且在相加之后表达式得到 4。因为没有用值 4 定义的情况，所以执行默认情况。
怪异故事 - 介绍break语句
在我们讨论更多关于break语句之前，请猜测这个 C 程序的输出。
#include <stdio.h>
int main()
{
int i=2;
switch (i)
{
case 1:
printf("Case1 ");
case 2:
printf("Case2 ");
case 3:
printf("Case3 ");
case 4:
printf("Case4 ");
default:
printf("Default ");
}
return 0;
}
输出：
Case2 Case3 Case4 Default
我传递了一个变量给switch，变量的值是 2，所以控制跳转到case 2，但是在上面的程序中没有这样的语句可以在case 2 执行后打破流程。这就是case 2之后，所有后续case和默认语句都已执行的原因。
如何避免这种情况？
我们可以使用break语句来打破每个case块之后的控制流。
switch-case中的break语句
当您希望程序流从switch中出来时，break语句很有用。每当在switch体中遇到break语句时，控制流都会出现在switch case语句外。
具有break的switch-case示例
和在上面看到的相同，但这次我们正在使用break。
#include <stdio.h>
int main()
{
int i=2;
switch (i)
{
case 1:
printf("Case1 ");
break;
case 2:
printf("Case2 ");
break;
case 3:
printf("Case3 ");
break;
case 4:
printf("Case4 ");
break;
default:
printf("Default ");
}
return 0;
}
输出：
Case 2
为什么default后不使用break语句？
控制流本身会在默认情况下从switch中出来，所以我没有使用它，但是如果你想在默认情况下使用它，你可以使用它，这样做没有坏处。
关于switch-case的几个重点
1）case并不总是需要顺序1,2,3等。它们可以在case关键字后面包含任何整数值。此外，case不需要始终按升序排列，您可以根据程序的需要以任何顺序指定它们。
2）您也可以在switch-case中使用字符。例如：
#include <stdio.h>
int main()
{
char ch='b';
switch (ch)
{
case 'd':
printf("CaseD ");
break;
case 'b':
printf("CaseB");
break;
case 'c':
printf("CaseC");
break;
case 'z':
printf("CaseZ ");
break;
default:
printf("Default ");
}
return 0;
}
输出：
CaseB
3）switch中提供的表达式应该产生一个常量值，否则它将无效。
例如：
switch的有效表达式：
switch(1+2+23)
switch(1*2+3%4)
无效的switch表达式：
switch(ab+cd)
switch(a+b+c)
4）允许嵌套switch语句，这意味着你可以在另一个switch内部使用switch语句。但是应该避免使用嵌套的switch语句，因为它会使程序更复杂，更不易读。
