1. 一维数组、二维数组的定义、初始化和引用方法

数组数据的特点：

1. 具有相同的数据类型
2. 使用过程中需要保留原始数据

数组：

是一种具有相同数据类型的数据的有序集合

一般形式：类型说明符 数组名[常量表达式]；

例如：int a[10]; 元素为a[0]----a[9]、2、常量表达式中不允许包含变量，可以包含常量或符号常量。

说明：

1. 数组名定义规则和变量名相同，遵循标识符定名规则
2. 在定义数组时，需要指定数组中的元素个数，方括号中的常量表达式用来表示元素的个数，即数组长度。从下标0开始
3. 常量表达式中可以包括常量和符号常量，但不能包括变量。也就是说C语言不允许对数组的大小作动态定义，即数组的大小不依赖与程序运行过程中变量的值。
4. 数组元素下标可以是任何整型常量、整型变量或任何整型表达式。
5. 使用数值型数组时，不可以一次引用整个数组，只能逐个引用元素
6. 需要整体赋值时只可以在定义的同时整体赋值。

如 int a[10]={0,1,2,3,4,5,6,7,8,9};正确。i nt a[10];a[10]={0,1,2,3,4,5,6,7,8,9};错误。

7. 可以只给一部分元素赋值。

例如：int a[10]={5,8,7,6};后面没有赋值的元素值默认为0

8. 对全部数组元素赋值时可以不指定数组长度，
   例如：

int a[10]={0,1,2,3,4,5,6,7,8,9};可以写成 int a[]={0,1,2,3,4,5,6,7,8,9};
但是，既不赋初值，也不指定长度是错误的。例如：int a[];错误。

一维数组的引用

1. 引用方式：

数组名[下标]
下标可以是整型常量或整型表达式。
例如：a[0]=a[5]+a[7]-a[2*3]

例子：

#include <stdio.h>

int main()
{
    int i, a[10];
    for (i = 0; i <= 9; i++)
        a[i] = i;
    for (i = 9; i >= 0; i--)
        printf("%d", a[i]);
    printf("\n");
}

2. 对数组元素初始化的实现方法
在定义数组时对数组元素赋以初值。
例如：int a[10]={0,1,2,3,4,5,6,7,8,9};

二维数组

一般形式：类型说明符 数组名[常量表达式1][常量表达式2]；例如：
int a[3][4];可以看成是包含3个一维数组，每个一维数组里包含4个元素。一共3*4=12个元素。

二维数组引用

表现形式：

数组名 [下标] [下标]

例如 a[2][3]

引用

数据类型

数组名 [常量表达式1][常量表达式2]={初始化数据}

二维数组的定义

二维数组中的元素在内存中的排序顺序是：按行存放，即先顺序存放第一行的元素，在存放第二行的元素

四种方法对二维数组初始化

1. 分行给二维数组赋初值：

int a [3] [4] ={{1,2，3,4}，{5,6，7,8}，{9,10,11,12}}；

2. 可以将所有数据写在一个花括弧内，按数组排列的顺序对各元素赋初值

int a [3][4] ={1,2,3,4,5,6,7,8,9,10,11,12}

3. 可以对部分元素赋初值

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

5. 如果对全部元素都赋初值，则定义数组时对第一维的长度可以不指定，但第二维的长度不能省。

2．一维数组的应用（如排序），二维数组的应用（如矩阵运算）

用冒泡法对两个数比较，将最小的掉在前头

#include <stdio.h>

int main()
{
    int a[10];
    int i, j, t;
    printf("input 10 numbera:\n ");
    for (i = 0; i < 10; i++)
        scanf("%d", &a[i]);
    printf("\n ");
    for (j = 0; j < 9; j++)
        for (i = 0; i < 9 - j; i++)
        {
            if (a[i] > a[i + 1])
            {
                t = a[i];
                a[i] = a[i + 1];
                a[i + 1] = t;
            }
        }
    printf("the sorted numbers:");
    printf("\n ");
    for (i = 0; i < 10; i++)
    {
        printf("%d  ", a[i]);
    }
}

有一个3*4的矩阵，要求编程序求出其中值最大的那个元素的值，以及其所在的行号和列号

#include <stdio.h>

int main()
{
    int i, j, row = 0, colum = 0, max;
    int a[3][4] = {{1, 2, 3, 4}, {9, 8, 7, 6}, {-10, -10, -5, 2}};
    max = a[0][0];
    for (i = 0; i <= 2; i++)
        for (j = 0; j <= 3; j++)
            if (a[i][j] > max)
            {
                max = a[i][j];
                row = i;
                colum = j;
            }
    printf("max=%d,row=%d,colum=%d\n", max, row, colum);
}

3．数组作函数参数

数组作函数参数

4．字符数组的定义、初始化和输入输出方法

字符数组的定义

用来存放字符数据的数组称为字符数组。字符数组中的一个元素存放一个字符。定义字符数组的方法与定义数值型数组的方法类似。

其定义的一般形式是：char 数组名[数据长度]
例如：
char c[10];
c[0]=‘I’; c[1]=’ ‘; c[2]=‘l’; c[3]=‘o’; c[4]=‘v’; c[5]=‘e’; c[6]=’ '; c[7]=‘y’; c[8]=‘o’; c[9]=‘u’;

以上定义了c为字符数组，包含10个元素。
由于字符型数据是以整数形式(ASCII代码)存放的，因此也可以用整型数组来存放字符数据，例如：
int c[10];
但这时每个数组元素占2个字节的内存单元，浪费存储空间。 [1]
字符数组也可以是二维或多维数组，例如：
char c[5][10];
即为二维字符数组。

字符数组的初始化

字符数组的初始化与数值型数组初始化没有本质区别。但它除了可以逐个给数组元素赋予字符外，也可以直接用字符串对其初始化。

1. （1）用字符常量逐个初始化数组。例如：
   char a[8]={‘i’，‘l’，‘o’，‘v’，‘e’，‘y’，‘o’，‘u’}；
   把8个字符依次分别赋给c[0]~c[7]这8个元素。

如果在定义字符数组时不进行初始化，则数组中各元素的值是不可预料的。如果花括号中提供的初值个数（即字符个数）大于数组长度，则出现语法错误。如果初值个数小于数组长度，则只将这些字符赋给数组中前面那些元素，其余的元素自动定为空字符（即’\0’）。如果提供的初值个数与预定的数组长度相同，在定义时可以省略数组长度，系统会自动根据初值个数确定数组长度

。例如：

char c[ ]={‘c’，‘ ’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'}；

这时c数组的长度自动定为9。
也可以定义和初始化一个二维字符数组，例如：
char diamond[5][5]={{’ ‘，’ ‘，’#’}，{’ ‘，’#’，’ ‘，’#’}，
{’#’，’ ‘，’ ‘，’ ‘，’#’}，{’ ‘，’#’，’ ‘，’#’}，{’ ‘，’ ‘，’#’}};用它代表一个菱形的平面图形。
2. （2）字符串常量初始化数组。例如：

char c[ ]={‘c’，‘ ’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'}；

可写为：

char c[ ]={"C program"};

或去掉{}写为：

char c[ ]="C program";

注意：此时数组c的长度不是9，而是10。因为字符串常量的最后由系统加上一个’\0’。上面的初始化与下面的初始化等价。

char c[ ]={‘c’，‘ ’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'，'\0'}； [1] 

元素的引用

可以通过引用字符数组中的一个元素，得到一个字符。
数组的引用形式为：
数组名[下标]

【例5-8】输入“I like playing basketball”并显示出来。

#include<stdio.h>
int main(void)
{
char a[26]="I like playing basketball";
int i;
for(i=0;i<26;i++)
printf("%c",a[i]);
}

运行结果为：I like playing basketball [2]

结束标志

字符串和字符串结束标志

在C语言中，是将字符串作为字符数组来处理的。为了测定字符串的实际长度，C语言规定了一个“字符串结束标志”，以字符’\0’作为结束标志 [1] 。

输入输出

1. 字符数组的输入：

（1）用getchar()或scanf()的’%c’格式符对数组进行字符赋值。例如，对于数组a[10]:用getchar()赋值：for(i=0;i<10;i++)a[i]=getchar();用scanf()赋值：for(i=0;i<10;i++)scanf("%c",&a[i]);

（2）用scanf()的’%s’格式对数组赋值。还是对于数组a[10]:scanf("%s",a);或scanf("%s“,&a[0]);输入”C
program“并回车时，a数组会自动包含一个以”\0“结尾的字符串”C program“。

2. 字符数组的输出

（1）用putchar()或printf()的‘%c’格式符对数组进行字符赋值。例如，对于数组a[10]：用putchar()赋值：for(i=0;i<10;i++)a[i]=putchar();用printf()赋值：for(i=0;i<10;i++)printf("%c",a[i]);输出结果为：c program

（2）用printf()的’%s’格式对数组赋值。还是对于数组a[10];printf("%s",a);输出结果为：c program

应用举例

#include <stdio.h>
int main()
{
    char string[81];
    int i, num = 0, word = 0;
    char c;
    gets(string);
    for (i = 0; (c = string[i]) != '\0'; i++)
        if (c == ' ')
            word = 0;
        else if (word == 0)
        {
            word = 1;
            num++;
        }
    printf("There are %d words in this line.\n", num);
}

5．字符串处理函数的使用

puts函数

C 库函数 int puts(const char *str) 把一个字符串写入到标准输出stdout，直到空字符，但不包括空字符。换行符会被追加到输出中。

int puts(const char *str)

实例:

#include <stdio.h>
#include <string.h>

int main()
{
   char str1[15];
   char str2[15];

   strcpy(str1, "RUNOOB1");
   strcpy(str2, "RUNOOB2");

   puts(str1);
   puts(str2);
   
   return(0);
}

gets函数

C 库函数 char *gets(char *str) 从标准输入 stdin 读取一行，并把它存储在 str所指向的字符串中。当读取到换行符时，或者到达文件末尾时，它会停止，具体视情况而定。

char *gets(char *str)

str – 这是指向一个字符数组的指针，该数组存储了 C 字符串

实例:

#include <stdio.h>

int main()
{
   char str[50];

   printf("请输入一个字符串：");
   gets(str);

   printf("您输入的字符串是：%s", str);

   return(0);
}

strcat函数

C 库函数 char *strcat(char *dest, const char *src) 把 src 所指向的字符串追加到 dest所指向的字符串的结尾。

char *strcat(char *dest, const char *src)

dest – 指向目标数组，该数组包含了一个 C 字符串，且足够容纳追加后的字符串。
src – 指向要追加的字符串，该字符串不会覆盖目标字符串。

#include <stdio.h>
#include <string.h>
 
int main ()
{
   char src[50], dest[50];
 
   strcpy(src,  "This is source");
   strcpy(dest, "This is destination");
 
   strcat(dest, src);
 
   printf("最终的目标字符串： |%s|", dest);
   
   return(0);
}

strcpy函数

char *strcpy(char *dest, const char *src)

dest – 指向用于存储复制内容的目标数组。
src – 要复制的字符串。

char *strcpy(char *dest, const char *src) 把 src 所指向的字符串复制到 dest。

需要注意的是如果目标数组 dest 不够大，而源字符串的长度又太长，可能会造成缓冲溢出的情况

#include <stdio.h>
#include <string.h>
 
int main()
{
   char src[40];
   char dest[100];
  
   memset(dest, '\0', sizeof(dest));
   strcpy(src, "This is runoob.com");
   strcpy(dest, src);
 
   printf("最终的目标字符串： %s\n", dest);
   
   return(0);
}

strcmp函数

strcmp compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。基本形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

#include <stdio.h>
#include <string.h>
 
int main ()
{
   char str1[15];
   char str2[15];
   int ret;
 
 
   strcpy(str1, "abcdef");
   strcpy(str2, "ABCDEF");
 
   ret = strcmp(str1, str2);
 
   if(ret < 0)
   {
      printf("str1 小于 str2");
   }
   else if(ret > 0) 
   {
      printf("str1 大于 str2");
   }
   else 
   {
      printf("str1 等于 str2");
   }
   
   return(0);
}

特别注意：strcmp(const char *s1,const char * s2) 这里面只能比较字符串，即可用于比较两个字符串常量，或比较数组和字符串常量，不能比较数字等其他形式的参数。

ANSI 标准规定，返回值为正数，负数，0 。而确切数值是依赖不同的C实现的。

当两个字符串不相等时，C 标准没有规定返回值会是 1 或 -1，只规定了正数和负数。

有些会把两个字符的 ASCII 码之差作为比较结果由函数值返回。但无论如何不能以此条依据作为程序中的流程逻辑

strlen函数

计算字符串 str 的长度，直到空结束字符，但不包括空结束字符

#include <stdio.h>
#include <string.h>

int main()
{
    char str[50];
    int len;

    strcpy(str, "This is runoob.com");

    len = strlen(str);
    printf("|%s| 的长度是 |%d|\n", str, len);

    return (0);
}

strlwr函数

strlwr(string)函数返回给定字符串的小写形式。

#include<stdio.h>  

int main() {
    char str[20];

    printf("Enter string: ");
    gets(str);//reads string from console  
    printf("String is: %s", str);
    printf("
Lower String is: %s", strlwr(str));

}

strupr函数

strupr(string)函数返回给定字符串的大写形式

#include<stdio.h>  

int  main() {
    char str[20];

    printf("Enter string: ");
    gets(str);//reads string from console  
    printf("String is: %s",str);  
    printf("\nUpper String is: %s \n",strupr(str));  
}