精华内容
下载资源
问答
  • 一维数组数组、字符串数组详解
    2021-10-19 21:56:21

    目录

    数组简述

    一维数组的定义

    一维数组的初始化

    二维数组的定义

    二维数组元素的引用

    多维数组

    字符数组和字符串

    字符数组

    字符串

    二维字符串数组


    数组简述

    • 数组是构造类型之一
    • 数组是具有一定顺序关系的若干个变量的集合,组成数组的各个变量称为数组的元素。
    • 数组中个元素的数据类型要求相同,用数组名和下标确定,数组可以是一维的也可以是多维的。

    一维数组的定义

    • 所谓一维数组是指只有一个下标的数组,它在计算机的内存中是连续存储的。
    • C语言中,一维数组的说名一般形式如下:
      <存储类型> <数据类型> <数组名> [<表达式>] 例如:int a[6];
      • 数组名表示内存首地址,是地址常亮,sizeof(数组名)是数组的内存空间。

    例:

    #include<stdio.h>
    int main (void)
    {
            int a[10];
            int i ;
            for(i = 0;i<10;i++)
                    printf("%p\n",&a[i]);
            return 0;
    }
    
    

    运行结果:

    0x7ffd148f8a20
    0x7ffd148f8a24
    0x7ffd148f8a28
    0x7ffd148f8a2c
    0x7ffd148f8a30
    0x7ffd148f8a34
    0x7ffd148f8a38
    0x7ffd148f8a3c
    0x7ffd148f8a40
    0x7ffd148f8a44
    
    •  注:程序运行是在linux系统下运行得到的结果,每个人运算得到的结果有可能都会不一致的。

      %p是打印地址信息的格式输出控制符

    一维数组的初始化

    • 初始化方式:在定义数组时,为数组元素赋初值
    •  int a[5] = {1,2,3,4,5};
    • 说明
    •  数组不初始化,其元素值为随机数
    •  对static数组不赋初值,系统会自动赋以0值
    •  只给部分数组元素赋初值

    对于第2条:

    static int a[5];
    等价于:
    a[0];a[1] = 0;a[2] = 0;a[3] = 0;a[4] = 0;
    

    例:数组只给部分元素赋初值,剩余元素以0代替

    #include<stdio.h>
    int main (void)
    {
            int a[10] = {1,5,6,8};//数组初始化部分元素
            int i ;
            for(i = 0;i<10;i++)
                    printf("%p,%d\n",&a[i],a[i]);//打印数组数值
            return 0;
    }
    

    运行结果:

    0x7ffc991407e0,1
    0x7ffc991407e4,5
    0x7ffc991407e8,6
    0x7ffc991407ec,8
    0x7ffc991407f0,0
    0x7ffc991407f4,0
    0x7ffc991407f8,0
    0x7ffc991407fc,0
    0x7ffc99140800,0
    0x7ffc99140804,0
    

    二维数组的定义

    • 定义方式:(声明时列数不能省略,行数可以省略)
    • 数据类型 数组名[常量表达式][常量表达式]

    例如:

    int a[3][3];
    float b[5][3];
    
    • 数组元素的存放顺序
    • 二维数组是按照行序优先进行存储的,因为内存是一维的,所以二维数组需要按照先后顺序进行存储。

    例如:int a[2][3]

    a[0][1]a[0][2]a[0][3]
    a[1][1]a[1][2]a[1][3]

    先存储a[0][1],再存储a[0][2]

    例:

    #include<stdio.h>
    int main(void)
    {
    	int a[2][3];
    	int i,j;
    	for(i= 0;i<2;i++)
    	{
    	    for(j = 0;j<3;j++)
    	        printf("%p ",&a[i][j]);//打印数组地址
    	    printf("\n");   
    	}
    	/*打印数地址以及数组长度*/
    	printf("%p %ld\n",a,sizeof(a));
    	/*打印第一行数组地址以及数据数组长度*/
    	printf("%p %ld\n",a[0],sizeof(a[0]));
    	/*打印第二行数组地址以及数据数组长度*/
    	printf("%p %ld\n",a[1],sizeof(a[1]));
    	return 0;
    }
    

    运行结果:

    0x7fff263db870 0x7fff263db874 0x7fff263db878 
    0x7fff263db87c 0x7fff263db880 0x7fff263db884 
    0x7fff263db870 24
    0x7fff263db870 12
    0x7fff263db87c 12
    
    

    二维数组元素的引用

    • 形式:数组名[下标][下标]
    • 二维数组元素的初始化
      • 分行初始化
      • 按元素排列顺序初始化

    分行初始化
    例:int a[2][3]={{1,2,3},{4,5,6}};

    按元素排列顺序初始化
    例:int a[2][3]={1,2,3,4,5,6};

    多维数组

    具有两个或两个以上下标的数组称为多维数组。

    例: int a[2][3][4];//是三维数组

    三维数组在实际的应用中已经很少了,在此就不再多做介绍。

    字符数组和字符串

    目标:

    • 掌握字符数字的用法
    • 掌握字符串的用法

    字符数组

    字符数组是元素的数据类型为字符类型的数组 char c[10],ch[3][4];

    字符数组的初始化

    • 逐个字符赋值 char ch[5] = {'B','o','y'};
    • 用字符串常量char ch[6] = {"hello"};char ch[] = "hello";

    例:

    #include<stdio.h>
    int main()
    {
        int i,n,n1;
        char ch[] = {'a','b','c'}; //字符
        char ch1[6] = {'a','b','c'};//字符串,空余的位数用'\0'表示
        
        n = sizeof(ch)/sizeof(char) //字符串长度
        for(i = 0;i < n;i++)
        {
            putchar(ch[i]);//循环打印字符
        }
        putchar('\n');
        n1 = sizeof(ch)/sizeof(char)  //字符串长度
        for(i = 0;i < n1;i++)
        {
            putchar(ch[i]);//打印字符串
        }
        putchar('\n');
        return 0;
    }
    

    运行结果:

    abc
    abc
    

    字符串

    • C语言中无字符串变量,用字符数组处理字符串

    • 字符串结束标志:'\0'。

    例 char str[] = "hello";

    表示字符长度为5,结尾以'\0'结束。

    二维字符串数组

    字符数组初始化

    char fruit[][10] = {"apple","orange","pear","peach","banana"};
    
    • 表示二维数组有5行,10列。

    #include<stdio.h>
    int main(void)
    {
        char fruit[][10] = {"apple","orange","pear","peach","banana"};
        int i,k;
        
        k = sizeof(fruit)/sizeof(fruit[0]);//表示一共有多少行
        
        for(i = 0;i < k;i++)
        {
            printf("%s\n",fruit[i]);
        }
        return 0;
    }
    

    运行结果:

    apple
    orange
    pear
    peach
    banana
    

    程序举例:字符串字符逆序

    #include<stdio.h>
    #include<string.h>
    #define N 20
    int main(void)
    {
    	char arr[N] = {0};
    	char temp;
    	int i = 0,j,n,k;
    	
    	printf("Plaese input a string!\n");
    	gets(arr);
    	n = strlen(arr);
    	j = n-1;
    	while(i<j)
    	{
    		temp = arr[i];
    		arr[i] = arr[j];
    		arr[j] = temp;
    		i++;
    		j--;
    	}		
    	puts(arr);
    	return 0;
    }
    

    运行结果:

    Plaese input a string!
    apple
    elppa
    
    更多相关内容
  • 二维数组当作参数的时候,必须指明所有维数大小或者省略一维的,但是不能省略二维或者更高维的大小,这是由编译器原理限制的。事实上,编译器是这样处理数组的:设有数组int a[m][n],如果要访问a[i][j]的值,...

    将二维数组当作参数的时候,必须指明所有维数大小或者省略第一维的,但是不能省略第二维或者更高维的大小,这是由编译器原理限制的。事实上,编译器是这样处理数组的:

    设有数组int a[m][n],如果要访问a[i][j]的值,编译器的寻址方式为:

    &a[i][j]=&a[0][0]+i*sizeof(int)*n+j*sizeof(int); //注意n为第二维的维数,

    因此,可以省略第一维的维数,不能省略其他维的维数。

    在定义二维数组的时候对其进行初始化,也可以省略第一维,编译器会根据你的初始化语句自动决定第一维度。

    下面介绍一个例子:

    #include#include#includeint main()

    {

    char a[10][10];

    memset(a,0,sizeof(a));

    printf("%d\n",sizeof(a));

    for(int i=0;i<10;i++)

    {

    for(int j=0;j< 10;j++)

    printf("%d ",a[i][j]);

    }

    system("PAUSE");

    return 0;

    }

    运行结果为:

    5645a4fbfc40e55b86ffafa7f376fef5.png

    以此也可以看出二维数组在内存中的分布情况,其实char a[10][10]和char a[100]在内存中的分布是一样的,sizeof的结果也是一样的。

    来源:

    http://blog.sina.com.cn/s/blog_615ec1630102uweg.html

    http://zhidao.baidu.com/link?url=dM6ejUOLpqiHlBG7FQd7hbAHUSD0Hs1Sjp6tpcOgpXvOJxBSCCq0e_92wu7eeJ4FCiYOH5RdMyFUVDQgE0ydslpTjv-BJqrQlts-IrnaIMq

    展开全文
  • 二维数组的创建和初始化2.1 二维数组的创建2.2 二维数组的初始化2.3 二维数组的使用三级目录 1. 一维数组的创建和初始化 1.1 数组的创建 数组是一组相同类型元素的集合。 数组的创建方式: type_t arr_name [const_...

    1. 一维数组的创建和初始化

    1.1 数组的创建

    数组是一组相同类型元素的集合。
    数组的创建方式:

    type_t   arr_name   [const_n];
    //type_t 是指数组的元素类型
    //const_n 是一个常量表达式,用来指定数组的大小
    

    数组创建的实例:

    //代码1
    int arr1[10];
    //代码2
    int count = 10;
    int arr2[count];//数组时候可以正常创建?
    //代码3
    char arr3[10];
    float arr4[1];
    double arr5[20];
    

    注:数组创建, [] 中要给一个常量才可以,不能使用变量。

    1.2 数组的初始化

    数组的初始化是指,在创建数组的同时给数组的内容一些合理初始值(初始化)。
    看代码:

    int arr6[];//全局默认初始值为0
    int main()
    {
    	//初始化
    	int arr1[20] = { 1,2,3 };//不完全初始化,剩余的默认初始化为0
    	int arr2[] = { 1,2,3 };
    	char arr3[] = "abc";
    	char arr4[] = { 'a','b','c'};
    	char arr5[] = { 'a',98,'c' };
    
    	return 0;
    }
    }
    

    1.3 一维数组的使用

    对于数组的使用我们之前介绍了一个操作符: [] ,下标引用操作符。它其实就数组访问的操作符。我们来看代码:

    #include<stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int i = 0;
    	//计算数组元素个数
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	for (i = 0; i < sz; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }
    

    1.4 一维数组在内存中的存储

    打印数组元素地址:

    #include<stdio.h>
    int main()
    {
    	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    	int i = 0;
    	//计算数组元素个数
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	for (i = 0; i < sz; i++)
    	{
    		printf("%p\n", &arr[i]);
    	}
    	return 0;
    }
    

    在这里插入图片描述
    数组随着下标增长,地址由低到高变化。可以看出相邻地址相差4,且连续,说明一维数组在内存中连续存储。

    2. 二维数组的创建和初始化

    2.1 二维数组的创建

    //数组创建
    int arr[3][4];
    char arr[3][5];
    double arr[2][4];
    

    2.2 二维数组的初始化

    //数组初始化
    int arr[3][4] = {1,2,3,4};
    int arr[3][4] = {{1,2},{4,5}};
    int arr[][4] = {{2,3},{4,5}};
    
    int main()
    {
    	int arr1[3][5] = { 1,2,3,4,5,6,7,8,9,10,11 };
    	int arr2[3][5] = { {1,2},{3,4},{4,5} };
    	int arr3[][5] = { {1,2},{3,4},{4,5} };//初始化之后行数可以省略,
    											//行数根据初始化来确定,但是列不能省略     
    	char ch1[4][6] = { 'a','b' };
    	char ch2[4][6] = { {'a'},{'b'} };
    	char ch3[4][6] = { "abc","def","qwe" };
    	
    	return 0;
    }
    

    2.3 二维数组的使用

    二维数组的使用也是通过下标的方式。

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

    在这里插入图片描述

    2.4 二维数组在内存中的存储

    像一维数组一样,这里我们尝试打印二维数组的每个元素。

    int main()
    {
    	int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,10} };
    	int i = 0;
    	for (i = 0; i < 3; i++)
    	{
    		int j = 0;
    		for (j = 0; j < 5; j++)
    		{
    			printf("&arr[%d][%d] = %p\n", i,j,&arr[i][j]);
    		}
    		printf("\n");
    	}
    	}
    

    在这里插入图片描述
    通过结果我们可以分析到,其实二维数组在内存中也是连续存储的。

    二维数组的行可以省略,但是列不能省略,二维数组也可以看成一维数组

    int main()
    {
    	int arr[3][5] = { {1,2,3},{4,5},{6,7,8,9,10} };
    	int* p = &arr[0][0];
    	int i = 0;
    	for (i = 0; i < 15; i++)
    	{
    		printf("%d ", *p);
    		p++;
    	}
    	return 0;
    }
    

    在这里插入图片描述

    3. 数组越界

    数组的下标是有范围限制的。
    数组的下规定是从0开始的,如果输入有n个元素,最后一个元素的下标就是n-1。
    所以数组的下标如果小于0,或者大于n-1,就是数组越界访问了,超出了数组合法空间的访问。
    C语言本身是不做数组下标的越界检查,编译器也不一定报错,但是编译器不报错,并不意味着程序就是正确的,所以程序员写代码时,最好自己做越界的检查。

    int main()
    {
    	int arr[5] = { 1,2,3,4,5 };
    	int i = 0;
    	for (i = 0; i <= 5; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }
    

    在这里插入图片描述

    4. 数组作为函数参数

    往往我们在写代码的时候,会将数组作为参数传个函数,比如:我要实现一个冒泡排序(这里要讲算法思想)函数将一个整形数组排序。
    那我们将会这样使用该函数:

    4.1冒泡排序:两两相邻的元素进行比较

    void Sort(int arr[],int sz)
    {
    	int i = 0;
    	for (i = 0; i <sz-1; i++)
    	{
    		int j = 0;
    		for (j = 0; j < sz - 1 - i; j++)
    		{
    			if (arr[j] > arr[j + 1])
    			{
    				int tmp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = tmp;
    			}
    		}
    	}
    }
    int main()
    {
    	int arr[] = { 34,45,7,8,23,45,89,900,100 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	//数组名传递给函数会降级成首元素地址
    	Sort(arr, sz);
    	int i = 0;
    	for (i = 0; i <= sz - 1; i++)
    	{
    		printf("%d ", arr[i]);
    	}
    	return 0;
    }
    

    在这里插入图片描述

    4.2什么是数组名

    //数组名就是首元素地址
    //有两个例外
    //1.当sizeof(数组名),数组名是整个数组
    //2.&数组名,数组名是整个数组,取出的数组的地址
    
    int main()
    {
    	int arr[10] = { 34,45,7,8,23};
    	printf("%p\n", arr);
    	printf("%p\n", &arr[0]);
    	printf("%p\n", &arr);
    	printf("--------------------------------\n");
    	printf("%p\n", arr+1);
    	printf("%p\n", &arr[0]+1);
    	printf("%p\n", &arr+1);
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 1.数组在c语言中,数组可以认为是相同类型数据的集合举个...需要的变量名也会很多,这个时候就需要考虑一下使用更科学的方法来储存数据#includeint a[5],这句话定义了数组,表示在内存中分配了可以保存5个整数...

    1.数组

    在c语言中,数组可以认为是相同类型数据的集合

    举个例子,当我们需要计算多个数据,比如说需要计算一个班级的数学成绩的平均分

    #include

    65d3a9fd26c8df4c88c54b3d9c5b93a0.png

    在这里定义了5个变量,代表5个学生的数学成绩,然后依次的给变量赋值,但是如果学生的成绩非常多,需要的变量名也会很多,这个时候就需要考虑一下使用更科学的方法来储存数据

    #include

    922fddb97f928a47d4dd8f8885f259bf.png

    int a[5],这句话定义了一个数组,表示在内存中分配了一个可以保存5个整数的空间

    1.1 数组的定义

    数组声明的语法:

    <数据类型> <数组名>[数组长度]

    比如:

    int a[3];
    float b[5];
    char c[12];

    声明数组之后就相当于在内存当中开辟了一个连续的空间,空间的大小取决于数组的长度与数组的元素个数(数组的长度)

    数组空间的大小 = 数组类型 ✖ 数组长度

    在使用数组的时候可以利用数组名[索引]的方式使用数组的元素

    #include

    bf8639cc186c5eb1105f531a9443b4bb.png

    在使用数组的时候需要注意,声明数组的时候中括号当中的数字代表数组的元素个数,使用数组元素的时候,中括号当中的数字代表数组元素的索引(或者称为下标)

    索引的取值范围是从0开始,数组索引的最大值是数组的长度-1

    987c586bbfd972f9b7e91cb72de02033.png

    在使用数组的时候一定要注意数组索引不要越界,也就是不要使用大于等于数组长度的索引

    1.2 数组的初始化

    声明数组之后可以给数组的元素赋值

    #include

    b62142c8acb2fb0456359bdb68e8ce15.png

    也可以在声明的同时初始化数组

    #include

    在这里使用 {元素1,元素2,....} 的方式来初始化数组

    c617c894b36bf7b878be98bfb34e716c.png

    结果是相同的

    如果在声明数组的时候对元素进行初始化,可以省略掉数组的长度,数组会自动按照初始化的长度来处理

    #include

    efd9b794f9a60b7172634417d0ec0aec.png

    如果数组的长度小于初始化元素的个数,那么多余的元素就会被舍去

    #include

    eec89145fc1fa9426f84dd4cf1d8f652.png

    这里数组只包含2个元素,第三个元素a[2]是一个错误的值,初始化数组只有前两个值被赋值到了数组里

    如果数组元素的个数大于初始化的数组,那么数组多余的值会被赋值为 0

    #include

    bc9747e712f9942500dd92e883f18d4a.png

    如果想把数组的元素全部初始化为0,我们就可以这样写

    #include

    4b1c8511959575cb7c9ba93246dedfa6.png

    需要注意的是,初始化数组一定要在数组声明的时候来完成,如果是初始化一个已经声明过的数组,程序就会出错

    #include

    5dec393af1a336a8af1b4d72c808001f.png

    2 使用循环来处理数组

    使用数组带来的最大的好处就是我们可以通过利用循环工具,来批量的处理数组当中的数据

    具体的做法就是把数组元素的索引当作循环的控制变量,通过索引自增,来遍历数组当中的元素

    #include

    77ab6d7d97ab9caa86983d18f454b023.png

    第一次循环i=0,打印的是a[0]的值,第二次循环i=1,打印的是a[1]的值,...,循环次数等于数组的元素个数

    在c99之后,还支持通过变量来动态的初始化数组

    例如我们可以设计一个程序,手动输入学生的成绩,计算学生成绩的平均分

    #include

    76ef30591db2b801565e06aa87ede96c.png

    数组的操作往往回合循环联系到一起,通过循环来遍历数组的元素,是在编写程序的时候经常会用到的手段

    3 二维数组

    有的时候处理的数据并不是线性的,而是有维度的,比如说可能会处理矩阵

    如果使用1维数组的话处理数据的位置就会有一些难度,因此我们可以使用二维数组

    二维数据可以想象为一个表格,有行和列

    e7cbc7f25e00c550a4e78978a44c3878.png

    我们建立数组

    int a[3][3];

    数组的第一个索引表示行号,第二个索引表示列号

    2ec6c72449163748647eaab1555db017.png

    那么 a[0][0]就是第一行第一列的元素为1,a[2][1]就是第三行第二列的元素为8

    3.1 二维数组的初始化

    声明二维数组

    <数据类型> <数组名>[第一维长度][第二维长度]

    比如说

    int a[2][3];

    a[2][3]就是一个2行3列的二维数组,使用的时候每个维度的索引都是由0开始,最大值为长度-1,所以 数组a的保存元素从 a[0][0]到a[1][2]

    f2b19351778ecd868dde45052af3432d.png

    我们也可以把二维数组想象为一个由一维数组组成的数组

    7a7dcad99b66160deb910b93304d2e04.png

    数组a由两个数组组成,a[0],a[1] 而a[0],a[1]又分别由三个整形数据组成

    所以我们可以使用大括号的方式来给数组初始化

    #include

    505b4dd39b99d7f0c8ac9e20e012210e.png

    数组的总大小除以整数的大小,就是数组包含的元素个数

    二维数组的大小除以其中包含的一维数组的大小,就是二维数组中包含的一维数组的个数,即数组的行数

    每个一维数组的大小除以整型数据的大小,就是一维数组的长度,即数组的列数

    在初始化二维数组的时候可以省略一维数组的大括号,会自动按顺序分配每个元素的位置

    #include

    cbd1f777a57b92ca0205e78b219cc8a4.png

    结果是一样的

    如果数据的个数是明确的,那么在声明数组的时候只要指明每个一维数组的长度,可以省略二维数组的长度,即只需要指明列数可以省略行数

    #include

    89e76abe46a0987637f8a642c018001a.png

    会自动计算行数

    如果数据不够填满数组,那么剩余的部分依然会补0

    #include

    6b948a9c9f36da4279cbea23b6855787.png

    如果要初始化所有元素都为0,就可以这样写

    #include

    a4543062084e0b28465cfbcc2d79bb0f.png

    3.2 使用循环遍历二维数组

    操作二维数组就需要使用嵌套的循环,外层循环的控制变量就是数组的第一维索引,内层循环的控制变量就是数组的第二维索引

    如果我们要输出数组的所有元素

    #include

    1deb0faae3304b99fc695abd00730276.png

    同样的也存在三维以上的数组,操作方式都是一样的

    展开全文
  • 一维数组二维数组
  • C语言入门系列之6.一维二维数组

    千次阅读 多人点赞 2020-04-27 10:18:31
    二维数组的定义格式为类型说明符 数组名[常量表达式][常量表达式];,可理解为元素是一维数组一维数组;引用形式是数组名[下标][下标],可以有多种方式进行初始化。利用二分法查找数据可以大大加快查询速率;内存...
  • 深入理解一维数组二维数组

    千次阅读 多人点赞 2021-10-08 10:49:50
    通过一些例子,加深对一维数组二维数组的理解
  • #include<conio.h>...char *fun(char (*a)[81], int num, char *max) { int i=0; max=a[0]; for(i=0;i<num;i++) {if(strlen(max)<strlen(a[i])) max=a[i];} return max; } voi.
  • 开始我以为掌握了java的数组,类推至c++,不用多学的,可自己写的时候老是犯错误,还是得仔细学学,下面主要讲关于c++一维数组二维数组的一些细节内容。 二、一维数组 定义:一维数组用于表示由固定多个 ...
  • 数组(Array)是在内存中连续存储的具有相同类型的组数据的集合。 数组组相同类型元素的集合。*这些元素在内存中依次连续挨着存放。 数组中,若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成...
  • 一、二维数组的介绍 当数组元素具有两个下标时, ... 数据类型是数组全体元素的数据类型, 数组名用合法的标识符表示, 两个整型常量表达式可以理解为分别代表行数和列数, 与一维数组相同, 数组元素的下标一律从 0 开始...
  • Presentation on theme: "第7章 数组 本章要求: 1、掌握C语言数组在内存中的存储形式 2、掌握一维数组二维数组的定义及使用 3、掌握使用数组的方法"— Presentation transcript:第7章 数组 本章要求: 1、掌握...
  • 一维数组的创建和初始化 数组的创建: 数组是一组相同类型元素的集合。数组的创建方式: type_t arr_name [const_n]; // type_t 指数组的元素类型 // arr_name 数组的名称 // const_n 这是一个常量表达式,用来...
  • 一维数组二维数组的定义及用法

    万次阅读 多人点赞 2018-06-08 19:03:01
    一维数组的定义 类型说明符 数组名 [常量表达式]; 在此说明:常量表达式必须是常量和常量符号。常量表达式定义了数组的长度。在宏定义中#define定义一个符号常量,则这个符号常量可以用来声明数组的个数 #define...
  • 二维数组降维为一维数组

    千次阅读 2019-10-02 19:25:07
    // // main.cpp // 二维数组 // 1.一个二维数组就像是若干个相同的数组放在一起,这对于存储多组...处理二维数组的时候直接当作一维数组可以了每一行都是一个一维数组。 // 5.二维数组在存储的时候,是按照一行...
  • C语言二维数组字符串的赋值

    千次阅读 2021-05-19 09:07:13
    1、在被调用函数的形参数组定义可以省略一维的大小,第二维不可省略,如下:void fun(int a[5][20]); //合法void fun(int a[][20]); //合法void fun(int a[5][]); //不合法void fun(int a[][]); //不合法将二维...
  • 一维数组二维数组知识点总结

    千次阅读 2019-11-04 16:28:40
    一维数组二维数组知识点总结 字符数据存储的基本知识 数组指针和指针数组的区别 数组指针:int(*p)【】,首先因为 *p放在括号内优先结合,所以先是一个指针,然后和【】起作用。 所以数组指针是指针,指向...
  • 全班40人,按照定义变量的思维,需要定义40个double类型的数据变量,每次从40个变量中找个变量,操作很麻烦,java中可以定义以和数据类存放40个人的成绩,使用数据类型存储​数组定义:它是相同数...
  • C语言- 数组-一维数组/二维数组 数组的创建 数组初始化 数组的使用 数组的内存方式
  • 一维二维数组创建和初始化等有关知识点
  • 数组 数组组相同类型元素的集合 1 数组的创建 int arr[5]; char ch[10]; int n=10; int arr[n]; /*C99标准之前不支持使用变量, 只能是常量,C99中增加了变长 数组的概念,允许数组大小是变 量,想这么...
  • 一维数组形式: int arr1[10] = {1,2,3,4}; char arr2[5] = {‘a’,98}; char arr3[] = “abc”; 关于数组sizeof和strlen的区别: sizeof是计算数组或变量在内存中所占的空间大小,如arr3在内存中的存储形式为 a b ...
  • 目录数组一、数组的概述一维数组的使用1、声明2、初始化3、引用4、默认初始化值5、操作数组时内存的状态5.1、初始化过程内存状态5.2、内存分析三、多维数组的使用1、概念2、初始化3、内存分析四、数组中涉及到的...
  • 二维字符数组中为什么定义字符串是个?“hello world”在C语言中代表什么?为什么只能在定义时才能写成char a[10]="jvssj";在函数体里就不可以这样赋值了,只能调用库里的函数 strcpy(a,"jvssj"),究竟是为...
  • # 1.C语言一维数组的定义和引用C语言支持一维数组和多维数组。如果一个数组的所有元素都不是数组,那么该数组称为一维数组。## 一维数组的定义方式在C语言中使用数组必须先进行定义。一维数组的定义方式为:类型说明...
  • 01 一维数组 数组,就是把相同数据类型的变量组合在一起而产生的数据集合。 数据就是从某个地址开始连续若干个位置形成的元素集合。 数据类型 数组名[数组大小]; 数组大小必须是整数常量,不可以是变量。 一维...
  • 数组一维二维

    千次阅读 2020-12-08 15:30:47
    二维数组的创建和初始化(1)二维数组的创建(2)二维数组的初始化3.数组作为函数的参数 1.一维数组的创建和初始化 (1)一维数组的创建 数组: 是一组相同类型元素的集合 int arr[10]; #define N 10 int main() { int...
  • 二维数组定义时进行初始化则第个[]可以不填。第二个[]不能省略。 示例: int buff[][3]={1,2,3,4,5,6};//每行有3个元素 Int buff2[][3]={ {1,2,3}, {4,5,6}, }; 二维数组遍历 示例: int main

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,795
精华内容 7,118
关键字:

二维数组可以省略一维char a[] [3]

友情链接: stc51controller.rar