数组 订阅
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。 展开全文
数组(Array)是有序的元素序列。 [1]  若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。 [1]  这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。
信息
定    义
同类数据元素的集合
分    类
一维、二维(矩阵)、三维数组
中文名
数组
外文名
Array
数组产生来源
在C语言中, 数组 [2]  属于构造数据类型。一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。关于可变长数组(VLA)的问题:原来的C89标准中是不允许可变长数组出现的,但是在C99标准中,加入了对VLA的支持 [3]  ,但是支持的编译器不多,而且由于栈溢出的安全问题,没有太多的人敢用这个可变长数组,所以在C11标准中又把它规定为可选实现的功能了 [4]  。如果有过用其它语言编程的经历,那么想必会熟悉数组的概念。由于有了数组,可以用相同名字引用一系列变量,并用数字(索引)来识别它们。在许多场合,使用数组可以缩短和简化程序,因为可以利用索引值设计一个循环,高效处理多种情况。数组有上界和下界,数组的元素在上下界内是连续的。因为 Visual Basic对每一个索引值都分配空间,所以不要不切实际声明一个太大的数组。此处数组是程序中声明的变量数组。它们不同于控件数组,控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的;与控件数组不同的是,不能从一个数组的中部加载或卸载数组元素。一个数组中的所有元素具有相同的数据类型(在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样,比如在Visual Foxpro中的数组就并没这样的要求)。当然,当数据类型为 Variant 时,各个元素能够包含不同种类的数据(对象、字符串、数值等等)。可以声明任何基本数据类型的数组,包括用户自定义类型和对象变量。如果要用户输入的是一个数组,一般是用一个循环,但是在输入前也需要固定数组的大小。compact跟变长数组没有太大的关系,也应该用不到变长数组。因为一般的传数组到函数中就是传数组的地址和元素的个数的,那只是一个提示,不是要求。原型可以这样写(假设数组的元素是type):数组类型说明 在C语言中使用数组必须先进行类型说明。数组说明的一般形式为:类型说明符 数组名 [常量表达式],……; 其中,类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的常量表达式表示数据元素的个数,也称为数组的长度。数组就是一次性定义相同数据类型的一组变量数组定义。说明整型数组a,有10个元素。若要表示第10个元素,则使用a[9]。第一个则是a[0]。说明实型数组b,有10个元素,实型数组c,有20个元素。说明字符数组ch,有20个元素。1.数组是相同数据类型的元素的集合。2.数组中的各元素的存储是有先后顺序的,它们在内存中按照这个先后顺序连续存放在一起。3.数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如,a[0]表示名字为a的数组中的第一个元素,a[1]代表数组a的第二个元素,以此类推。对于VB的数组,表示数组元素时应注意:1下标要紧跟在数组名后,而且用圆括号括起来(不能用其他括号)。2下标可以是常量,变量,或表达式,但其值必须是整数(如果是小数将四舍五入为整数)。3下标必须为一段连续的整数,其最小值成为下界,其最大值成为上界。不加说明时下界值默认为1。
收起全文
精华内容
下载资源
问答
  • 数组
    千次阅读
    2020-12-26 18:31:41


    1 数组概述

    数组是一个集合,用于存放相同类型的数据元素。

    特点1:数组中的每个数据元素具有相同的数据类型
    特点2:数组占用一段连续的内存空间


    2 一维数组

    2.1 一维数组定义方式

    注1:数组名的命名规范与变量名命名一致,且数组名不能与变量重名。
    注2:数组的下标/索引从0开始。

    一维数组定义的3种方式:
    (1)数据类型 数组名[ 数组长度 ];

    注:定义数组时,若未给定数组元素的初始值,则必须指定初始数组长度,否则提示错误:“不允许使用不完整的类型”。

    (2)数据类型 数组名[ 数组长度 ] = { 值1,值2 ...};

    注:数组初始化时,若大括号{ }内的元素个数小于定义的数组长度,则剩余数组元素默认使用 0 填充

    (3)数据类型 数组名[ ] = { 值1,值2 ...};

    注:定义数组元素初始值时,数组可以不指定初始数组长度。

    示例

    int main() {
    	//定义方式1:数据类型 数组名[元素个数];
    	int arr[10];
    	//使用数组下标对数组元素进行赋值或访问
    	arr[0] = 10;
    	arr[1] = 20;
    	arr[2] = 30;
    
    	//定义方式2:数据类型 数组名[元素个数] =  {值1,值2 ,值3 ...};
    	//若大括号{ }内的元素个数小于定义的数组长度,则剩余数据默认使用0填充
    	int arr2[10] = { 100,90,80,70,60,50,40,30,20,10 };
    
    	//定义方式3:
    	//数据类型 数组名[] =  {值1,值2 ,值3 ...};
    	int arr3[] = { 100,90,80,70,60,50,40,30,20,10 };
    
    	return 0;
    }
    

    2.2 一维数组数组名

    2.2.1 一维数组名称的作用

    (1)统计整个数组的长度,例:sizeof(arr) / sizeof(arr[0]);

    数组占用内存空间大小:sizeof(arr)
    数组单个元素占用内存空间大小:sizeof(arr[0])
    数组长度sizeof(arr) / sizeof(arr[0])

    (2)获取数组在内存中的首地址,例:arr。

    获取数组首地址:arr&arr[0]

    注:arr&arr[0]数组首元素的地址 ;
    &arr整个数组的地址【地址值相同,含义不同】。


    2.2.2 一维数组名的2种特例情况

    一维数组名不表示数组首元素地址的两种特例
    sizeof(数组名):整个数组的大小;
    &数组名:整个数组的地址(地址值与首元素地址相同,但意义不同),表示数组指针

    注:其它情况下,一维数组的数组名均表示数组首元素地址,等价于相应的指针类型

    示例

    int main() {
    	//数组名用途
    	//1、获取整个数组占用内存空间大小
    	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    
    	cout << "整个数组所占内存空间为: " << sizeof(arr) << endl;
    	cout << "每个元素所占内存空间为: " << sizeof(arr[0]) << endl;
    	cout << "数组的元素个数为: " << sizeof(arr) / sizeof(arr[0]) << endl;
    
    	//2、获取到数组首地址
    	cout << "数组首地址为: " << (int)arr << endl;	//17431292 
    	cout << "数组中第一个元素地址为: " << (int)&arr[0] << endl;	//17431292
    	cout << "数组中第二个元素地址为: " << (int)&arr[1] << endl;	//17431296
    
    	//arr = 10;	//错误:数组名是常量,不可赋值
    	
    	return 0;
    }
    

    注1:数组名是常量,不能进行赋值,否则报错:表达式必须是可修改的左值
    注2:对数组名使用sizeof,可获取整个数组占内存空间的大小。


    2.3 一维数组的地址

    【以整型一维数组int arr[n]为例】

    (1) arr 等价于 &arr[0]

    1. 表示数组首元素地址,指向数组第1个元素,arr + 1&arr[0] + 1会跳过第1个元素【加上1个数组元素的字节数】,指向数组的下1个元素。
    2. arr&arr[0]的地址类型为int *类型,使用int类型的指针(指向数组首元素的指针)接收。

    (2) &arr

    1. 表示整个数组的地址,指向整个数组,&arr + 1会跳过整个数组【加上整个数组的总字节数】,如int *p = (int *)(&arr + 1),指针p指向数组的末尾。
    2. &arr的地址类型为int (*)[数组长度]类型,使用数组指针(指向数组的指针)接收。

    示例

    #include <iostream>
    using namespace std;
    
    int main() {
    	//一维数组
    	int arr[5] = { 1,2,3,4,5 };
    
    	/* 一维数组的地址与指针 */
    	int* p1 = (int *)(&arr + 1);	//&arr:整个数组的地址	//&arr + 1:指向数组的末尾处
    	int* p2 = (int*)(arr + 1);		//arr等价于&arr[0],类型为int *类型:数组首元素地址 
    	cout << p1[-2] << endl;		//4
    	cout << *p2 << endl;		//2
    
    
    	cout << arr << endl;			//009DFBB8
    	cout << *arr << endl;			//1【第1个元素值】
    	cout << arr + 1 << endl;		//009DFBBC	后移4字节【跳过1个元素】
    	cout << *(arr + 1) << endl;		//2【第2个元素值】
    		
    	cout << &arr[0] << endl;		//009DFBB8
    	cout << *(&arr[0]) << endl;		//1【第1个元素值】
    	cout << &arr[0] + 1 << endl;	//009DFBBC	后移4字节【跳过1个元素】
    	cout << *(&arr[0] + 1) << endl;	//2【第2个元素值】
    
    	cout << &arr << endl;			//009DFBB8
    	cout << *(&arr) << endl;		//009DFBB8
    	cout << &arr + 1 << endl;		//009DFBCC	后移4*5=20字节【跳过整个数组】
    	cout << *(&arr + 1) << endl;	//009DFBCC
    	
    	return 0;
    }
    

    2.4 冒泡排序

    作用: 常用的排序算法,对数组内元素进行排序,时间复杂度O(n2)
    步骤
    (1)比较相邻元素:若前一个元素大于后一个元素,则交换两元素;
    (2)针对每一对相邻元素重复执行步骤(1),执行完毕后,最大值置于数组的最末尾;
    (3)重复以上步骤,每次比较的次数减少1次,直至不再需要比较。

    示例: 使用冒泡排序对数组 { 4,2,8,0,5,7,1,3,9 } 进行升序排序。

    int main() {
    	int arr[] = {4,2,8,0,5,7,1,3,9};
    
    	int len = sizeof(arr) / sizeof(arr[0]);	//数组长度
    	int temp;
    	//外层循环:每轮对比的次数
    	for (int i = 0; i < len - 1; i++) {
    		//内层循环:进行比较的元素的索引位置
    		for (int j = 0; j < len - i - 1; j++) {
    			if (arr[j] > arr[j + 1]) {
    				temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    
    	cout << "升序排序后的数组为" << endl;
    	for (int i = 0; i < len; i++) {
    		cout << arr[i] << " ";
    	}
    
    	return 0;
    }
    

    3 二维数组

    二维数组的每个元素均为一个一维数组,可用矩阵的形式表示。

    3.1 二维数组定义方式

    二维数组定义的4种方式:
    (1)数据类型 数组名[ 行数 ][ 列数 ];
    (2)数据类型 数组名[ 行数 ][ 列数 ] = { {数据1,数据2} ,{数据3,数据4} };
    (3)数据类型 数组名[ 行数 ][ 列数 ] = { 数据1,数据2,数据3,数据4};
    (4)数据类型 数组名[ ][ 列数 ] = { 数据1,数据2,数据3,数据4};

    注1:第(2)种定义方式更直观,可提高代码的可读性;第(3)、(4)种根据二维数组的列数推断数组元素(可省略行数,不可省略列数)。
    注2:定义二维数组时,若已初始化数据,则可以省略行数

    示例:

    int main() {
    	int arr[2][3] = { {1,2,3},{4,5,6} };
    
    	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++) {
    		for (int j = 0; j < sizeof(arr[i]) / sizeof(arr[i][0]); j++) {
    			cout << arr[i][j] << " ";
    		}
    		cout << endl;
    	}
    
    	return 0;
    }
    

    3.2 二维数组数组名

    二维数组名称的作用
    (1)计算二维数组所占内存空间

    二维数组占用内存空间大小:sizeof(arr)
    二维数组第 i 行占用内存空间大小:sizeof(arr[i])
    二维数组某个元素占用内存空间大小:sizeof(arr[i][j])

    (2)计算二维数组的行数列数

    二维数组的行数:sizeof(arr) / sizeof(arr[0])
    二维数组的列数:sizeof(arr[0]) / sizeof(arr[0][0])

    (3)获取二维数组的首地址

    二维数组首地址:arr[0]&arr[0][0]
    二维数组第1个元素的地址: arr[0]&arr[0][0]
    二维数组第 0 行的地址arrarr[0]arr + 0 【或*(arr + 0)
    二维数组第 i 行的地址:arr[i]arr + i 【或*(arr + i)&a[0] + i

    注:arr[0]&arr[0][0]二维数组首元素的地址 ;
    二维数组名arr二维数组第0行首行)的地址,等价于arr[0]arr + 0

    (4)二维数组的其它地址

    二维数组第 i 行首元素的地址arr[i]arr + i*(arr + i)&a[0] + i
    二维数组第 i 行第 j 列元素的地址&arr[i][j]*(arr + i) + j

    (5)通过指针解引用访问或操作某元素:*(*(arr + i) + j)

    示例

    int main() {
    	int arr[2][3] = { {1,2,3},{4,5,6} };
    
    	//二维数组占用的内存空间
    	cout << "二维数组大小: " << sizeof(arr) << endl;			//24
    	cout << "二维数组一行大小: " << sizeof(arr[0]) << endl;		//12
    	cout << "二维数组元素大小: " << sizeof(arr[0][0]) << endl;	//3
    
    	//二维数组的行数与列数
    	cout << "二维数组行数: " << sizeof(arr) / sizeof(arr[0]) << endl;		//2
    	cout << "二维数组列数: " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;	//3
    
    	//地址
    	cout << "二维数组首行地址:" << (int)arr << endl;				//16053988
    	cout << "二维数组第一行地址:" << (int)arr[0] << endl;			//16053988
    	cout << "二维数组第一个元素地址:" << (int)&arr[0][0] << endl;	//16053988
    	
    	cout << "二维数组第二行地址:" << (int)arr[1] << endl;			//16054000
    	cout << "二维数组第二个元素地址:" << (int)&arr[0][1] << endl;	//16053992
    
    	system("pause");
    	return 0;
    }
    

    2.3 二维数组的地址

    【以整型二维数组int arr[m][n]为例】

    (1) arr[0] 等价于 &arr[0][0]

    1. 表示二维数组首元素地址,指向二维数组第0行第0列元素, arr[0] + 1等价于&arr[0][0] + 1会在二维数组第0行跳过第1个元素【加上1个数组元素的字节数】,指向二维数组第0行的下1个元素。
    2. arr[0]&arr[0][0]的地址类型为int *类型,使用int类型的指针(指向数组第0行首元素的指针)接收。如int *p = arr[0];int *p = &arr[0][0];

    (2) arr 等价于 &arr[0]

    1. 表示二维数组第0行地址,指向整个数组,arr + 1会跳过二维数组当前行【加上二维数组每行的总字节数】,如(arr + i)&a[0] + i,指向二维数组的下 i 行
    2. arr&arr[0]的地址类型为int (*)[数组列数]类型,使用数组指针(指向数组的指针)接收。如int (*p)[4] = arr;int (*p)[4] = &arr[0];

    (3) &arr

    1. 表示整个二维数组的地址,指向整个二维数组,&arr + 1会跳过整个二维数组【加上整个二维数组(共m * n个元素)的总字节数】,指向数组的末尾。
    2. &arr的地址类型为int (*)[数组行数][数组列数]类型,使用二维数组指针(指向数组的指针)接收。如int (*p)[3][4] = &arr;

    示例

    #include <iostream>
    using namespace std;
    
    int main() {
    	//二维数组3行4列
    	int arr[3][4] = {
    		{1,2,3,4},
    		{5,6,7,8},
    		{9,10,11,12}
    	};
    
    
    	cout << &arr << endl;			//00DAFB34	//整个二维数组的地址
    	cout << &arr + 1 << endl;		//00DAFB64	/后移4*3*4=48字节【跳过整个二维数组的全部12个元素】
    
    
    	cout << arr << endl;			//00DAFB34	//二维数组第0行的地址
    	cout << arr + 1 << endl;		//00DAFB44	后移4*4=16字节【跳过二维数组1行共4个元素】
    	cout << arr[1] << endl;			//00DAFB44	后移4*4=16字节【跳过二维数组1行共4个元素】
    	cout << &arr[0] + 1 << endl;	//00DAFB44	后移4*4=16字节【跳过二维数组1行共4个元素】
    
    	cout << *(arr + 1) << endl;		//00DAFB44	//二维数组第1行首元素的地址
    	cout << *(arr + 1) + 1 << endl;	//00DAFB48	后移4字节【跳过1个元素】
    
    
    	cout << arr[0] << endl;			//00DAFB34	//二维数组首元素地址
    	cout << arr[0] + 1 << endl;		//00DAFB38	后移4字节【跳过1个元素】
    
    	cout << &arr[0][0] << endl;		//00DAFB34	//二维数组首元素地址
    	cout << &arr[0][0] + 1 << endl;	//00DAFB38	后移4字节【跳过1个元素】
    
    
    
    	/* 数组指针,指向数组长度为4的int数组 */
    	//arr或&arr[0]:地址类型int(*)[4]
    	int (*p1)[4] = arr;		//正确
    	int (*p2)[4] = &arr[0];	//正确
    
    	//&arr:地址类型int(*)[3][4]
    	int(*p)[3][4] = &arr;	//正确
    
    	return 0;
    }
    
    更多相关内容
  • 数组指针和指针数组

    万次阅读 多人点赞 2019-09-17 16:39:06
    首先,理解一下数组指针和指针数组这两个名词: “数组指针”和“指针数组”,只要在名词中间加上“的”字,就知道中心了—— 数组的指针:是一个指针,什么样的指针呢?指向数组的指针。 指针的数组:是一个数组...

    首先,理解一下数组指针和指针数组这两个名词:

    “数组指针”和“指针数组”,只要在名词中间加上“的”字,就知道中心了——

    数组的指针:是一个指针,什么样的指针呢?指向数组的指针。

    指针的数组:是一个数组,什么样的数组呢?装着指针的数组。

    然后,需要明确一个优先级顺序:()>[]>*,所以:

    (*p)[n]:根据优先级,先看括号内,则p是一个指针,这个指针指向一个一维数组,数组长度为n,这是“数组的指针”,即数组指针;

    *p[n]:根据优先级,先看[],则p是一个数组,再结合*,这个数组的元素是指针类型,共n个元素,这是“指针的数组”,即指针数组。

    根据上面两个分析,可以看出,p是什么,则词组的中心词就是什么,即数组“指针”和指针“数组”。
     

    int *p1[5];
    int (*p2)[5];

    首先,对于语句“int*p1[5]”,因为“[]”的优先级要比“*”要高,所以 p1 先与“[]”结合,构成一个数组的定义,数组名为 p1,而“int*”修饰的是数组的内容,即数组的每个元素。也就是说,该数组包含 5 个指向 int 类型数据的指针,如图 1 所示,因此,它是一个指针数组。

                                           图1 

    其次,对于语句“int(*p2)[5]”,“()”的优先级比“[]”高,“*”号和 p2 构成一个指针的定义,指针变量名为 p2,而 int 修饰的是数组的内容,即数组的每个元素。也就是说,p2 是一个指针,它指向一个包含 5 个 int 类型数据的数组,如图 2 所示。很显然,它是一个数组指针,数组在这里并没有名字,是个匿名数组。

                                        

                                                                   图2 

    由此可见,对指针数组来说,首先它是一个数组,数组的元素都是指针,也就是说该数组存储的是指针,数组占多少个字节由数组本身决定;而对数组指针来说,首先它是一个指针,它指向一个数组,也就是说它是指向数组的指针,在 32 位系统下永远占 4 字节,至于它指向的数组占多少字节,这个不能够确定,要看具体情况。
     

    数组指针 (*p)[n]

    数组指针:是指针——指向数组的指针。

    看下面的例子进行理解

    #include "stdafx.h"
     
     
    int main()
    {
    	//一维数组
    	int a[5] = { 1, 2, 3, 4, 5 };
    	//步长为5的数组指针,即数组里有5个元素
    	int (*p)[5];
    	//把数组a的地址赋给p,则p为数组a的地址,则*p表示数组a本身
    	p = &a;
     
    	//%p输出地址, %d输出十进制
    	//\n回车
    	//在C中,在几乎所有使用数组的表达式中,数组名的值是个指针常量,也就是数组第一个元素的地址,它的类型取决于数组元素的类型。
    	printf("%p\n", a); //输出数组名,一般用数组的首元素地址来标识一个数组,则输出数组首元素地址
    	printf("%p\n", p); //根据上面,p为数组a的地址,输出数组a的地址
    	printf("%p\n", *p); //*p表示数组a本身,一般用数组的首元素地址来标识一个数组
    	printf("%p\n", &a[0]); //a[0]的地址
    	printf("%p\n", &a[1]); //a[1]的地址
    	printf("%p\n", p[0]); //数组首元素的地址
    	printf("%d\n", **p); //*p为数组a本身,即为数组a首元素地址,则*(*p)为值,当*p为数组首元素地址时,**p表示首元素的值1
    	printf("%d\n", *p[0]); //根据优先级,p[0] 表示首元素地址,则*p[0]表示首元素本身,即首元素的值1
    	printf("%d\n", *p[1]); //为一个绝对值很大的负数,不表示a[1]...表示什么我还不知道
     
    	
     
    	//将二维数组赋给指针
    	int b[3][4];
    	int(*pp)[4]; //定义一个数组指针,指向含4个元素的一维数组
    	pp = b; //将该二维数组的首地址赋给pp,也就是b[0]或&b[0],二维数组中pp=b和pp=&b[0]是等价的
    	pp++; //pp=pp+1,该语句执行过后pp的指向从行b[0][]变为了行b[1][],pp=&b[1]
     
    	int k;
    	scanf_s("%d", &k);
     
        return 0;
    }
    
    
     
    

    根据上面二维数组可以得出,数组指针也称指向一维数组的指针,所以数组指针也称行指针。

    指针数组 *p[n]

    指针数组:是数组——装着指针的数组。

    看下面的例子进行理解:

    #include "stdafx.h"
     
     
    int main()
    {
    	int a = 1;
    	int b = 2;
    	int *p[2];
    	p[0] = &a;
    	p[1] = &b;
     
    	printf("%p\n", p[0]); //a的地址
    	printf("%p\n", &a); //a的地址
    	printf("%p\n", p[1]); //b的地址
    	printf("%p\n", &b); //b的地址
    	printf("%d\n", *p[0]); //p[0]表示a的地址,则*p[0]表示a的值
    	printf("%d\n", *p[1]); //p[1]表示b的地址,则*p[1]表示b的值
     
     
    	//将二维数组赋给指针数组
    	int *pp[3]; //一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2],所以要分别赋值
    	int c[3][4];
    	for (int i = 0; i<3; i++)
    		pp[i] = c[i];
     
    	int k;
    	scanf_s("%d", &k);
     
        return 0;
    }
     
    

    最后,从上文来看:

    数组指针是一个指针变量,占有内存中一个指针的存储空间;

    指针数组是多个指针变量,以数组的形式存储在内存中,占有多个指针的存储空间。

     

    了解指针数组和数组指针二者之间的区别之后,继续来看下面的示例代码:

    int arr[5]={1,2,3,4,5};
    int (*p1)[5] = &arr;
    /*下面是错误的*/
    int (*p2)[5] = arr;

    不难看出,在上面的示例代码中,&arr 是指整个数组的首地址,而 arr 是指数组首元素的首地址,虽然所表示的意义不同,但二者之间的值却是相同的。那么问题出来了,既然值是相同的,为什么语句“int(*p1)[5]=&arr”是正确的,而语句“int(*p2)[5]=arr”却在有些编译器下运行时会提示错误信息呢(如在 Microsoft Visual Studio 2010 中提示的错误信息为“a value of type"int*"cannot be used to initialize an entity of type"int(*)[5]"”)?

    其实原因很简单,在 C 语言中,赋值符号“=”号两边的数据类型必须是相同的,如果不同,则需要显示或隐式类型转换。在这里,p1 和 p2 都是数组指针,指向的是整个数组。p1 这个定义的“=”号两边的数据类型完全一致,而 p2 这个定义的“=”号两边的数据类型就不一致了(左边的类型是指向整个数组的指针,而右边的数据类型是指向单个字符的指针),因此会提示错误信息。

    展开全文
  • 新手小白学JAVA 数组 数组工具类 二维数组

    万次阅读 多人点赞 2021-04-02 08:28:55
    1 数组 1.1 概念 数组Array,标志是[ ] ,用于储存多个相同类型数据的集合 想要获取数组中的元素值,可以通过脚标(下标)来获取 数组下标是从0开始的,下标的最大值是数组的长度减1 1.2 创建数组 数组的创建方式一般...

    1 数组

    1.1 概念

    数组Array,标志是[ ] ,用于储存多个相同类型数据的集合
    想要获取数组中的元素值,可以通过脚标(下标)来获取
    数组下标是从0开始的,下标的最大值是数组的长度减1
    数组结构

    1.2 创建数组

    数组的创建方式一般分为动态初始化和静态初始化

    1. 动态初始化
      int[] a = new int[5];
    2. 静态初始化
      int[] b = new int[]{1,2,3,4,5};
      int[] c = {1,2,3,4,5};

    1.3 创建数组过程分析

    程序创建数组 int[] a = new int[5]; 时发生了什么?

    1. 在内存中开辟连续的空间,用来存放数据,长度是5
    2. 给数组完成初始化过程,给每个元素赋予默认值,int类型默认值是0
    3. 数组完成初始化会分配一个唯一的地址值
    4. 把唯一的地址值交给引用类型的变量a去保存

    数组名是个引用类型的变量,它保存着的是数组的地址,不是数组中的数据

    1.4 数组的长度

    数组的长度用 length属性来表示,数组一旦创建,长度不可改变
    数组的长度允许为0

    1.5 练习:向数组中存入数据hello

    数组中存入hello示例
    创建包: cn.tedu.array
    创建类: TestCreateArray.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的创建*/
    public class TestCreateArray {
    	public static void main(String[] args) {
    		//1.创建数组
    		//1.1静态创建--创建的时候已经知道了每一个元素的值
    		char[] c1 = {'h','e','l','l','o'};
    		char[] c2 = new char[] {'h','e','l','l','o'};
    		
    		//1.2动态创建--知道了数组的长度,后面再具体赋值
    		char[] c3 = new char[5];//在内存中开辟一块连续的内存空间,用来存放5个字符
    		//1.2.2给c3数组动态的赋值
    		/**我们通过数组的下标来操作数组中的每一个元素,注意数组下标从0开始*/
    		c3[0] = 'h';//给数组中的第1个元素赋值
    		c3[1] = 'e';//给数组中的第2个元素赋值
    		c3[2] = 'l';//给数组中的第3个元素赋值
    		c3[3] = 'l';//给数组中的第4个元素赋值
    		c3[4] = 'o';//给数组中的第5个元素赋值
    		
    		//2.打印查看刚刚创建好的数组
    		System.out.println(c1);
    		System.out.println(c2);
    		System.out.println(c3);
    		
    		//3.创建String类型的数组,存放数据"a","b","c"
    		String[] s1 = {"a","b","c"};
    		String[] s2 = new String[] {"a","b","c"};
    		String[] s3 = new String[3];
    		s3[0] = "a";//给s3数组的第1个元素赋值为"a"
    		s3[1] = "b";//给s3数组的第2个元素赋值为"b"
    		s3[2] = "c";//给s3数组的第3个元素赋值为"c"
    		
    		/**char类型的数组底层中做了处理,可以直接打印数组中的具体元素
    		 * 除了char类型以外的数组想要查看数组中的具体元素,需要使用数组的工具类Arrays
    		 * 具体方式:Arrays.toString(数组名);
    		 * 注意Arrays使用时需要导包*/
    		//4.打印创建好的数组
    		System.out.println(s1);//打印出来的是数组的地址值
    		System.out.println(Arrays.toString(s2));
    		
    		//5.查看数组的长度--数组中存放的元素的个数
    		/**数组一旦创建,长度不可改变,如果想要增加/删除数组中的元素
    		 * 只能先创建一个新长度的数组,再将原来的数据复制过去*/
    		System.out.println(c1.length);
    		System.out.println(s1.length);
    		
    	}
    	
    }
    

    1.6 数组的遍历

    遍历:从头到尾,依次访问数组每一个位置,获取每一个位置的元素.形式如下:
    我们通过数组的下标操作数组,所以for循环变量操作的也是数组下标

    开始:开始下标0 结束:结束下标length-1 如何变化:++
    for(从下标为0的位置开始 ; 下标的取值 <= 数组的长度-1 ; 下标++){
    循环体;
    }`

    1.7 练习-1:输出每个月的天数

    创建类: TestArrayExec.java

    package cn.tedu.array;
    /**本类用于练习数组的遍历
     * 需求:输出一年中每个月份的天数
     * */
    public class TestArrayExec {
    	public static void main(String[] args) {
    		m ();//本方法用于输出每个月的天数,快速修复快捷键Ctrl+1
    	}
    	//打印需求:例如 1月有31天
    	public static void m () {
    		//1.创建数组用来存12个月的天数
    		int[] a = {31,28,31,30,31,30,30,31,30,31,30,31};
    		
    		//2.输出每个月的天数打印到控制台
    		//数组的遍历--通过循环的方式--操作的是数组的下标
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		//for(int i = 0 ; i <=a.length-1 ; i++) {
    		for(int i = 0 ; i <a.length ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			System.out.println((i+1)+"月有:"+a[i]+"天");
    		}
    	}
    }
    

    1.8 练习-2:遍历数组,存入1到10

    //需求:遍历数组,存入1-10
    	public static void m2() {
    		//1.创建数组--动态创建
    		int[] a = new int[10];
    		
    		//2.遍历数组,依次给每个位置赋值
    		//循环开始:a[0]--数组中的第一个元素
    		//循环结束:a[a.length-1]--数组中的最后一个元素
    		//如何变化:++
    		for(int i = 0 ; i <= a.length-1 ; i++) {
    			//a[i]--根据下标i来获取数组a中对应位置上元素的值
    			a[i] = i+1;
    		}//for循环结束
    		//3.在存入10个数据之后,打印a数组
    		System.out.println(a);//[I@15db9742
    		//除了char类型的数组,其他类型的数组想要查看具体内容需要借助工具类Arrays
    		//Arrays.toString(要打印的数组的名字)来查看数组中的具体内容
    		System.out.println(Arrays.toString(a));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    		
    	}
    

    1.9 练习-3:创建随机数组

    需求:创建数组,数组中的内容是100以内的随机数

    public static void m3() {
    	//1.创建数组--动态
    	int[] a = new int[10];
    	//2.遍历数组,给数组中的每个元素赋值
    	for(int i = 0 ; i <a.length ; i++) {
    		//100是自定义的数据,表示生成的随机整数的范围是[0,100)
    		a[i] = new Random().nextInt(100);
    		//a[i] = new Random().nextInt(100)+1;//取值范围前后都+1-->[1,101)
    	}
    	//3.使用数组的工具类查看数组中的元素
    	System.out.println(Arrays.toString(a));
    }
    

    2 数组工具类Arrays

    2.1 Arrays.toString(数组)

    把数组里的数据,用逗号连接成一个字符串[值1,值2]
    

    2.2 Arrays.sort(数组)

    对数组进行排序,对于基本类型的数组使用的是优化后的快速排序算法,效率高
    对引用类型数组,使用的是优化后的合并排序算法
    

    2.3 练习:练习Arrays.sort(数组)

    创建类: TestArraysSort.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于测试数组的工具类Arrays*/
    public class TestArraysSort {
    	public static void main(String[] args) {
    		//1.创建无序数组
    		int[] a = {21,96,75,23,25};
    		
    		//底层使用的排序算法是进行优化后的快速排序算法
    		Arrays.sort(a);//对无序数组进行直接排序
    		System.out.println(Arrays.toString(a));
    	}
    }
    

    2.4 Arrays.copyOf(数组,新的长度)

    把数组赋值成一个指定长度的新数组
    新数组的长度 大于 原数组, 相当于复制,并增加位置
    新数组的长度 小于 原数组, 相当于截取一部分数据

    2.5 练习:练习Arrays. copyOf(数组,新的长度)

    创建类: TestArraysCopyOf.java

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于练习数组的缩容与扩容*/
    public class TestArraysCopyOf {
    	public static void main(String[] args) {
    		//1.创建数组
    		int[] from = {1,2,3,4,5};//数组一旦创建,长度不可改变
    		
    		//2.1 数组的普通复制
    		/**copyOf()用于完成数组的复制,两个参数:
    		 * 参数1:要复制哪个数组
    		 * 参数2:新数组的长度*/
    		int[] to = Arrays.copyOf(from, 5);
    		System.out.println(Arrays.toString(to));
    		
    		//2.2数组的扩容
    		/**扩容:给数组扩大容量,新数组的长度>原数组的长度
    		 * 扩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中将元素复制到新数组,没有被覆盖的元素还是默认值0*/
    		int[] to2 = Arrays.copyOf(from, 10);
    		System.out.println(Arrays.toString(to2));
    		
    		//2.3数组的缩容
    		/**缩容:缩小数组的容量,新数组的长度<原数组的长度
    		 * 缩容思路:先创建对应长度的新数组,每个位置上都是默认值0
    		 * 然后从原数组中复制指定个数的元素到新数组中,类似于截取*/
    		int[] to3 = Arrays.copyOf(from, 3);
    		System.out.println(Arrays.toString(to3));
    		
    		//2.4指定首尾截取原数组中的元素
    		/**copyOfRange()用于完成数组的截取,3个参数:
    		 * 参数1:要截取哪个数组【原数组】
    		 * 参数2:从原数组的哪个下标开始
    		 * 参数3:到原数组的哪个下标结束
    		 * 注意:截取的元素包含开始下标处的元素,不包含结束下标处的元素*/
    		int[] to4 = Arrays.copyOfRange(from, 2, 4);
    		System.out.println(Arrays.toString(to4));
    	}
    }
    

    3 拓展之二维数组

    3.1 概念

    存放数组的数组,也就是说数组里存的还是数组的数据形式
    二维数组图示

    3.2 创建二维数组

    int[][] a = {{3,5},{7,9},{1,2}};
    –创建外部数组,长度是3
    –给每个外部数组的位置创建内部数组,每个内部数组的长度是2
    –给每个内部数组进行数据初始化
    –二维数组生成唯一的地址值
    –把地址值交给引用类型变量a来保存

    3.3 遍历二维数组

    for (int i = 0; i < a.length; i++) {//遍历外部数组
    for (int j = 0; j < a[i].length; j++) {//遍历内部数组
    System.out.println(a[i][j]);//依次打印二维数组中每个元素的值
    }
    }

    3.4 打印二维数组中的数据

    package cn.tedu.array;
    
    import java.util.Arrays;
    
    /**本类用于打印二维数组中的数据*/
    public class TestArrays2 {
    	public static void main(String[] args) {
    		//1.创建二维数组
    		//    3      5    
    		//a[0][0] a[0][1]
    		//    7       9
    		//[1][0] a[1][1] 
    		//    1       2      3
    		//a[2][0] a[2][1] a[2][2]
    		int[][] a = {{3,5},{7,9},{1,2,3}};
    		
    		//2.遍历二维数组
    		for (int i = 0; i < a.length; i++) {
    //			System.out.println(Arrays.toString(a[i]));
    			for (int j = 0; j < a[i].length; j++) {
    				//a[i][j]--根据外部数组的下标和内部数组的下标定位具体的元素
    				System.out.print(a[i][j]);
    			}
    			System.out.println();
    		}
    	}
    }
    
    展开全文
  • 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’在内
    在这里插入图片描述

    展开全文
  • 1.定宽数组 声明: int lo [0:15]; int lo [16]; //16个整数[0]...[15] int arr[0:7] [0:3]; // 等效与 int arr[8] [4]; 8行4列的数组 arr[8] [4]=1;// 设置数组的最后一个元素为1 知识1 – for 和 foreach 的...
  • c语言—数组详解(建议收藏)

    万次阅读 多人点赞 2021-07-06 21:12:15
    文章目录一、一维数组1.一维数组的创建和初始化(1).数组的创建(2).数组的初始化2.一维数组的使用3.一维数组在内存中的存储二、二维数组1.二维数组的创建和初始化(1).二维数组的创建(2).二维数组的初始化2.二维数组的...
  • 数组(Array)——数组介绍

    万次阅读 多人点赞 2020-02-12 16:30:39
    Arrays(数组) 数组是一个固定长度的存储相同数据类型的数据结构,数组中的元素被存储在一段连续的内存空间中。它是最简单的数据结构之一,大多数现代编程语言都内置数组支持。 为何使用数组存储一堆变量 与单独为...
  • Java 数组在内存中的存储 数组的常见操作

    万次阅读 多人点赞 2022-04-23 17:44:47
    Java 数组在内存中的存储 数组的常见操作
  • 数组(Array)是一系列具有相同类型的数据的集合,每一份数据叫做一个数组元素(Element)。数组中的所有元素在内存中是连续排列的,整个数组占用的是一块内存。以int arr[] = { 99, 15, 100, 888, 252 };为例,该...
  • 数组

    万次阅读 2017-10-06 14:39:56
    重点: 定义数组初始化数组遍历数组Arrays类 难点: 遍历数组二维数组及使用 ...数组类型 数组名[]=new 数组类型[数组长度]; 数组元素分配的初始值: 数组元素类型  默认初始值 byt
  • Java数组

    万次阅读 2022-03-24 18:52:18
    Java数组01 1.数组的定义 数组是相同类型数据的有序集合。 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。 其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。 二....
  • 指针数组数组指针——用指针访问数组方法总结

    万次阅读 多人点赞 2019-01-14 09:51:11
    1.数组元素的访问 2.通过指针访问数组 2.1 通过指针访问一维数组 2.2 通过指针访问二维数组 2.2.1 指向元素的指针 2.2.2 指向每一行的指针(指针数组方式) 2.2.3 指向整个数组的指针(数组指针方式) 3 总结...
  • JS数组常用的操作方法

    千次阅读 2021-11-04 10:23:21
    1. push() 将一个或多个元素添加到数组的末尾,并返回该数组的新长度。此方法修改原有数组。 var arr = ['a','b','c']; var ele = arr.push('d'); // ele结果为: 4; // arr数组被修改: ['a','b','c','d']; 2. pop()...
  • C语言数组——字符数组

    万次阅读 多人点赞 2020-02-17 20:59:51
    C语言目录 C/C++学习资源(百度云盘链接) 计算机二级资料(过级专用) C语言学习路线(从入门到实战) 编写C语言程序的7个步骤和编程机制 C语言基础-第一个C程序 ...C语言数组——一维数组 C语言数组——二维数...
  • JavaScript第一个分水岭——数组

    万次阅读 多人点赞 2022-02-21 23:08:50
    文章目录 一、初识数组 二、创建数组 使用Array对象创建数组 使用“[]”创建数组 三、数组的基本操作 获取数组长度 访问数组元素 元素的添加与修改 元素的删除 解构赋值 一、初识数组 数组构成:数组由一个或多个...
  • 数组指针和指针数组区别判断

    千次阅读 多人点赞 2022-03-24 18:33:59
    数组名 vs 数组名 2.指针数组 2.1指针数组的使用 3.数组指针 3.1数组指针的使用 结语: 前言 对于c语言的初学者来说,往往容易将数组指针和指针数组混淆,本文将对二者概念以及其用法进行详细解释。 1.&...
  • js数组常用方法

    万次阅读 多人点赞 2022-03-27 14:32:57
    js数组常用方法还挺多的,有17 18个,如果面试官问你这道题可不要只回答几个哟,那是会扣分的! 1. Array.push(),向数组的末尾添加一个或多个元素,并返回新的数组长度。原数组改变。 2. Array.pop(),删除并...
  • js中,在数组后添加数组

    千次阅读 2022-06-01 20:48:23
    1.我们要把arr2 变成一个适合splice的数组(包含splice前2个参数的数组) :在arr2前面插入2个元素:splice前2个参数(开始位置,删除几个元素) 2.把新得到的arr2整个数组做为参数传给arr1。 上面的代码相当于
  • 嵌套数组

    千次阅读 2021-01-02 16:18:24
    要注意多维数组和嵌套数组二者之间的区别,嵌套数组也叫数组数组,或者交错数组。通过以下方式来声明变量: int[3][2] arr; 就是数组中的每个元素也是数组,也就是数组里面也包含数组。如: //嵌套数组 char[]...
  • C++ 二维数组

    千次阅读 2021-09-04 16:13:13
    1、二维数组 二维数组就是在一维数组上,多加一个维度。 二维数组定义方式: 1)、数据类型 数组名[ 行数 ] [列数]; 2)、数据类型 数组名[行数][列数] = {{数据1,数据2,数据3},{数据4,数据5}}; 3)、数据类型 ...
  • Java数组详解

    万次阅读 2022-03-03 15:20:51
    数组是相同类型数据的有序集合、数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成,其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们。 2、数组声明创建: 首先必须...
  • 用C++语音实现一维数组二维数组写入txt,从txt中读取数据存到一维数组、二维数组数组用指针表示
  • java数组定义、使用、以及数组内存分析详解

    千次阅读 多人点赞 2019-10-04 22:17:30
    文章目录1、什么是容器2、什么是数组3、数组的三种定义定义方式一定义方式二定义方式三数组定义格式详解:4、数组的访问5、什么是内存5.1 Java虚拟机的内存划分5.2 数组在内存中的存储5.2.1 一个数组内存图5.2.2两个...
  • java数组完全解析(干货满满)

    万次阅读 多人点赞 2019-07-19 21:41:53
    1. 数组的定义和访问 1.1 容器概述 案例分析 现在需要统计某公司员工的工资情况,例如计算平均工资、找到最高工资等。假设该公司有50名员工,假如我没有数组的话,程序首先需要声明50个变量来分别记住每位员工的工资...
  • C语言数组——二维数组

    万次阅读 多人点赞 2020-02-07 14:58:35
    C语言目录 C/C++学习资源(百度云盘链接) 计算机二级资料(过级专用) C语言学习路线(从入门到实战) 编写C语言程序的7个步骤和编程机制 C语言基础-第一个C程序 ...C语言数组——一维数组 二维数组 前面介绍了...
  • C# 数组的定义

    千次阅读 2021-12-21 09:15:40
    C# 数组的声明 数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合,通常认为数组是一个同一类型变量的集合。 声明数组变量并不是声明 number0、number1、…、number99 一个个单独的变量,...
  • Java 数组定义和访问

    万次阅读 2022-04-23 16:50:51
    Java 数组定义和访问
  • python 数组添加数组_Python添加到数组

    万次阅读 2020-07-18 00:14:52
    python 数组添加数组Python doesn’t have any specific data type as an array. We can use List that has all the characteristics of an array. Python没有任何特定的数据类型作为数组。 我们可以使用具有数组...
  • 二维数组与指针、指针数组数组指针的用法

    万次阅读 多人点赞 2018-03-12 18:16:20
    二维数组和指针⑴ 用指针表示二维数组元素。要用指针处理二维数组,首先要解决从存储的角度对二维数组的认识问题。我们知道,一个二维数组在计算机中存储时,是按照先行后列的顺序依次存储的,当把每一行看作一个...
  • 06_星仔带你学Java之数组篇(一)

    万次阅读 多人点赞 2022-03-22 22:59:15
    详细的讲解了一维数组以及多维数组的各种操作。 本博客收录于华星详谈-学习中心。本学习中心收集了Java整个技术体系的所有技术要点。每篇博客后面或者知识点结尾都附带有面试题,提供给大家巩固本章内容。 为各位...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,986,129
精华内容 2,394,451
关键字:

数组

友情链接: 85375532zhiliudianji.rar