【全网最详细】初识C语言之数组应用篇——带你走进编程家族的聚集地

目录

​​一维数组​​

​​一维数组的定义和引用​​

​​一维数组初始化​​

​​一维数组应用​​

​​二维数组​​

​​二维数组的定义和引用​​

​​二维数组初始化​​

​​二维数组应用​​

​​字符数组​​

​​字符数组定义和引用​​

​​字符数组初始化​​

​​字符数组的结束标志​​

​​字符数组的输入和输出​​

​​字符数组应用​​

​​多维数组​​

​​数组的排序算法​​

​​选择法排序​​

​​冒泡法排序​​

​​交换法排序​​

​​插入法排序​​

​​折半法排序​​

​​排序算法的比较​​

​​字符串处理函数​​

​​字符串复制​​

​​字符串连接​​

​​字符串比较​​

​​字符串大小写转换​​

​​获得字符串长度​​

​​数组应用​​

​​反转输出字符串​​

​​输出系统日期和时间​​

​​字符串的加密和解密​​

​​每文一语​​

一维数组

一维数组的定义和引用

一维数组的定义

一维数组是用以存储一维数列中数据的集合。

一维数组的一般形式如下：

类型说明符 数组标识符[常量表达式];

类型说明符表示数组中的所有元素类型。

数组标识符就是这个数组型变量的名称，命名规则与变量名一致。

常量表达式定义了数组中存放的数据元素的个数，即数组长度。例如iArray[5]，5表示数组中有5个元素，下标从0开始，到4结束。

例如定义一个数组：：int iArray[5];

代码中的int为数组元素的类型，而iArray表示的是数组变量名，括号中的5表示的是数组中包含的元素个数。

一维数组的引用

数组定义完成后就要使用该数组，可以通过引用数组元素的方式，使用该数组中的元素。

数组元素的表示的一般形式如下：

数组标识符[下标]

例如引用一个数组变量iArray中的第3个变量：

iArray[2];

iArray是数组变量的名称，2为数组的下标。有的读者会问：“为什么使用第3个数组元素，而使用的数组下标是2呢？”。在上面介绍过数组的下标是从0开始的，也就是说下标为0表示的是第一个数组元素。

【实例8.1】 使用数组保存数据。

#include<stdio.h>
int main()
{
    int iArray[5], index, temp; /*定义数组及变量为基本整型*/
    printf("Please enter a Array:\n");
    for (index= 0; index< 5; index++)/*逐个输入数组元素*/
  {
    scanf("%d", &iArray[index]);
  }
    printf("Original Array is:\n");
    for (index = 0; index< 5; index++)/*显示数组中的元素*/
  {
    printf("%d ", iArray[index]);
  }
    printf("\n");
   for (index= 0; index < 2; index++)/*将数组中元素的前后位置互换*/

    {
        temp = iArray[index];   /*元素位置互换的过程借助中间变量temp*/
  iArray[index] = iArray[4-index];
        iArray[4-index] = temp;
    }

    printf("Now Array is:\n");
    for (index = 0; index< 5; index++)/*将转换后的数组再次输出*/
  {
    printf("%d ", iArray[index]);
  }
    printf("\n");
  return 0;
}

一维数组初始化

对一维数组的初始化可以用以下几种方法实现：

在定义数组时可直接对数组元素赋初值

例如：

int i,iArray[6]={1,2,3,4,5,6};

该方法是将数组中的元素值一次放在一对花括号中。经过上面的定义和初始化之后，数组中的元素iArray[0]=1，iArray[1]=2，iArray[2]=3，iArray[3]=4，iArray[4]=5，iArray[5]=6。

【实例8.2】 初始化一维数组。在本实例中，对定义的数组变量进行初始化操作，然后隔位进行输出。

#include<stdio.h>
int main()
{
  int index;    /*定义循环控制变量*/
  intiArray[6]={0,1,2,3,4,5}; /*対数组中的元素赋值*/
  for(index=0;index<6;index+=2) /*输出数组中的元素*/
  {
    printf("%d\n",iArray[index]);
  }
  return 0;
}

可以只给一部分元素赋值，未赋值的部分元素值为0

第二种为数组初始化的方式是对其中一部分元素进行赋值，例如：

int iArray[6]={0,1,2};

数组变量iArray包含6个元素，不过在初始化时只给出了3个值。于是数组中前3个元素的值对应括号中给出的值，在数组中没有得到值的元素被默认赋值为0。

【实例8.3】 赋值数组中的部分元素。在本实例中，定义数组并且为其进行初始化赋值，但只为一部分元素赋值，然后将数组中的所有元素进行输出，观察输出的元素数值。

#include<stdio.h>
int main()
{
  int index;
  int iArray[6]={1,2,3};  /*对数组中部分元素赋初值*/
  for(index=0;index<6;index++)/*输出数组中的所有元素*/
  {
    printf("%d\n",iArray[index]);
  }
  return 0;
}

在对全部数组元素赋初值时可以不指定数组长度

之前在定义数组时，都在数组变量后指定了数组的元素个数。C语言还允许在定义数组时不必指定长度，例如：

int iArray[]={1,2,3,4};

上面的语句，大括号中有4个元素，系统就会根据给定的初始化元素值的个数来定义数组的长度，因此该数组变量的长度为4。

【实例8.4】 不指定数组的元素个数。在本实例中，定义数组变量时不指定数组的元素个数，直接对其进行初始化操作，然后将其中的元素值进行输出显示。

#include<stdio.h>
int main()
{
  int index;
  int iArray[]={1,2,3,4,5}; /*不指定元素个数进行初始化*/
  for(index=0;index<5;index++)
  {
    printf("%d\n",iArray[index]); /*使用for循环隔位输出数组中的元素*/
  }
  return 0;
}

一维数组应用

例如，在一个学校的班级中会有很多学生，此时就可以使用数组来保存这些学生的姓名，以便进行管理。

【实例8.5】 使用数组保存学生姓名。在本实例中，要使用数组保存学生的姓名，那么数组中的每一个元素都应该是可以保存字符串的类型，这里使用字符指针类型。

#include<stdio.h>
int main()
{
  char* ArrayName[5]; /*字符指针数组*/
  int index;  /*循环控制变量*/
  ArrayName[0]="WangJiasheng";/*为数组元素赋值*/
  ArrayName[1]="LiuWen";
  ArrayName[2]="SuYuqun";
        ArrayName[3]="LeiYu";
  ArrayName[4]="ZhangMeng";
  for(index=0;index<5;index++)/*使用循环显示名称*/
  {
    printf("%s\n",ArrayName[index]);
  }
  return 0;
}

二维数组

二维数组的定义和引用

1．二维数组的定义

二维数组的声明和一维数组相同，一般形式如下：

数据类型 数组名[常量表达式1][常量表达式2];

其中，“常量表达式1”被称为行下标，“常量表达式2”被称为列下标。如果有二维数组array[n][m]，则二维数组的下标取值范围如下：

行下标的取值范围0～n-1。

列下标的取值范围0～m-1。

二维数组的最大下标元素是array[n-1][m-1]。

例如定义一个3行4列的整型数组：

int array[3][4];

2．二维数组的引用

二维数组元素的一般形式为：

数组名[下标][下标];

例如对一个二维数组的元素进行引用：

array[1][2];

这行代码表示的是对array数组中第2行的第3个元素进行引用。

这里和一维数组一样要注意下标越界的问题，例如：

int array[2][4];

…  /*对数组元素进行赋值*/

array[2][4]=9;  /*错误！*/

上述代码的表示是错误的：

首先array为2行4列的数组，那么它的行下标的最大值为1，列下标的最大值为3，所以array[2][4]超过了数组的范围，下标越界。

二维数组初始化

二维数组和一维数组一样，也可以在声明时对其进行初始化。在给二维数组赋初值时，有以下4种情况：

可以将所有数据写在一个大括号内，按照数组元素排列顺序对元素赋值。如：

int array[2][2] = {1,2,3,4};

如果大括号内的数据少于数组元素的个数，则系统将默认后面没被赋值的元素值为0。

在为所有元素赋初值时，可以省略行下标，但是不能省略列下标。如：

int array[][3] = {1,2,3,4,5,6};

系统会根据数据的个数进行分配，一共有6个数据，而数组每行分为3列，当然可以确定数组为2行。

也可以分行给数组元素赋值。如：

int a[2][3] = {{1,2,3},{4,5,6}};

在分行赋值时，可以只对部分元素赋值。如：

int a[2][3] = {{1,2},{4,5}};

二维数组也可以直接对数组元素赋值，例如：

int a[2][3];

a[0][0] = 1;

a[0][1] = 2;

这种赋值的方式就是使用数组引用的数组中的元素。

二维数组应用

【实例8.7】 任意输入一个3行3列的二维数组，求对角之和。在本实例中，使用二维数组保存一个3行3列的数组，利用双重循环访问数组中的每一个元素。在循环中判断是否是对角线上的元素，然后进行累加计算。

#include<stdio.h>
int main()
{
  int a[3][3];  /*定义一个3行3列的数组*/
  int i,j,sum=0;  /*定义循环控制变量和保存数据变量sum*/
  printf("please input:\n");
  for(i=0;i<3;i++)  /*利用循环进行对数组元素进行赋值*/
  {
    for(j=0;j<3;j++)
    {
      scanf("%d",&a[i][j]);
    }
  }
        for(i=0;i<3;i++)  /*使用循环计算对角线的总和*/
  {
    for(j=0;j<3;j++)
    {
      if(i==j)
      {
        sum=sum+a[i][j];/*进行数据的累加计算*/
      }
    }
  }
  printf("the result is :%d\n",sum);  /*输出最后的结果*/
  return 0;
}

字符数组

字符数组定义和引用

1．字符数组的定义

字符数组的定义与其他数据类型的数组定义类似，一般形式如下：

char 数组标识符[常量表达式]

因为要定义的是字符型数据，所以在数组标识符前所用的类型是char。后面括号中表示的是数组元素的数量。

例如定义字符数组cArray

char cArray[5];

其中的cArray表示数组的表示符，而括号中的5表示数组中包含5个字符型的变量元素。

2．字符数组的引用

字符数组的引用和其他类型数据引用一样，也是使用下标的形式。例如引用上面定义的数组cArray中的元素：

cArray[0]='H';

cArray[1]='e';

cArray[2]='l';

cArray[3]='l';

cArray[4]='o';

上面的代码依次引用数组中元素，为其进行赋值。

字符数组初始化

在对字符数组进行初始化操作时有以下几种方法：

逐个字符赋给数组中各元素

这是最容易理解的初始化字符数组的方式，例如初始化一个字符数组：

char cArray[5]={'H','e','l','l','o'};

定义包含5个元素的字符数组，在初始化的大括号中，每一个字符对应赋值一个数组元素。

【实例8.8】 使用字符数组输出一个字符串。在本实例中，定义一个字符数组，通过初始化操作保存一个字符串，然后通过循环引用每一个数组元素进行输出操作。

#include<stdio.h>
int main()
{
  char cArray[5]={'H','e','l','l','o'}; /*初始化字符数组*/

  int i;      /*循环控制变量*/

  for(i=0;i<5;i++)    /*进行循环*/

  {

    printf("%c",cArray[i]); /*输出字符数组元素*/

  }

  printf("\n");   /*输出换行*/
  return 0;
}

如果在定义字符数组时进行初始化，可以省略数组长度

如果初值个数与预定的数组长度相同，在定义时可以省略数组长度，系统会自动根据初值个数确定数组长度。例如上面初始化字符数组的代码可以写成：

char cArray[]={'H','e','l','l','o'};

可见，代码中定义的cArray[]中没有给出数组的大小，但是根据初值的个数可以确定数组的长度为5。

利用字符串给字符数组赋初值

通常用一个字符数组来存放一个字符串。例如用字符串的方式对数组作初始化赋值如下：

char cArray[]={"Hello"};

或者将{}去掉，写成：

char cArray[]="Hello";

【实例8.9】 使用二维字符数组输出一个钻石形状。在实例中定义一个二维数组，并且利用数组的初始化赋值设置钻石形状。

#include<stdio.h>
int main()
{
  int iRow,iColumn;   /*用来控制循环的变量*/

  char cDiamond[][5]={{' ',' ','*'},  /*初始化二维字符数组*/

          {' ','*',' ','*'},

          {'*',' ',' ',' ','*'},

          {' ','*',' ','*'},

          {' ',' ','*'} };

  for(iRow=0;iRow<5;iRow++) /*利用循环输出数组*/
  {
    for(iColumn=0;iColumn<5;iColumn++)
    {
      printf("%c",cDiamond[iRow][iColumn]); /*输出数组元素*/
    }
    printf("\n");   /*进行换行*/
  }
  return 0;
}

字符数组的结束标志

在C语言中，使用字符数组保存字符串，也就是使用一个一维数组保存字符串中的每一个字符。此时系统会自动为其添加“\0”作为结束符。

例如在初始化一个字符数组时：

char cArray[]="Hello";

字符串总是以“\0”作为串的结束符，因此当把一个字符串存入一个数组时，也就是把结束符“\0”存入数组，并以此作为该字符串是否结束的标志。

用字符串方式赋值比用字符逐个赋值要多占一个字节，多占的这个字节用于存放字符串结束标志“\0”。上面的字符数组cArra在内存中的实际存放情况如图所示。

“\0”是由C编译系统自动加上的。因此上面的赋值语句等价于：

char cArray[]={'H','e','l','l','o','\0'};

字符数组并不要求最后一个字符为“\0”，甚至可以不包含“\0”。例如下面这样写也是合法的：

char cArray[5]={'H','e','l','l','o'};

不过是否加“\0”，完全根据需要决定。但是由于系统对字符串常量自动加一个“\0”，因此，为了使处理方法一致，且便于测定字符串的实际长度以及在程序中作相应的处理，在字符数组中也常常人为地加上一个“\0”。例如：

char cArray[6]={'H','e','l','l','o','\0'};

字符数组的输入和输出

字符数组的输入和输出有两种方法：

使用格式符

“

%c

”

进行输入和输出

使用格式符“%c”实现字符数组中字符的逐个输入与输出。例如循环输出字符数组中的元素：

for(i=0;i<5;i++)  /*进行循环*/

{

  printf("%c",cArray[i]);  /*输出字符数组元素*/

}

其中变量为循环的控制变量，并且在循环中作为数组的下标，进行循环输出。

使用格式符

“

%s

”

进行输入或输出

使用格式符“%s”，将整个字符串依次输入或输出。例如输出一个字符串：

char cArray[]="GoodDay!";  /*初始化字符数组*/

printf("%s",cArray);  /*输出字符串*/

其中使用格式符%s将字符串进行输出。此时需注意以下几种情况：

输出字符不包括结束符 “ \0 ” 。 用 “ %s ” 格式输出字符串时，printf函数中的输出项是字符数组名cArray，而不是数组中的元素名cArray[0]等。 如果数组长度大于字符串实际长度，则也只输出到 “ \0 ” 为止。 如果一个字符数组中包含多个 “ \0 ” 结束字符，则在遇到第一个 “ \0 ” 时输出就结束。   【实例8.10】 使用两种方式输出字符串。在本实例中为定义的字符数组进行初始化操作，再输出字符数组中保存的数据时，可以逐个将数组中的元素进行输出，或者直接将字符串进行输出。

#include<stdio.h>
int main()
{
  int iIndex; /*循环控制变量*/
  char cArray[12]="MingRi KeJi";/*定义字符数组用于保存字符串*/
  for(iIndex=0;iIndex<12;iIndex++)
  {
    printf("%c",cArray[iIndex]); /*逐个输出字符数组中的字符*/
  }
  printf("\n%s\n",cArray); /*直接将字符串输出*/
  return 0;
}

字符数组应用

【实例8.11】 计算字符串中有多少个单词。在本实例中输入一行字符，然后统计其中有多少个单词，要求每个单词之间用空格分隔开，且最后的字符不能为空格。

#include<stdio.h>
int main()
{
  char cString[100];  /*定义保存字符串的数组*/
  int iIndex, iWord=1;/*iWord表示单词的个数*/
  char cBlank;  /*表示空格*/
  gets(cString);  /*输入字符串*/
  if(cString[0]=='\0')  /*判断字符串为空的情况*/
  {
    printf("There is no char!\n");
  }
        else if(cString[0]==' ')/*判断第一个字符为空格的情况*/
  {
    printf("First char just is a blank!\n");
  }
        else
  {
    for(iIndex=0;cString[iIndex]!='\0';iIndex++)/*循环判断每一个字符*/
    {
      cBlank=cString[iIndex]; /*得到数组中的字符元素*/
      if(cBlank==' ')/*判断是不是空格*/
      {
        iWord++;  /*如果是则加1*/
      }
    }
    printf("%d\n",iWord);
  }
  return 0;
}

多维数组

多维数组的声明和二维数组相同，只是下标更多，一般形式如下：

数据类型 数组名[常量表达式1][常量表达式2]…[常量表达式n];

例如声明多维数组：

int iArray1[3][4][5];

int iArray2[4][5][7][8];

在上面的代码中分别定义了一个三维数组iArray1和一个四维数组iArray2。由于数组元素的位置都可以通过偏移量计算，因此对于三维数组a[m][n][p]来说，元素a[i][j][k]所在的地址是从a[0][0][0]算起到（i*n*p+j*p+k）个单位的位置。

数组的排序算法

选择法排序

选择法排序指每次选择所要排序的数组中的最大值（由大到小排序，由小到大排序则选择最小值）的数组元素，将这个数组元素的值与最前面没有进行排序的数组元素的值互换。

下面以数字9、6、15、4、2为例，对这几个数字进行排序，每次交换的顺序如表所示。

冒泡法排序

冒泡法排序指的是在排序时，每次比较数组中相邻的两个数组元素的值，将较小的数（从小到大排列）排在较大的数前面。

下面仍以数字9、6、15、4、2为例，对这几个数字进行排序，每次排序的顺序如表所示。

交换法排序

交换法排序是将每一位数与其后的所有数一一比较，如果发现符合条件的数据则交换数据。首先，用第一个数依次与其后的所有数进行比较，如果存在比其值大（小）的数，则交换这两个数，继续向后比较其他数直至最后一个数。然后在使用第二个数与其后面的数进行比较，如果存在比其值大（小）的数，则交换这两个数。继续向后比较其他数直至最后一个数，直至最后一个数比较完成。

下面以数字9、6、15、4、2为例，对这几个数字进行交换法排序，每次排序的顺序如表所示。

插入法排序

插入法排序较为复杂，其基本工作原理是抽出一个数据，在前面的数据中寻找相应的位置插入，然后继续下一个数据，直到完成排序。

下面以数字9、6、15、4、2为例，对这几个数字进行插入法排序，每次排序的顺序如表所示。

折半法排序

折半法排序又称为快速排序，是选择一个中间值middle（在程序中，我们使用数组中间值），然后把比中间值小的数据放在左边，比中间值大的数据放在右边（具体的实现是从两边找，找到一对后进行交换）。然后对两边分别递归使用这个过程。

下面以数字9、6、15、4、2为例，对这几个数字进行折半法排序，每次排序的顺序如表所示。

排序算法的比较

在前面已经介绍了5种排序方法，那么在进行数组排序时应该使用哪一种方法呢？这就应该根据需要进行选择。下面对这5种排序方法进行一下简单的比较。

（1）选择法排序

选择法排序在排序过程中共需进行n(n-1)/2次比较，互相交换n-1次。选择法排序简单、容易实现，适用于数量较小的排序。

（2）冒泡法排序

最好的情况是正序，因此只要比较一次即可；最坏的情况是逆序，需要比较n^2次。冒泡法是稳定的排序方法，当待排序列有序时，效果比较好。

（3）交换法排序

交换法排序和冒泡法排序类似，正序时最快，逆序时最慢，排列有序数据时效果最好。

（4）插入法排序

此算法需要经过n-1次插入过程，如果数据恰好应该插入到序列的最后端，则不需要移动数据，可节省时间，因此若原始数据基本有序，此算法具有较快的运算速度。

（5）折半法排序

折半法排序对于较大的n时，是速度最快的排序算法；但当n很小时，此方法往往比其他排序算法还要慢。折半法排序是不稳定的，对应有相同关键字的记录，排序后的结果可能会颠倒次序。

插入法、冒泡法、交换法排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度；在这种情况下，折半法排序反而会显得速度慢了。当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。

字符串处理函数

字符串复制

在字符串操作中，字符串复制是比较常用的操作之一，在字符串处理函数中包含strcpy函数，该函数可用于复制特定长度的字符串到另一个字符串中。其语法格式如下：

strcpy(目的字符数组名，源字符数组名)

功能：把源字符数组中的字符串复制到目的字符数组中。字符串结束标志“\0”也一同复制。

【实例8.17】 字符串复制。

#include<stdio.h>
#include<string.h>
int main()
{
  char str1[30],str2[30];
  printf("输入目的字符串:\n");
  gets(str1);   /*输入目的字符*/
  printf("输入源字符串:\n");
  gets(str2);   /*输入源字符串*/
  printf("输出目的字符串:\n");
  puts(str1);   /*输出目的字符*/
  printf("输出源字符串:\n");
  puts(str2);   /*输出源字符串*/
  strcpy(str1,str2);  /*调用strcpy函数实现字符串复制*/
  printf("调用strcpy函数进行字符串复制:\n");
  printf("复制字符串之后的目的字符串:\n");
  puts(str1);   /*输出复制后的目的字符串*/
  return 0; /*程序结束*/
}

字符串连接

字符串连接就是将一个字符串连接到另一个字符串的末尾，使其组合成一个新的字符串。在字符串处理函数中，strcat函数就具有字符串连接的功能。其语法格式如下：

strcat(目的字符数组名，源字符数组名)

功能：把源字符数组中的字符串连接到目的字符数组中字符串的后面，并删去目的字符数组中原有的串结束标志“\0”。

【实例8.18】 字符串连接。

#include<stdio.h>
#include<string.h>
int main()
{
  char str1[30],str2[30];
  printf("输入目的字符串:\n");
  gets(str1);   /*输入目的字符*/
  printf("输入源字符串:\n");
  gets(str2);   /*输入源字符串*/
  printf("输出目的字符串:\n");
  puts(str1);   /*输出目的字符*/
  printf("输出源字符串:\n");
  puts(str2);   /*输出源字符串*/
  strcat(str1,str2);  /*调用strcat函数进行字符串连接*/
  printf("调用strcat函数进行字符串连接:\n");
  printf("字符串连接之后的目的字符串:\n");
  puts(str1);   /*输出连接后的目的字符串*/
  return 0; /*程序结束*/
}

字符串比较

字符串比较就是将一个字符串与另一个字符串从首字母开始，按照ASCII码的顺序进行逐个比较。在字符串处理函数中，strcmp函数就具有在字符串间进行比较的功能。其语法格式如下：

strcmp(字符数组名1，字符数组名2)

功能：按照ASCII码顺序比较两个数组中的字符串，并由函数返回值返回比较结果。

返回值如下：

字符串1=字符串2，返回值为0。

字符串1>字符串2，返回值为正数。

字符串1<字符串2，返回值为负数。

字符串大小写转换

字符串的大小写转换需要使用strupr函数和strlwr函数。strupr函数的语法格式如下：

strupr（字符串）

功能：将字符串中的小写字母变成大写字母，其他字母不变。

strlwr函数的语法格式如下：

strlwr（字符串）

功能：将字符串中的大写字母变成小写字母，其他字母不变。

获得字符串长度

在使用字符串的时候，有时需要动态获得字符串的长度，通过循环来判断字符串结束标志“\0”虽然也能获得字符串的长度，但是实现起来相对繁琐。这时，可以使用strlen函数来计算字符串的长度。strlen函数的语法格式如下：

strlen(字符数组名)

功能：计算字符串的实际长度（不含字符串结束标志“\0”），函数返回值为字符串的实际长度。

数组应用

反转输出字符串

字符串操作在应用程序中经常会使用，如连接两个字符串、查找字符串等。本节需要实现的功能是反转字符串。以字符串“mrsoft”为例，其反转的结果为“tfosrm”。

在程序中定义两个字符数组，一个表示源字符串，另一个表示反转后的字符串。在源字符串中我们从第一个字符开始遍历，读取字符数据，在目标字符串中从最后一个字符（结束标记\0 除外）倒序遍历字符串，依次将源字符串中的第一个字符数据写入目标字符串的最后一个字符中，将源字符串中的第2个字符数据写入目标字符串的倒数第2个字符中，依此类推。这样就实现了字符串的反转。图8.23描述了算法的实现过程。

【实例8.22】 反转输出字符串。

#include <stdio.h>
int main()
{
  int i;
  char String[7]  = {"mrsoft"};
  char Reverse[7] = {0};
  int size;
  size = sizeof(String);  /*计算源字符串长度*/
  /*循环读取字符*/
  for(i=0;i<6;i++)
  {
    Reverse[size-i-2] = String[i];/*向目标字符串中插入字符*/
  }
  /*输出源字符串*/
  printf("输出源字符串：%s\n",String);
  /*输出目标字符串*/
  printf("输出目标字符串：%s\n",Reverse);
  return 0;   /*程序结束*/
}

输出系统日期和时间

在控制台应用程序中，通常需要按照系统的提示信息进行操作。例如，用户进行某一个操作，需要输入一个命令，如果命令输入错误，系统会进行提示。本节要求设计一个应用程序，当用户输入命令字符“0”时显示帮助信息，输入命令字符“1”时显示系统日期，输入命令字符“2”时显示系统时间，输入命令字符“3”时退出系统。

在设计本实例时需要解决两个问题：第一个问题是需要不断地保持程序运行，等待用户输入命令，防止main函数结束；第二个问题是获取系统日期和时间。

对于第一个问题可以使用一个无限循环语句来实现，在循环语句中等待用户输入，如果用户输入了命令字符3，则终止循环，结束应用程序。

对于第2个问题可以使用时间函数time和localtime来获取系统日期和时间。

字符串的加密和解密

在设计应用程序时，为了防止一些敏感信息的泄漏，通常需要对这些信息进行加密。以用户的登录密码为例，如果密码以明文的形式存储在数据表中，就很容易被人发现；相反，如果密码以密文的形式储存，即使别人从数据表中发现了密码，这也是加密之后的密码，根本不能够使用。通过对密码进行加密，能够极大提高系统的保密性。

为了减小本节实例的规模，这里要求设计一个加密和解密的算法，在对一个指定的字符串加密之后，利用解密函数能够对密文解密，显示明文信息。加密的方式是将字符串中每个字符加上它在字符串中的位置和一个偏移值5。以字符串"mrsoft"为例，第一个字符m在字符串中的位置为0，那么它对应的密文是'm' + 0 + 5，即r。

数组类型是构造类型的一种，数组中的每一个元素都属于同一种类型。本文首先介绍了有关一维数组、二维数组、字符数组及多维数组的定义和引用，使读者可以对数组有个充分的认识，然后通过实例介绍了C语言标准函数库中常用的字符串处理函数的使用，最后通过几个综合性的数组应用实例加深对数组的理解。

每文一语

欲速则不达