精华内容
下载资源
问答
  • C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 ...

    第七章、数组

    数组是构造数据类型之一

    • 数组: 有序数据的集合,用数组名标识
    • 元素: 属同一数据类型,用数组名和下标确定

    一维数组

    一维数组的定义

    定义方式:
    在这里插入图片描述
    例: int a[6]
    在这里插入图片描述

    一维数组的引用

    1、数组必须先定义,后使用。
    2、只能逐个引用数组元素,不能一次引用整个数组。
    3、数组元素表示形式: 数组名[下标] ,下标可以是常量或整型表达式

    一维数组的初始化

    初始化方式:
    在这里插入图片描述

    说明:
    1、数组不初始化,其元素值为随机数。
    2、对static数组元素不赋初值,系统会自动赋以0值。
    在这里插入图片描述
    3、只给部分数组元素赋初值。
    在这里插入图片描述
    4、当全部数组元素赋初值时,可不指定数组长度。
    在这里插入图片描述

    程序举例

    例1: 读10个整数存入数组,找出其中最大值和最小值
    在这里插入图片描述

    /*示例1*/
    #include <stdio.h>
    #define SIZE 10
    main()
    {   int x[SIZE],i,max,min;
        printf("Enter 10 integers:\n");
        for(i=0;i<SIZE;i++)
        {   printf("%d:",i+1);
    	scanf("%d",&x[i]);
        }
        max=min=x[0];
        for(i=1;i<SIZE;i++)
        {  if(max<x[i])  max=x[i];
           if(min>x[i])  min=x[i];
        }
        printf("Maximum value is %d\n",max);
        printf("Minimum value is %d\n",min);
    }
    

    例2: 用数组求Fibonacci数列前20个数
    在这里插入图片描述

    /*示例2*/
    #include <stdio.h>
    main()
    {   int i;
         int f[20]={1,1};
        for(i=2;i<20;i++)
           f[i]=f[i-2]+f[i-1];
        for(i=0;i<20;i++)
        {   if(i%5==0)  printf("\n");
             printf("%12d",f[i]);
        }
    }
    

    例3: 用冒泡法对10个数排序
    在这里插入图片描述
    在这里插入图片描述

    /*示例3*/
    #include <stdio.h>
    main()
    {   int a[11],i,j,t;
        printf("Input 10 numbers:\n");
        for(i=1;i<11;i++)
           scanf("%d",&a[i]);
        printf("\n");
        for(j=1;j<=9;j++)
           for(i=1;i<=10-j;i++)
              if(a[i]>a[i+1])
             {t=a[i]; a[i]=a[i+1]; a[i+1]=t;}
        printf("The sorted numbers:\n");
        for(i=1;i<11;i++)
    	printf("%d ",a[i]);
    }
    

    例4: 用简单选择法对10个数排序

    在这里插入图片描述

    在这里插入图片描述

     /*示例4*/
    #include <stdio.h>  
    main()
    {   int a[11],i,j,k,x;
        printf("Input 10 numbers:\n");
        for(i=1;i<11;i++)
           scanf("%d",&a[i]);
        printf("\n");
       for(i=1;i<10;i++)
       {  k=i;
          for(j=i+1;j<=10;j++)
                if(a[j]<a[k])  k=j;
          if(i!=k)
          {  x=a[i]; a[i]=a[k]; a[k]=x;}
       }
        printf("The sorted numbers:\n");
        for(i=1;i<11;i++)
    	printf("%d ",a[i]);
    }
    

    二维数组及多维数组

    二维数组的定义

    定义方式: 
    在这里插入图片描述
    在这里插入图片描述
    数组元素的存放顺序
    1、原因: 内存是一维的
    2、二维数组: 按行序优先
    3、多维数组: 最右下标变化最快

    在这里插入图片描述
    数组a[m][n],m行n列,共m*n个元素
    在这里插入图片描述

    这些元素占用m*n个单元,每个单元的大小取决于
    元素的类型。

    任意元素a[i][j]在数组中的位置计算公式为:

    i×n+j (从0开始)

    a——数组的起始地址;a[0]——0行0列元素的地址。

    二维数组元素的引用

    形式: 数组名[下标][下标]

    二维数组元素的初始化

    1、分行初始化
    2、按元素排列顺序初始化

    程序举例

    例1:将二维数组行列元素互换,存到另一个数组中
    在这里插入图片描述

    /*示例1*/
    #include <stdio.h>
    main()
    {   int a[2][3]={{1,2,3},{4,5,6}};
         int b[3][2],i,j;
        printf("array a:\n");
        for(i=0;i<=1;i++)
        {   for(j=0;j<=2;j++)
    	{   printf("%5d",a[i][j]);
    	    b[j][i]=a[i][j];
    	}
    	printf("\n");
        }    
        printf("array b:\n");
        for(i=0;i<=2;i++)
        {   for(j=0;j<=1;j++)
    	   printf("%5d",b[i][j]);
             printf("\n");
        }
    }
    

    例2:求二维数组中最大元素值及其行列号
    在这里插入图片描述

    /*示例2*/
    #include <stdio.h>
    main()
    {  int a[3][4]={{1,2,3,4},
                            {9,8,7,6},
                            {-10,10,-5,2}};
        int i,j,row=0,colum=0,max;
        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:分别求n阶方阵两条对角线上的元素之和

    /*示例3*/
    #define N 3
    main()
    {   int i,j,a[N][N];
    int sum1=0,sum2=0;
    for(i=0;i<N;i++)
      for(j=0;j<N;j++)
        scanf(%d”,&a[i][j]);
    for(i=0;i<N;i++)
      for(j=0;j<N;j++)
        if(i==j) sum1+=a[i][j];
    for(i=0;i<N;i++)
      for(j=N-1;j>=0;j--)
        if((i+j)==N-1) sum2+=a[i][j];
    printf(“sum1=%d,sum2=%d\n”,sum1,sum2);
    }
    

    字符数组和字符串

    字符数组

    定义 : 每个元素存一个字符,主要用来对字符串操作。
    字符数组的初始化:

    1、逐个字符赋值
    2、用字符串常量

    字符数组的引用:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    字符串

    字符串及其结束标志

    (1)、无字符串变量,用字符数组处理字符串。
    (2)、字符串结束标志:‘\0’。

    在这里插入图片描述
    字符串的输入输出
    输入:

    • 用scanf函数
      (1).输入单个字符:%c 需用循环语句
      (2).输入字符串:%s scanf(“%s”,str);
    • 用gets函数:gets(str);

    输出:

    • 用printf函数
      (1).输出单个字符:%c 需用循环语句
      (2).输出字符串:%s printf(“%s”,str);
    • 用puts函数:puts(str);

    在这里插入图片描述

    常用的字符串处理函数: 加粗样式包含在头文件 string.h

    字符串输出函数puts

    格式: puts(字符数组)
    功能: 向显示器输出字符串(输出完,换行)
    说明: 字符数组必须以‘\0’结束

    字符串输入函数gets

    格式: gets(字符数组)
    功能: 从键盘输入一以回车结束的字符串放入字符数组中,并自动加‘\0’
    说明: 输入串长度应小于字符数组维数

    字符串连接函数strcat

    格式: strcat(字符数组1,字符数组2)
    功能: 把字符数组2连到字符数组1后面
    返值: 返回字符数组1的首地址
    说明:
    1、字符数组1必须足够大
    2、连接前,两串均以‘\0’结束;连接后,串1的‘\0’取消, 新串最后加‘\0’

    字符串拷贝函数strcpy

    格式: strcpy(字符数组1,字符串2)
    功能: 将字符串2,拷贝到字符数组1中去
    返值: 返回字符数组1的首地址
    说明:
    1、字符数组1必须足够大
    2、拷贝时‘\0’一同拷贝
    3、不能使用赋值语句为一个字符数组赋值
    在这里插入图片描述

    字符串比较函数strcmp

    格式: strcmp(字符串1,字符串2)
    功能: 比较两个字符串
    比较规则: 对两串从左向右逐个字符比较(ASCII码),直到遇到不同字符或‘\0’为止
    返值: 返回int型整数,
    a. 若字符串1< 字符串2, 返回负整数
    b. 若字符串1> 字符串2, 返回正整数
    c. 若字符串1== 字符串2, 返回零
    说明: 字符串比较不能用“==”,必须用strcmp

    字符串比较函数strcmp

    字符串长度函数strlen
    格式:strlen(字符数组)
    功能:计算字符串长度
    返值:返回字符串实际长度,不包括‘\0’在内
    在这里插入图片描述

    展开全文
  • 如果让你指定一个气球的颜色,可以定义一个一维数组设定颜色 #include<stdio.h> int main(){ char a[10]; printf("设定一个气球的颜色\n"); scanf("%s",a); printf("这个气球的颜色是%s\n",a); } 如果让...

    以气球算法题为例

    如果让你指定一个气球的颜色,可以定义一个一维数组设定颜色

    #include<stdio.h>
    int main(){
    	char a[10];
    	printf("设定一个气球的颜色\n");
    	scanf("%s",a);
    	printf("这个气球的颜色是%s\n",a);
    }
    

    如果让你指定5个气球的颜色,可以定义一个二维数组设定颜色

    #include<stdio.h>
    int main(){
    	char a[10][10];
    	int i;
    	for(i=1;i<=5;i++){
    	printf("指定第%d个气球的颜色:\n",i);
    	scanf("%s",a[i]);
    	printf("第%d个气球的颜色是%s\n",i,a[i]);
    	} 
    }
    

    c语言中要char数组代替字符串型,使用%s,不用加&符号;其他的整型数组、双精度数组,赋值时依然是要加&符号的

    展开全文
  • 第一部分:一维数组 我们之前所学过的数据类型都属于基本数据类型(整型、浮点型、字符型)。实际上C语言不仅仅可以操作基本数据类型,还可以操作构造数据类型(如结构体、数组等)。 数组是有序数据的结合,数组中...

    第一部分:一维数组
    我们之前所学过的数据类型都属于基本数据类型(整型、浮点型、字符型)。实际上C语言不仅仅可以操作基本数据类型,还可以操作构造数据类型(如结构体、数组等)。
    数组是有序数据的结合,数组中的每个元素都属于同一种数据类型。
    每个数组都有一个数组名,数组名代表了数组的起始地址。
    数组中的元素由下标(或索引)标识,下标是从0开始到n-1(数组长度为n)的整数。
    示例:一个拥有10个元素的int型数组a
    int a[10];
    其元素是a[0]、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]
    数组同基本数据类型变量一样,必须要先定义再使用
    1、数组的定义:
    数据类型 数组名[长度]
    其中长度必须是整数必须大于0。以下的定义都是合法的
    int a[10];
    float f[10];
    int b[2*3];
    获取数组元素:数组名[下标]。下标可以是变量、常量或常量表达式。
    数组在定义后,就在内存中划分了一块空间用于存储数组。以int a[n]为例(n大于0):
    内存中划分出一块空间用于存储数组,这块空间的大小是sizeof(int)*n,划分成n块来顺序存储a[0]~a[n-1]。数组名代表这块空间的首地址(也就是a[0]的地址)
    计算数组所占内存空间的大小:sizeof(a);//计算数组a占内存空间大小
    思考:已知一个数组(如int a[n]),在只知道数组名,不知道数组元素个数的情况下,如何算出数组中元素个数(即求出n的值)?
    答案:sizeof(a)/sizeof(a[0]);
    2、数组的初始化:
    1)数组初始化的一般形式:
    类型 数组名[数组长度]={值1,值2……};
    示例:int a[10]={0,1,2,3,4,5,6,7,8,9};
    将花括号内的值一一对应赋值到数组各个元素中
    2)如果只给数组一部分元素赋值,则剩下的会变成0
    示例:int a[10]={1,2,3};
    则a[3]及以后的值都是0
    如果想使一个int型数组中元素全部为0可以这样写:
    int a[10]={0};
    3)对数组内全部元素赋值时,由于元素个数已经确定,因此可以不指定数组长度。
    示例:int a[5]={1,2,3,4,5};<---等价--->int a[]={1,2,3,4,5};
    如果采取第二种写法,系统就会根据后面花括号内的个数来分配数组长度是5。但若数组长度与提供初值个数不同,则数组长度不可省略。
    示例:定义一个数组,反序输出
    #include<stdio.h>
    int main()
    {
        int i,a[]={0,1,2,3,4,5,6,7,8,9};//定义数组并初始化,系统分配数组长度是10
        for(i=9;i>=0;i--)
        {
            printf("%d ",a[i]);//将数组反序输出
        }
        printf("\n");
        return 0;
    }
    练习1:使用数组存储斐波那契数列前30项,并输出
    答案:
    #include <stdio.h>
    #define MAX 30
    int main()
    {
        int i,fibonacci[MAX];
        fibonacci[0]=1;
        fibonacci[1]=1;
        for(i=2;i<MAX;i++)
        {
            fibonacci[i]=fibonacci[i-1]+fibonacci[i-2];
        }
        for(i=0;i<MAX;i++)
        {
            printf("%d\t",fibonacci[i]);
        }
        printf("\n");
        return 0;
    }
    练习2:从键盘输入10个学生的成绩,如果遇到大于100或者小于0的成绩需要提示输入错误重新输入。之后计算10个学生的总成绩和平均成绩
    答案:
    #include <stdio.h>
    #define MAX 10
    int main()
    {
        int a[MAX];
        int i,sum=0;
        float avg=0;
        for(i=0;i<MAX;i++)
        {
            printf("请输入第%d个学生的成绩:",i+1);
            scanf("%d",&a[i]);
            if(a[i]<0 || a[i]>100)
            {
                printf("输入非法数据,请重新输入!\n");
                i--;//退回上次循环状态
            }
        }
        for(i=0;i<MAX;i++)
        {
            sum += a[i];
        }
        avg = (float)sum/MAX;
        printf("总成绩是%d\n平均成绩是%f\n",sum,avg);
        return 0;
    }
    练习3(选做):使用数组法解决约瑟夫环问题
    约瑟夫入狱,监狱内共有33个犯人。某日33名犯人围成一圈,从第一个犯人开始报数,报到数字7的犯人出列,被枪毙,下一名犯人重新从1开始报数。依次类推,直至剩下最后1名犯人可被赦免。聪明的约瑟夫在心里稍加计算,算出了最后枪毙的位置,他站在这个位置,最终避免了自己被枪毙,逃出升天。
    问:约瑟夫算出的是哪个位置?
    提示:对于约瑟夫环问题来说,需要解决4个问题
    ⒈需要一个长度为33的数组,数组内需要存储什么?
    ⒉如何解决数组循环的问题?
    ⒊如何解决“逢7一杀”这个逻辑?
    ⒋如何处理“已死之人”?
    答案:
    #include<stdio.h>
    int main()
    {
        int fanren[33]={0};//用0/1表示犯人是否存活,0表示存活,1表示死亡
        int i,j,k=-1;
        for(i=0;i<32;i++)//外层循环表示要枪毙32个犯人
        {
            for(j=0;j<7;j++)//内层循环表示每隔7个犯人
            {
                k++;//表示当前犯人下标
                if(k==33)//越界处理
                    k=0;
                if(fanren[k]==1)//如果该犯人已死,则应在报数中-1
                    j--;
            }
            fanren[k]=1;//找到第7个犯人
            printf("第%d号已被枪毙\n",k+1);
        }
        for(i=0;i<33;i++)
        {
            if(fanren[i]==0)//跳过所有已被枪毙的犯人
                printf("第%d号存活\n",i+1);
        }
        return 0;
    }
    练习4(选做):从键盘输入10个各不相同的整数,存储在数组中,使用冒泡排序法将数组排序并输出
    冒泡排序:是一种简单的排序算法
    1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
    2)对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
    3)针对所有的元素重复以上的步骤,除了最后一个。
    4)持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
    答案:
    #include <stdio.h>
    #define MAX 10
    int main()
    {
        int a[MAX];
        int i,j,tmp;
        //输入10个数
        for(i=0;i<MAX;i++)
        {
            scanf("%d",&a[i]);
        }
        //输入完毕
        //冒泡排序
        for(i=0;i<MAX-1;i++)//外层循环表示循环MAX-1次
        {
            for(j=0;j<MAX-i-1;j++)//内层循环表示操作当前的数组元素下标
            {
                if(a[j]>a[j+1])//如果比它后面的大就交换
                {
                    tmp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = tmp;
                }
            }
        }
        //冒泡排序end
        //打印输出
        for(i=0;i<MAX;i++)
        {
            printf("%d ",a[i]);
        }
        printf("\n");
        return 0;
    }

    第二部分:二维数组
    C语言中不仅可以存储一维数组,还可以存储二维数组。二维数组类似矩阵,有行/列等
    1、二维数组的定义:数据类型 数组名[常量表达式1][常量表达式2];
    示例:
    int a[2][3];//定义一个2*3的二维int型数组
    float f[3][4];//定义一个3*4的二维float型数组
    2、二维数组的存储方式:
    C语言对二维数组的存储方式是:将二维数组视为一种特殊的一维数组,它的元素又是一个一维数组。例如,对于二维数组:
    int a[3][4];
    它的存储方式是:
    a[0]-------a[0][0]  a[0][1]  a[0][2]  a[0][3]
    a[1]-------a[1][0]  a[1][1]  a[1][2]  a[1][3]
    a[2]-------a[2][0]  a[2][1]  a[2][2]  a[2][3]
    在内存中的存储顺序是:
    a[0][0]->a[0][1]->a[0][2]->……->a[2][3]
    获取数组元素:类似一维数组:数组名[下标1][下标2]
    3、二维数组的初始化
    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};
    类似于一维数组,如果有未写的则默认为0
    3)可以对二维数组的部分元素赋值:例如:
    int a[3][4]={{1},{5},{9}};
    则赋值结果是a[0][0]=1,a[1][0]=5,a[2][0]=9
    int a[3][4]={{1},{0,6},{0,0,11}};
    则赋值结果是a[0][0]=1,a[1][1]=6,a[2][2]=11
    这种方法对非0元素较少时比较方便。
    4)可以提供全部元素的初值,这样常量表达式1(即第一个下标)可以缺省不写,系统会根据输入的多少来计算行数。但常量表达式2(即第二个下标)不可缺省。例如:
    int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
    则系统自动计算出这个二维数组是a[3][4]
    思考:如果int a[][4]={1,2,3,4,5,6,7,8,9,10};则该二维数组是多少?
    答案:同样是a[3][4],只不过10以后的两个元素未初始化,变成默认值0

    注意:C语言对于数组下标越界不予检查。因此对于数组的操作要十分注意其边界值。如果指定了数组长度而初始化元素个数多余指定的数组元素个数,如:
    int a[2][3]={1,2,3,4,5,6,7,8,9};
    则会只取前n个数据进行初始化(n是指定长度,如这里n=6),后面的剩余数据舍弃。编译期间编译器会报warning。

    练习1:自定义一个3*4的矩阵,输出矩阵中值最大的元素,并输出其数组下标
    答案:
    #include <stdio.h>
    #define LINE 3
    #define COL 4
    int main()
    {
        int a[LINE][COL]={55,11,77,33,22,88,44,100,121,66,555,99};//自定义
        int i,j,max,x=0,y=0;
        max=a[x][y];
        for(i=0;i<LINE;i++)
        {
            for(j=0;j<COL;j++)
            {
                if(a[i][j]>max)
                {
                    x=i;
                    y=j;
                    max=a[i][j];
                }
            }
        }
        printf("最大元素是%d\n数组下标是%d和%d\n",max,x,y);
        return 0;
    }
    练习2:打印杨辉三角型前10行
    杨辉三角型:杨辉三角型是形如以下矩阵的三角形:
    1
    1 1
    1 2 1
    1 3 3  1
    1 4 6  4  1
    1 5 10 10 5 1
    ……
    答案:
    #include <stdio.h>
    #define LINE 10
    int main()
    {
        int yanghui[LINE][LINE]={0};
        int i,j;
        //构造杨辉三角型
        for(i=0;i<LINE;i++)
        {
            for(j=0;j<=i;j++)
            {
                if(j==0)
                    yanghui[i][j]=1;
                else if(i==j)
                    yanghui[i][j]=1;
                else
                    yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
            }
        }
        //构造杨辉三角型end
        //打印杨辉三角型
        for(i=0;i<LINE;i++)
        {
            for(j=0;j<LINE;j++)
            {
                if(yanghui[i][j]!=0)
                    printf("%-4d",yanghui[i][j]);
            }
            printf("\n");
        }
        //打印杨辉三角型end
        return 0;
    }

    4、使用数组的注意事项:
    1)二维数组的第一个下标可以省略不写,编译器会根据我们初始化值的多少计算出数组的第一个下标。而第二个下标不可以省略不写。例如:
    int a[3][]={1,2,3,4,5};//非法
    如果这样写,编译器在分配内存的过程中不知道需要分配多大的空间(因为第二个下标未定),因此会报错。
    2)不能为数组整体赋值。如:
    int a[10]=1;
    int a[10];a={1,2,3,4,5,6,7,8,9,10};
    以上2种都是错误的

    第三部分:字符数组与字符串
    1、字符数组的定义:
    字符数组的定义方法与之前介绍的一维数组的类似。例如:
    char c[10];
    2、字符数组的初始化:
    字符数组的初始化与之前介绍的一维数组的类似。例如:
    char c[]={'I',' ','a','m',' ','a',' ','s','t','u','d','e','n','t'};
    练习:输入以下代码,编译,运行,查看结果。
    #include<stdio.h>
    int main()
    {
        char diamond[][5]={{' ',' ','*'},{' ','*',' ','*'},{'*',' ',' ',' ','*'},{' ','*',' ','*'},{' ',' ','*'}};
        int i,j;
        for(i=0;i<5;i++)
        {
            for(j=0;j<5;j++)
            {
                printf("%c",diamond[i][j]);
            }
            printf("\n");
        }
        return 0;
    }
    3、字符串
    如果我们一个字符一个字符键入的话,不仅操作不便,而且还容易出现错误。因此对于字符型数组,我们可以使用字符串来操作。
    字符串:由双引号""引起来的字符序列。
    字符串中每个字符都视为一个字符型数组的元素,存储占1字节。
    字符串的结束标志是'\0'
    /*************************************关于'\0'************************************************************/
    '\0'是转义字符,在ASCII表中的编码为0(NULL)。它不是一个可见的字符,而是一个空操作符,即什么都不做。用'\0'表示字符串结束标志不会产生其他的附加操作,只是提供一个标识。
    /*************************************关于'\0'end*********************************************************/
    思考:0、'0'、'\0'、"0"相同么?有什么区别?
    答案:
    ⒈0代表数字0
    ⒉'0'代表字符零,在ASCII表中的编码是48,是一个可见字符
    ⒊'\0'代表NULL,在ASCII表中的编码是0,是一个不可见字符、空操作符,作为字符串的结束标志。
    ⒋"0"代表字符串"零",这是一个字符串,实际上等价于'0''\0'(字符0后面加字符串结束标志'\0')

    使用字符串常量对字符数组进行初始化:
    char c[]={"I am student"};
    或者省略花括号直接写成:
    char c[]="I am student";
    使用这种方式为字符数组赋值,访问数组内元素的方法同一维数组
    c[0]--->I
    c[1]--->' '(空格)
    ……
    如果使用字符串常量给字符数组赋值,则字符数组的最后一个元素不是't'而是'\0'
    char c[]="China";<---等价--->char c[]={'C','h','i','n','a','\0'};//多出的'\0'是字符串结束标志
    因此,字符串与字符数组有稍许差别,不完全等价。字符数组若不人为添加,末尾是不会出现'\0'的,而字符串末尾系统会自动添加'\0'表示字符串结束。
    输出字符串不必使用for()循环遍历整个数组,直接使用%s格式控制符即可。
    printf("%s",c);
    示例:
    int main()
    {
        char c[]="I am a Student.";
        printf("%s\n",c);
        return 0;
    }
    当然,我们也可以使用%s在scanf()函数中直接输入一个字符串:
    scanf("%s",c);
    不过,使用%s输入整个字符串需要注意以下2点:
    ⒈因为C语言不检查数组下标越界问题,因此如果直接键入字符串给字符数组,需要将字符数组设置的足够大,这样才不会丢失数据。
    ⒉输入字符串给字符数组,注意scanf()的第二个参数不要带&(取地址符)。因为数组名就代表了数组的地址。
    示例:
    int main()
    {
        char c[64];//申请一块足够大的空间作为输入的字符串的存储空间
        scanf("%s",c);
        printf("%s\n",c);
        return 0;
    }

    第四部分:字符串处理函数
    C语言提供各种处理字符串的函数,可以简便地处理字符串。
    字符串处理函数在头文件string.h中,使用时不要忘了包含头文件
    1、字符串输入输出函数:puts()和gets()
    1)puts()函数
    函数原型:
    int puts(char *string);
    使用方法:
    puts(字符数组名 或 字符串指针);
    说明:
    puts()函数将一个字符串输出到标准输出流中,再输出到屏幕上。注意puts()函数只能输出字符串,不能进行其他操作
    puts()函数等价于:printf("%s\n",string);
    示例:
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        puts("Hello World!");
        return 0;
    }
    2)gets()函数
    函数原型:
    char* gets(char *string);
    使用方法:
    gets(字符数组名);
    说明:
    gets()函数从标准输入流中获得一个字符串,直至接收换行符\n或EOF为止。将获得的字符串储存到字符数组内,读取出的换行符转换成'\0'
    注意:
    gets()函数不会检查待存储的字符数组的大小,若没有接收到换行符或EOF则会无限制读取下去。因此待存储的字符数组一定要足够大。
    事实上gets()函数缺点很多,因此我们不推荐使用。推荐使用scanf()或fgets()函数。
    gets()函数和puts()函数一次只能操作一个字符串,不能写成
    gets(str1,str2);
    gets()和scanf("%s")的区别:当键入空格时,scanf("%s")认为该字符串已经结束,空格后的是下一个字符串内容。而gets()函数则会当空格做本字符串的一部分。

    2、字符串连接函数:strcat()
    函数原型:
    char* strcat(char *s1,const char *s2);
    使用方法:
    strcat(字符数组1,字符数组2);
    说明:
    strcat是string catenate的缩写,作用是把后一个字符串(字符数组2)拼接到前一个字符串(字符数组1)之后,结果存放在字符数组1中。
    示例:
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        char str1[30]="Hello ";
        char str2[]="World!";
        strcat(str1,str2);
        printf("%s\n",str1);
        return 0;
    }
    注意:
    1)字符数组1的空间需要足够大以能够存储得下两个字符串,否则数组长度不够,编译阶段会报warning,并且不会输出正确结果。
    2)两个字符串拼接时,字符数组1之后的'\0'会取消,只在拼接后的新的字符数组之后添加'\0'
    练习:自定义2个字符数组,不使用系统提供的strcat()函数,实现strcat()函数功能。
    答案:
    #include<stdio.h>
    int main()
    {
        char s1[30]="Hello ";
        char s2[]="World!";
        int i=0,j=0;
        while(s1[i]!='\0')//寻找s1中'\0'的位置
        {
            i++;
        }
        while(s2[j]!='\0')//开始字符串拼接,直至s2出现'\0'(即字符串2结束)为止
        {
            s1[i]=s2[j];
            i++;
            j++;
        }
        s1[i]='\0';//不要忘了添加字符串结束符'\0'
        printf("%s\n",s1);//输出
        return 0;
    }

    3、字符串复制函数:strcpy()和strncpy()
    1)strcpy()函数
    函数原型:
    char* strcpy(char *str1,const char *str2);
    使用方法:
    strcpy(字符数组1,字符数组2或字符串2);
    说明:
    strcpy()是string copy的缩写,表示“字符串复制函数”,将字符数组2或字符串2的内容复制给字符数组1。
    示例:
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        char s1[10],s2[]="China";
        strcpy(s1,s2);
        printf("%s\n",s1);
        return 0;
    }
    注意:
    1)字符数组之间不能互相赋值。以下这种方式是非法的:
    char s1[];
    char s2[]="China";
    s1=s2;
    因此如果给字符数组间赋值,必须使用strcpy()函数。
    2)字符数组1的空间必须足够大以能够容纳字符数组2或字符串2的所有字符。这点与strcat()相同。
    3)strcpy()的两个参数,第一个参数必须是字符数组名,第二个参数可以是字符数组名或直接是一个字符串常量。例如:
    strcpy(s1,"China");
    4)如果字符数组2或字符串2比字符数组1短,则在复制操作后,字符数组1内没被复制所覆盖掉的内容将会保留
    练习:自定义2个字符数组,不使用系统提供的strcpy()函数,实现strcpy()函数功能。
    答案:
    #include<stdio.h>
    int main()
    {
        char s1[30];
        char s2[]="Hello World!";
        int i=0;
        while(s2[i]!='\0')
        {
            s1[i]=s2[i];
            i++;
        }
        s1[i]='\0';//不要忘了添加字符串结束符'\0'
        printf("%s\n",s1);
        return 0;
    }

    2)strncpy()函数
    函数原型:
    char* strncpy(char *s1,const char *s2,int n);//实际上第三个参数是size_t型
    使用方法:
    strncpy(字符数组1,字符数组2或字符串2,长度);
    说明:
    类似strcpy()函数,只不过是取出字符数组2或字符串2前n个字符复制到字符数组1中。
    注意:n的值不能超过字符数组2或字符串2的总长度。

    4、字符串比较函数:strcmp()
    函数原型:
    int strcmp(const char *s1,const char *s2);
    使用方法:
    strcmp(字符数组1或字符串1,字符数组2或字符串2);
    说明:
    字符串比较的规则是:将字符串1和字符串2的第一个字符拿出比较ASCII码,如果字符串1大则返回一个正数,如果字符串2大则返回一个负数。如果相等则比较下一个字符。直至遇到不同字符或遇到字符串结尾'\0'。如果两个字符串相同,则返回0。
    示例:
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        char s1[]="Hello";
        char s2[]="World";
        if(strcmp(s1,s2)>0)
        {
            printf("s1字符串大\n");
        }
        else if(strcmp(s1,s2)<0)
        {
            printf("s2字符串大\n");
        }
        else
        {
            printf("两个字符串相同\n");
        }
        return 0;
    }
    注意:
    字符数组或字符串之间不能直接使用关系运算符来比较大小,以下的操作都是非法的:
    str1<str2;str1==str2;str1>str2;
    必须使用strcmp函数来比较字符串
    练习:自定义2个字符数组,不使用系统提供的strcmp()函数,实现strcmp()函数功能
    答案:
    //注意:这里不是main()函数而是另一个自定义函数。有关函数的使用方法我们将在接下来的课程中学习
    #include<stdio.h>
    int my_strcmp(char *s1,char *s2)
    {
        int i=0,j=0;
        while(s1[i]!='\0' && s2[j]!='\0')
        {
            if(s1[i]>s2[j])
                return 1;
            else if(s1[i]<s2[j])
                return -1;
            i++;
            j++;
        }
        if(s1[i]!='\0' && s2[j]=='\0')
            return 1;
        else if(s1[i]=='\0' && s2[j]!='\0')
            return -1;
        return 0;
    }
    int main()//主函数,程序入口
    {
        char s1[]="Hello";
        char s2[]="World";
        switch(my_strcmp(s1,s2))//在这里调用my_strcmp()函数
        {
        case 1:
            printf("s1大\n");break;
        case 0:
            printf("一样大\n");break;
        case -1:
            printf("s2大\n");break;
        }
        return 0;
    }

    5、测字符串长度函数:strlen()
    函数原型:
    int strlen(const char *s);//实际不是int类型而是size_t类型
    使用方法:
    strlen(字符数组 或 字符串);
    说明:
    strlen()函数是string length的缩写,其功能是测试字符串的长度(不包括'\0')
    示例:
    #include<stdio.h>
    #include<string.h>
    int main()
    {
        char s1[]="Hello World";
        printf("长度是%d\n",strlen(s1));
        return 0;
    }
    注意:
    sizeof()与strlen()的区别:
    sizeof()的长度是整个字符数组的总长度,其中包括'\0';而strlen()不包括'\0'。例如:
    char s1[]="Hello";
    则sizeof(s1)=6,而strlen(s1)=5。
    练习:自定义1个字符数组,不使用系统提供的strlen()函数,实现strlen()函数功能
    答案:
    #include<stdio.h>
    int my_strlen(char *s1)
    {
        int i;
        for(i=0;s1[i]!='\0';i++);
        return i;
    }
    int main()
    {
        char s1[]="Hello World";
        printf("%d\n",my_strlen(s1));
        return 0;
     

    展开全文
  •  定义一个二维数组 该数组有2行3列共6个元素 这6个元素都存放int型数据 存储时先存储第一行的3个元素,然后再存储第二行的3个元素 可将此二维数组看成是一个有2个元素(一维数组)的一维数组,每个元素又是一个有...

    要求:
    了解多维数组的概念
    掌握二维数组的使用
    掌握用字符数组存放字符串的方法
    掌握字符串的输入及输出方法

    二维数组的定义
     例:int a[2][3];
     定义一个二维数组
     该数组有2行3列共6个元素
     这6个元素都存放int型数据
     存储时先存储第一行的3个元素,然后再存储第二行的3个元素
     可将此二维数组看成是一个有2个元素(一维数组)的一维数组,每个元素又是一个有3个元素(int)的一维数组

    二维数组的初始化
     ⑴ int i[3][4]         //没初始化,值不确定
     ⑵ int i[2][2]={1,2,3,4}    //有4个元素,且都有确定的值,按存储顺序初始化
     ⑶ int i[2][2]={1}       //有4个元素,a[0][0]的值为1,其余默认为0
     ⑷ int i[3][3]={{1},{2,3},{4}} //按行初始化
     ⑸ int i[][4]={{1,2},{3},{4,5}} //初始化数据的行数即为数组的行数。对多维数组仅可省略最左侧一维的的大小。

    程序示例
    //奇数魔方阵
    //在n×n的方阵中填写从1开始的自然数,使行、列及对角线数据的和都相等

    #include<iostream.h>
    #include<stdio.h>
    void main()
    {
      int row,col,mf[9][9];
      int i,j,size;
      printf("请输入魔方阵的大小(3~9):");
      cin>>size;
      if (size<3)size=3;
      if (size>9)size=9;
      if (size%2==0)size++;
      row=0, col=size/2;
      for(i=1;i<=size*size;i++)
      {
        mf[row][col]=i;
        if (i%size==0) row++;
        else
        {
          row--, col++;
          if (row<0) row=size-1;
          if (col==size) col=0;
        }
      }
      for(i=0;i<size;i++)
      {
        for(j=0;j<size;j++)
          printf("%4d ",mf[i][j]);
        printf("\n\n");
      }
    }

    字符数组的定义及初始化
     ⑴ char c[15];
       c[0]= 'W';         //直接对数组元素赋值
       c[1]= 'e';
     ⑵ char c[7]={ 'W', 'e', 'l', 'c', 'o', 'm', 'e'};    //定义数组的同时进行初始化
       char c[8]={ 'W', 'e', 'l', 'c', 'o', 'm', 'e', '\0'}; //这种初始化数据的方法太累
     ⑶ char c[100]= {"Welcome"};  //用字符串对字符数组进行初始化
       char c[100]= "Welcome";   //数组的大小大于所存放的字符串的长度
       char c[]= "Welcome";    //初始化数据的个数即为数组的大小

    字符数组的引用
     ⑴ 按数组元素引用
     ⑵ 把数组作为一个整体
       此时注意,数组名代表字符串首字符的地址,字符串以字符'\0'作为结束标记
       ①显示字符串
       char c[]="How are you?\n";
       cout<<c;
       puts(c);      //显示串后会自动换行,使用时要包含头文件stdio.h
       printf("%s",c); 
       ②输入字符串
       char c[10];    //含10个元素的字符数组
       cin>>c;      //空格、制表符、回车作为字符串结束标记
       gets(c);      //以回车作为结束标记,串中可含空格、制表符。
       cin.getline(c,10); //以回车作为结束标记,最多9个字符,要为字符串结束标记'\0'留出位置

    程序示例
    //统计输入的字符串中包含的空格数量
    #include<stdio.h>
    void main()
    {
      int i,count=0;
      char s[100];
      puts("请输入一个字符串:");
      gets(s);
      for (i=0;s[i]!=0;i++)
        if(s[i]==' ')count++;
      printf("\n串中空格的数量=%d\n",count);
    }

    运行结果
    请输入一个字符串:
    A  BC DEF G

    串中空格的数量=6
    Press any key to continue

    思考题
    //写出下面程序的输出结果
    #include<iostream.h>
    void main()
    {
      char s[]="Good morning";
      cout<<s<<endl;
      s[4]=0;
      cout<<s<<endl;
    }

    多个字符串的存储
     一般采用二维字符数组
     char c[5][10]={"Basic","Foxpro","C++"}; //可存放5个字符串,每串最大9个字符
     char c[][10]={"Basic","Foxpro","C++"};  //初始化字符串的个数即为数组的行数

    显示多个字符串
     char c[][10]={"Basic","Foxpro","C++"};
     for(int i=0;i<3;i++)
       cout<<c[i]<<endl;//c[i]可理解为c[i][0]、c[i][1]、...、c[i][9]这个一维数组的数组名

    程序示例
    //根据用户输入的数字(1~7)显示相应的星期。
    #include<iostream.h>
    void main()
    {
      cout<<"请输入一个数字(1~7):";
      int i;
      cin>>i;
      char w[][10]={"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
      cout<<"对应的星期是:"<<w[i-1]<<endl;
    }

    运行结果
    请输入一个数字(1~7):5
    对应的星期是:Friday
    Press any key to continue

    试试身手
    统计从键盘输入的英文句子中有多少个英文单词,各单词间用空格分隔。
    比如若输入 I love you ,则显示有3个单词。

    转载于:https://www.cnblogs.com/Lee-geeker/archive/2013/05/07/3065478.html

    展开全文
  • 01 一维数组 数组,就是把相同数据类型的变量组合在一起而产生的数据集合。 数据就是从某个地址开始连续若干个位置形成的元素集合。 数据类型 数组名[数组大小]; 数组大小必须是整数常量,不可以是变量。 一维...
  • 维数组存储字符串

    千次阅读 2020-07-18 17:28:45
    维数组存储字符串 ... printf("请输入字符串:\n"); scanf("%s",s[i]); } //打印数据 for(int j= 0;j<5;j++) { printf("打印数据为:%s\n", s[j]); } //清零i行 bzero(s,4*100); //打印检查
  • 要求: 了解多维数组的概念 掌握二维数组的使用 掌握用字符数组存放字符串的方法 掌握字符串输入及输出方法 ... 可将此二维数组看成是一个有2个元素(一维数组)的一维数组,每个元素又是一个
  • C语言04 -- 一维数组,字符串

    千次阅读 2015-07-20 19:36:42
    // C4–一维数组 // // Created by dllo on 15/7/3. // Copyright (c) 2015年 Gaozi. All rights reserved. //import // 最小公倍数printf(“主人,请您输入您喜欢的两个数吧!\n”); int m = 0, n = 0; scanf...
  • 维数组字符串数组

    千次阅读 2014-08-14 14:43:47
    维数组定义时,第一维下标可以省略(行数可以省略),但是第二维下标必须制定,(列数必须要给,列数时换行的一个标准) int a[][3] = {1,2,3,4,5,6, 7}; 并且,第一维下标和第二位下标都必须是常量或常量表达式...
  • 维数组 .二维数组初始化【此处介绍4种方法】 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....
  • 数字我用二维数组能控制循环,但不知怎么在二维数组里储存字符串,是用数组指针吗?大神们能给个杨辉三角但是数学换成字符串的例子吗?类似图中用二维数组做怎么表示![图片说明]...
  • 本文主要是谭浩强老师c++教材第三版第五章的小结。...数组是用来存储系列数据,但它往往被认为是系列相同类型的变量。 数组的声明并不是声明个个单独的变量,比如 number0、number1、...、number...
  • java二维数组字符串

    千次阅读 2017-03-08 13:03:23
     在Java语言中,二维数组被看做是数组的数组,数组空间不是连续分配的,所以不要求二维数组一维的大小都相同。 数组一旦创建后,不能调整大小,但可使用相同的引用变量来引用一个 全新的数组,如:int a[]=new ...
  • 、二维数组
  • 个3*3二维数组中每行的最大值和每行的和。 输入格式: 在行中输入9个小于100的整数,其间各以个空格间隔 输出格式: 输出3行3列的二维数组,并在每行后面分别输出每行最大值和每行元素的和,每个数据输出占4列...
  • 1、概念:可以看做是一个特殊的一维数组,这个一维数组的每个元素又是一个一维数组 2、定义:数据类型 数组名 [ 第一维的长度(行)] [ 第二维的长度(列)] 例如:int a[2][3]; 1)这是一个特殊的
  • C#二维数组字符串操作

    千次阅读 2013-05-29 21:30:00
    维数组 int r = arr.Rank;//数组的维数 Console.WriteLine("长度{0}",arr.Length);//总长度 int e=arr.GetLength(0);//获取第一维的长度 Console.WriteLine("第一维的长度{0}",e);//2 arr.GetUpperBound(0);/...
  • 指针与多维数组 多维数组地址的表示方法: 二维数组s[3][4] 定义 int ...注意:S代表着二维数组的首地址,s+1代表第行的首地址,而s[1]代表着第行第列的地址,虽然s+1和s[1]都是代表着同个地址,但
  • C++使用VARIANT实现二维数组的操作 VARIANT变量是COM组件之间互相通信的重要的参数变量之,它可以容纳多种不同的类型,如short、long、double等,包括各类指针和数组。组件之间的互相调用是比较耗时的,尤其带当...
  • 二维数组可以看着是一种特殊的一维数组。 二、二维数组初始化 1、分行给二维数组初始化 int a[3][4] = { { 1,2,3,4 },  { 5,6,7,8 },   { 9,10,11,12 }  }; 2、可以将所有的数据写在一个{ }内 ...
  • #include<stdio.h> int main(){ char a[15][20]; int i; for(i=0;i<15;i++){ scanf("%s",&a[i][0]); } printf("%s ",&a[2][0]); printf("%s",&a[11][0]); }
  • int main(int argc, const char * argv[]) { @autoreleasepool { #pragma mark-----------二维数组 int a[3][4]={ {1,2,3,4}, {5,6,7,8}, {12,10,11,12} };
  • //import java.util.Arrays; //包含Arrays //import java.util.Random; public class HelloWorld { public static void main(String[] args){ // Scanner s = new Scanner(System.... // System.out.println("请输入
  • //输入三个字符串 // char a[3][20]={0}; // for (int i = 0; i; i++) { // scanf("%s",a[i]); // } //// printf("%s",a[0]); // long maxLength = 0; // for (int i =0; i; i++) { // if (maxLength(a[i])) { // ...
  • 二.三维数组 例如: int a[2][4][3] = {0}; 表⽰示整型的三维数组,2层4...例:随机产生个三维数组,求三维数组的和. for (int i = 0; i ; i++) { //第层控制层 printf("------第%d层-----\n",i+1); for (i
  • 输入字符串实例: [[1,2,3],[2,3,4],[4,5,6]] [[1, 2]] [[]] 下面测试的输出情况:按一维数组打印 [1, 2, 3] [2, 3, 4] [4, 5, 6] [1, 2] [0] 注意: 两个二维数组之间分隔],[中间还有空格的情况 public class Main ...
  • 【1】结构体中含有内置数据类型的一维数组 C++代码: typedef struct _testStru3 { int iValArrp[30]; WCHAR szChArr[30]; }testStru3; EXPORTDLL_API void Struct_ChangeArr( testStru3 *pStru ) { if ...
  • //String[] arr存储的是字符串数组 public static int[] getIndex(String[] arr,String str){ int[] index=new int[0]; for(int i=0;i;i++){ if(str.equals(arr[i])){ index=NewArray(index, i); } } return...
  • 字符数组字符串

    万次阅读 多人点赞 2017-01-26 22:52:04
    、字符数组字符串的再认识此处关于字符串是否是字符数组的问题,此处我们需要明确: 字符数组,完整地说叫字符类型的数组。字符数组不一定是字符串字符串是最后个字符为NULL字符的字符数组字符串一定是...
  • 维数组 字符串 指针

    千次阅读 2016-08-25 11:59:11
    IOS学习第12天二维数组 ...1.二维数组的地址 == 二维数组名 == 二维数组的低地址 == 二维数组中第0行的地址 == 二维数组中第0行第0个元素地址 == 二维数组第0行的低字节地址2.二维数组的长度以及行

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,375
精华内容 32,150
关键字:

一维数组输入字符串