精华内容
下载资源
问答
  • 我设定的二维数组,只有一个值,byte类型,如何用这二维数组表示rgb的几个值。我百度说是二维数组是单通道,只能表示几个值一样的rgb,所以几个值一样怎么设置,还有就是能不能设置三个二维数组,最后组成一个rgb值...
  • 二维数组指针表示,C语言指针引用二维数组详解

    千次阅读 多人点赞 2019-12-09 14:43:53
    但是在概念和使用方法上,二维数组的指针比一维数组的指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话:二维数组就是一维数组,这句话该怎么理解呢? 假如有一个二维数组: int a[3][4] = {{1, 3, ...

    指针变量可以指向一维数组中的元素,当然也就可以指向二维数组中的元素。但是在概念和使用方法上,二维数组的指针比一维数组的指针要复杂一些。要理解指针和二维数组的关系首先要记住一句话:二维数组就是一维数组,这句话该怎么理解呢?

    假如有一个二维数组:

    int a[3][4] = {{1, 3, 5, 7}, {9, 11, 13, 15}, {17, 19, 21, 23}};

    其中,a 是二维数组名。a 数组包含 3 行,即 3 个行元素:a[0],a[1],a[2]。每个行元素都可以看成含有 4 个元素的一维数组。而且 C 语言规定,a[0]、a[1]、a[2]分别是这三个一维数组的数组名。如下所示:

    在这里插入图片描述

    a[0]、a[1]、a[2] 既然是一维数组名,一维数组的数组名表示的就是数组第一个元素的地址,所以 a[0] 表示的就是元素 a[0][0] 的地址,即 a[0] == &a[0][0];a[1] 表示的就是元素 a[1][0] 的地址,即 a[1] == &a[1][0];a[2] 表示的就是元素 a[2][0] 的地址,即 a[2] == &a[2][0]。

    所以二维数组a[M][N]中,a[i]表示的就是元素a[i][0]的地址,即(式一):

    a[i] == &a[i][0]

    我们知道,在一维数组 b 中,数组名 b 代表数组的首地址,即数组第一个元素的地址,b+1 代表数组第二个元素的地址,…,b+n 代表数组第 n+1 个元素的地址。所以既然 a[0]、a[1]、a[2]、…、a[M–1] 分别表示二维数组 a[M][N] 第 0 行、第 1 行、第 2 行、…、第 M–1 行各一维数组的首地址,那么同样的道理,a[0]+1 就表示元素 a[0][1] 的地址,a[0]+2 就表示元素 a[0][2] 的地址,a[1]+1 就表示元素 a[1][1] 的地址,a[1]+2 就表示元素 a[1][2] 的地址……a[i]+j 就表示 a[i][j] 的地址,即(式二):

    a[i]+j == &a[i][j]

    将式一代入式二得(式三):

    &a[i][0]+j == &a[i][j]

    在一维数组中 a[i] 和 *(a+i) 等价,即(式四):

    a[i] == *(a+i)(13-4)

    这个关系在二维数组中同样适用,二维数组 a[M][N] 就是有 M 个元素 a[0]、a[1]、…、a[M–1] 的一维数组。将式四代入式二得(式五):

    *(a+i)+j == &a[i][j]

    由式二和式五可知,a[i]+j 和 *(a+i)+j 等价,都表示元素 a[i][j] 的地址。

    上面几个公式很“绕”,理清楚了也很简单,关键是把式二和式五记住。


    二维数组的首地址和数组名

    下面来探讨一个问题:“二维数组 a[M][N] 的数组名 a 表示的是谁的地址?”在一维数组中,数组名表示的是数组第一个元素的地址,那么二维数组呢? a 表示的是元素 a[0][0] 的地址吗?不是!我们说过,二维数组就是一维数组,二维数组 a[3][4] 就是有三个元素 a[0]、a[1]、a[2] 的一维数组,所以数组 a 的第一个元素不是 a[0][0],而是 a[0],所以数组名 a 表示的不是元素 a[0][0] 的地址,而是 a[0] 的地址,即:

    a == &a[0]

    而 a[0] 又是 a[0][0] 的地址,即:

    a[0] == &a[0][0]

    所以二维数组名 a 和元素 a[0][0] 的关系是:

    a == &(&a[0][0])

    即二维数组名 a 是地址的地址,必须两次取值才可以取出数组中存储的数据。对于二维数组 a[M][N],数组名 a 的类型为 int(*)[N],所以如果定义了一个指针变量 p:

    int *p;

    并希望这个指针变量指向二维数组 a,那么不能把 a 赋给 p,因为它们的类型不一样。要么把 &a[0][0] 赋给 p,要么把 a[0] 赋给 p,要么把 *a 赋给 p。前两个好理解,可为什么可以把 *a 赋给 p?因为 a==&(&a[0][0]),所以 a==(&(&a[0][0]))==&a[0][0]。

    除此之外你也可以把指针变量 p 定义成 int(*)[N] 型,这时就可以把 a 赋给 p,而且用这种方法的人还比较多,但我不喜欢,因为我觉得这样定义看起来很别扭。

    如果将二维数组名 a 赋给指针变量 p,则有(式六):

    p == a

    那么此时如何用 p 指向元素 a[i][j]?答案是以“行”为单位进行访问。数组名 a 代表第一个元素 a[0] 的地址,则 a+1 就代表元素 a[1] 的地址,即a+1==&a[1];a+2 就代表 a[2] 的地址,即 a+2==&a[2]……a+i 就代表 a[i] 的地址,即(式七):

    a+i == &a[i]

    将式六代入式七得:

    p+i == &a[i]

    等式两边作“*”运算得:

    *(p+i) == a[i]

    等式两边同时加上j行(式八):

    *(p+i) + j == &a[i][j]

    式八就是把二维数组名 a 赋给指针变量 p 时,p 访问二维数组元素的公式。使用时,必须先把 p 定义成 int()[N] 型,然后才能把二维数组名 a 赋给 p。那么怎么把 p 定义成 int()[N] 型呢?关键是 p 放什么位置!形式如下:

    > int (*p)[N] = a;    /*其中N是二维数组a[M][N]的列数, 是一个数字, 前面说过, 数组长度不能定义成变量*/
    

    下面编一个程序来用一下:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        int (*p)[4] = a;  //记住这种定义格式
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%-2d\x20", *(*(p+i)+j));  /*%-2d中, '-'表示左对齐, 如果不写'-'则默认表示右对齐;2表示这个元素输出时占两个空格的空间*/
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

    1  2  3  4
    5  6  7  8
    9  10 11 12
    

    如果把 &a[0][0] 赋给指针变量 p 的话,那么如何用 p 指向元素 a[i][j] 呢?在前面讲过,对于内存而言,并不存在多维数组,因为内存是一维的,内存里面不分行也不分列,元素都是按顺序一个一个往后排的,所以二维数组中的每一个元素在内存中的地址都是连续的,写一个程序来验证一下:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%#X\x20", &a[i][j]);
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

    0X18FF18 0X18FF1C 0X18FF20 0X18FF24
    0X18FF28 0X18FF2C 0X18FF30 0X18FF34
    0X18FF38 0X18FF3C 0X18FF40 0X18FF44
    

    我们看到地址都是连续的。所以对于数组 a[3][4],如果把 &a[0][0] 赋给指针变量 p 的话,那么:

    p == &a[0][0]; p + 1 == &a[0][1]; p + 2 == &a[0][2]; p + 3 ==
    &a[0][3]; p + 4 == &a[1][0]; p + 5 == &a[1][1]; p + 6 == &a[1][2];
    p + 7 == &a[1][3]; p + 8 == &a[2][0]; p + 9 == &a[2][1]; p + 10
    == &a[2][2]; p + 10 == &a[2][3];

    如果仔细观察就会发现有如下规律:

    p+i*4+j == &a[i][j]

    其中 4 是二维数组的列数。

    所以对于二维数组 a[M][N],如果将 &a[0][0] 赋给指针变量 p 的话,那么 p 访问二维数组元素 a[i][j] 的公式就是:

    p + i*N +j == &a[i][j]

    下面把验证式八的程序修改一下,验证一下上式:

    # include <stdio.h>
    int main(void)
    {
        int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
        int i, j;
        int *p = &a[0][0];  //把a[0][0]的地址赋给指针变量p
        for (i=0; i<3; ++i)
        {
            for (j=0; j<4; ++j)
            {
                printf("%-2d\x20", *(p+i*4+j));
            }
            printf("\n");
        }
        return 0;
    }
    

    输出结果是:

    1  2  3  4
    5  6  7  8
    9  10 11 12
    

    结果是一样的。两种方法相比,第二种方法更容易接受,因为把 &a[0][0] 赋给指针变量 p 理解起来更容易,而且 p 定义成 int* 型从心理上或从感觉上都更容易接受。

    展开全文
  • 名称:二维数组的几种表示方法 说明:常用的有以下几种二维数组表示方法: (1)、第一种是普通的二维数组表示方法。 (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组...
  • 二维数组元素表示方法

    千次阅读 2018-12-04 15:27:30
    二维数组元素表示方法 a // 数组首行的地址 a[0] //元素a[0][0]的地址。 二维数组可以看成是一维数组的数组,a[0] 可以认为是数组名,数组名代表数组首元素的地址 a[0] 代表 a[0][0]的地址 *(a+0) //元素...

    二维数组
    二维数组本质上是以数组作为数组元素的数组,即“数组的数组”。
    二维数组元素表示方法

     a                //  数组首行的地址
    
     a[0]            //元素a[0][0]的地址。 
     
     二维数组可以看成是一维数组的数组,(a[0] 、a[1] 、a[2] ) 。
     a[0] 可以认为是数组名,数组名代表数组首元素的地址, a[0] 代表 a[0][0]的地址
     
     *(a+0)        //元素a[0][0]的地址
     
    因为a是二维数组名,即是一维数组(a[0] 、a[1] 、a[2] )这三个元素的的首地址。
    a+0就是 a[0]的地址。
    *是取指针的值。
    那么*(a+0)就是取 a[0]的值。 a[0] 是一个数组名,他代表数组首元素a[0][0]的地址。
    
     a+1             // 数组第二行的地址
    
     a[1]+2       //  元素a[1][2]的地址        a[1] 是数组名,数组名是指向数组首元素的地址, a[1]+2  数组名+2 代表数组的第三个元素的地址。
     
     *(a+1)+2     //  元素 a[1][2]的地址       a+1  就是 a[1] 的地址 ,*(a+1)  就是 a[1][0]的地址, *(a+1)+2  就是 a[1][2]的地址。
    
     *(a[1]+2)      //元素 a [1][2] 的值         a[1] 是数组名。  a[1]+2  是 a[1][2]的地址,*(a[1]+2) 就是 元素 a[1][2]的值了。
    
    *(*(a+1)+2)     //元素 a[1][2]的值       a+1 代表 a[1]的地址,*(a+1) 代表 a[1][0] 的地址,*(a+1)+2 代表 a[1][2] 的地址。
    
    展开全文
  • 用C++语音实现一维数组二维数组写入txt,从txt中读取数据存到一维数组、二维数组,数组用指针表示
  • 数据结构 二维数组表示一维数组

    千次阅读 2013-08-03 11:31:51
    2、看数组代表矩阵的表示方法,引发了关于一维指针表示二维数组的方法和二维数组作为参数的问题 1)比如: a[3][4]是一个二维数组, 怎么定义一个指针p,使得它能替代数组名a? 比如对于访问一

    1、指针变量:是指其变量的值为内存的一个存储位置的数据类型变量(也就是指针的值指一个地址)

          动态内存分配:是指变量存储空间的分配过程是在程序执行时由操作系统提供可用的内存空间,因此内存可以按需分配,节省内存空间,但是同时需要手动释放内存,这跟静态内存分配的编译器自动释放空间不同,这也是动态分配的缺点。

        

    2、看数组代表矩阵的表示方法,引发了关于一维指针表示二维数组的方法和二维数组作为参数的问题

    1)比如:
    a[3][4]是一个二维数组,
    怎么定义一个指针p,使得它能替代数组名a?

    比如对于访问一个元素,如果用数组名,可以这样:*(*(a+i)+j)

    怎么定义然后赋值使得p 也可以这样取数据:*(*(p+i)+j)

    ?========================
    定义a为二维数组后,有三种成份:数组本身、3个一维数组(a的每一行对应一个一维数组)、12个数组元素,由此就有三种指针及对应的指针变量,&a和int (*p1)[3][4](没有实用意义)、&a[i]和int (*p2)[4](当i为0时,@a[0]可简化为a)、a[i][j]和int *p3;
    由于指针类型匹配是完全匹配,所以初始化形式必须严谨。
    上面有人写出
    int (*p)[4]=&a;
    则是类型不匹配,指向一维数组的指针变量指向了二维数组,尽管有些编译器只给warning、尽管有人认为指针值(二维数组a和一维数组a[0]的地址值)是相同的,事实是类型不匹配、错误
    还有人写出
    int *p = &a[0][0];/*或者int *p = a[0];*/
    这个指针变量是指向数组元素的,没有了数组结构信息,因此用该指针变量访问数组元素时,只能再提供列数信息进行地址计算:
    *(p+i*列数+j)
    结论是
    int (*p)[4]=a;/*或者int (*p)[4]=&a[0]*/
    是严格指针类型匹配的,且p具有数组结构信息(列数),可以直接访问数组元素
    *(*(p+i)+j)等价于a[i][j]
    提供一个小“伎俩”供分析用:指针(变量)左边一个*可等效替换为右边一个[],两个*可等效替换为。。。

    2)http://blog.csdn.net/xuleicsu/article/details/919801

    如何将二维数组作为函数的参数传递

      今天写程序的时候要用到二维数组作参数传给一个函数,我发现将二维数组作参数进行传递还不是想象得那么简单里,但是最后我也解决了遇到的问题,所以这篇文章主要介绍如何处理二维数组当作参数传递的情况,希望大家不至于再在这上面浪费时间。

    正文:

     

      首先,我引用了谭浩强先生编著的《C程序设计》上面的一节原文,它简要介绍了如何

    将二维数组作为参数传递,原文如下(略有改变,请原谅):

     

      [原文开始]

        可以用二维数组名作为实参或者形参,在被调用函数中对形参数组定义时可以指定所有维数的大小,也可以省略第一维的大小说明,如:

        void Func(int array[3][10]);

        void Func(int array[][10]);

        二者都是合法而且等价,但是不能把第二维或者更高维的大小省略,如下面的定义是不合法的:

        void Func(int array[][]);

        因为从实参传递来的是数组的起始地址,在内存中按数组排列规则存放(按行存放),而并不区分行和列,如果在形参中不说明列数,则系统无法决定应为多少行多少列,不能只指定一维而不指定第二维,下面写法是错误的:

        void Func(int array[3][]);实参数组维数可以大于形参数组,例如实参数组定义为:

        void Func(int array[3][10]);

        而形参数组定义为:

        int array[5][10];

        这时形参数组只取实参数组的一部分,其余部分不起作用。

      [原文结束]

      大家可以看到,将二维数组当作参数的时候,必须指明所有维数大小或者省略第一维的,但是不能省略第二维或者更高维的大小,这是由编译器原理限制的。大家在学编译原理这么课程的时候知道编译器是这样处理数组的:

      对于数组 int p[m][n];

      如果要取p[i][j]的值(i>=0 && i<m && 0<=j && j < n),编译器是这样寻址的,它的地址为:

      p + i*n + j;

      从以上可以看出,如果我们省略了第二维或者更高维的大小,编译器将不知道如何正确的寻址。但是我们在编写程序的时候却需要用到各个维数都不固定的二维数组作为参数,这就难办了,编译器不能识别阿,怎么办呢?不要着急,编译器虽然不能识别,但是我们完全可以不把它当作一个二维数组,而是把它当作一个普通的指针,再另外加上两个参数指明各个维数,然后我们为二维数组手工寻址,这样就达到了将二维数组作为函数的参数传递的目的,根据这个思想,我们可以把维数固定的参数变为维数随即的参数,例如:

     

        void Func(int array[3][10]);

        void Func(int array[][10]);

      变为:

        void Func(int **array, int m, int n);

     

      在转变后的函数中,array[i][j]这样的式子是不对的(不信,大家可以试一下),因为编译器不能正确的为它寻址,所以我们需要模仿编译器的行为把array[i][j]这样的式子手工转变为:

        *((int*)array + n*i + j);

        在调用这样的函数的时候,需要注意一下,如下面的例子:

        int a[3][3] =

        {

          {1, 1, 1},

          {2, 2, 2},

          {3, 3, 3}

        };

        Func(a, 3, 3);

     

      根据不同编译器不同的设置,可能出现warning 或者error,可以进行强制转换如下调用: 

        Func((int**)a, 3, 3);

      其实多维数组和二维数组原理是一样的,大家可以自己扩充的多维数组,这里不再赘述。写到这里,我先向看了这篇文章后悔的人道歉,浪费你的时间了。下面是一个完整的例子程序,这个例子程序的主要功能是求一个图中某个顶点到其他顶点的最短路经,图是以邻接矩阵的形式存放的(也就是一个二维数组),其实这个函数也是挺有用的,但是我们这篇文章的重点在于将二维数组作为函数的参数传递。


    展开全文
  • 如果对象是二维数组,则切片应当是x[:]的形式,里面有一个冒号,冒号之前和之后分别表示对象的第0个维度和第1个维度; 如果对象是三维数组,则切片应当是x[::],里面有两个冒号,分割出三个间隔,三个间隔的前、...
  • 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’在内
    在这里插入图片描述

    展开全文
  • java:二维数组方法

    2019-08-05 21:41:26
    文章目录二维数组方法二维数组二维数组的注意点: 初始化的方式是一样的,只是多加了一个[] 它的 内存存方式跟一维数组符方式是 一样 3 . 如果使用嵌套for循环遍历二维数组 长度的方式 外层的是 数组的...
  • 主要介绍了Swift中定义二维数组方法及遍历方法示例,本文直接给出代码示例,需要的朋友可以参考下
  • 二维数组的几种表示方法

    万次阅读 2017-04-30 21:55:24
    名称:二维数组的几种表示方法 说明:常用的有以下几种二维数组表示方法: (1)、第一种是普通的二维数组表示方法。 (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一...
  • 由此,当为了保存一个简单的[1,2,3]时,需要3个指针和3个整数对象用list来表示二维数组时,最外层的list中每个元素为一维数组,即a=[[1,2,3],[4,5,6],[7,8,9]]>>a[[1,2,3],[4,5,6],[7,8,9]]2. numpy.array可以专门...
  • c#二维数组表示方法

    万次阅读 2018-10-14 12:27:48
    //定义一个2行4列的二维数组   第二种表示方法: int[][]a=new int[2][];//后面中括号里面不能写数字。 a[0]=new int[2]; //表示第一行有两列,两个元素 a[1]=new int[3]; //表示第二行有三列,三个元素...
  • C++二维数组排序方法

    千次阅读 2020-05-07 15:48:09
    在这里注意一点的是:定义一个二维数组名为a,a是二级指针(地址的地址),*a表示二维数组a第一行a[0]的首地址,而要实现二维数组的排序为了避免出错我们取第一个元素的地址为:&a[0][0]。 C++二维数组冒泡排序 ...
  • 一维数组及其二维数组表示

    千次阅读 2018-11-03 12:12:49
    一维数组:是指由相同数据类型的数据 经过 在同一方向 有序排列,一维数组 结构单一,但却是二维数组、多维数组的集合 二维数组:一维数组的叠加,将一维数组看做是一个 “数据”,则将多个数据 依照一位数组 在 另...
  • 二维数组二维数组

    千次阅读 2018-06-26 05:50:40
    二维数组二维数组名   对于一位数组我们认识到其数据元素在内存中是按线性顺序依次排列的,且一维数组名的值是一个指针常量。那么二维数组在内存中又是怎么存储的,其数组名又有什么含义呢?   定义一个二维...
  • 二维数组是一页纸 三维数组是一本书 四维数组是书架 五维数组是图书室2201(好几个书架) 六维数组是图书馆某一层,2楼/3楼,好几个图书室 七维数组是整个图书馆 第N维数组是宇宙...................
  • 二维数组的结构决定了其能非常方便地表示计算机中的表,以第一个下标表示元素所在的行,第二个下标表示元素所在的列。下面简单了解一下二维数组,包括数组的声明和初始化。 创建二维数组 在 Java 中二维数组被看作...
  • 常用的有以下几种二维数组表示方法: (1)、第一种是普通的二维数组表示方法。 (2)、第二种是用一维数组来表示二维数组,从显示的元素地址可以看出,二维数组和一维数组表示二维数组在内存中的储存方式...
  • C++ 动态申请二维数组二维数组传参

    千次阅读 多人点赞 2018-12-15 11:59:41
    在C++中我们知道: int *ptr = new int; 这样可以动态分配一个int型指针 int *ptr = new int[3]; 这样可以动态分配一个一维数组 ...在尝试新的方法之前,我们需要首先了解二维数组在内存中的存储结构: ...
  • 二维数组 一维数组,我们看成一组盒子,每个盒子只能放一个内容。 ...一维数组的表示: myarray[ ] ...二维数组,我们看成一组盒子,不过每个盒子里还可以放多个盒子。...1. 二维数组的定义方法一 var myarr=new Arr
  • 用指针来表示二维数组方法

    千次阅读 2018-08-20 17:22:19
    1.类型说明 int *b; //定义一个int型指针变量 int *p[3]; //定义一个int型指针数组的变量 int (*c)[3] 和 int (*)[3]: //定义一个指向3个整形数组的指针变量 ...(1)用指针b表示二维数组时为: int ...
  • C++二维数组 | 二维数组输出0-6

    千次阅读 2020-12-01 09:44:12
    C++二维数组 C++的二维数组是指具有两个下标的数组,有些数据要依赖于两个因素才能惟一地确定,因此才会引入二维数组。 C++二维数组的定义 C++中定义二维数组的一般格式: 类型标识符 数组名[常量表达式] [常量...
  • C#二维数组拷贝到另一个二维数组

    千次阅读 2017-08-22 17:38:38
    这里解释一种拷贝二维数组方法,使用的仍然是Array.Copy的方法。 有如下数组: a=[1 2 3 4; 5 6 7 8; 9 10 11 12]; 要把这个数组的第一行和第三行拷贝到一个新的数组中,即有: b=[1 2 3 4; 9 10 11 12]; 代码如
  • 二维数组及遍历

    万次阅读 多人点赞 2019-09-12 17:41:23
    二维数组及遍历 概念 初始化方式详解 遍历 我在前面的博文详细说过一维数组的概念初始化方式及遍历,今天这篇博文,可以看过前面博文的会很容易接受,前置博文,请直接点击链接跳转。 什么是二维数组二维数组和...
  • 今天我们来聊聊二维数组及其二维数组的动态内存分配关知识。 1.数组的基本定义 我们都知道,数组是典型的线性存储,是一种最基本的存储表示方法, 把逻辑上相邻的元素存储在物理位置相邻的存储单元中,由此得到的...
  • 接下来到二维数组int[3][4]:首先,由二维数组的第二维[4]我们可以确定一排是4个苹果,这个跟刚才的一维数组一样。 那么之前的[3]是什么呢?于是int[3][4]相当于在你面前放了3排的苹果,一排4个。 再到三维数组int...
  • C语言二维数组指针(指向二维数组的指针)详解

    千次阅读 多人点赞 2020-05-27 17:43:22
    如有需要,请访问C语言二维数组指针(指向二维数组的指针)详解 二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例: int a[3][4] = { ...
  • 求一维数组和二维数组的维度方法

    千次阅读 2017-10-25 19:52:48
    一维数组大小的求法和二维数组大小的求法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 241,456
精华内容 96,582
关键字:

二维数组的表示方法