数组概念、定义、初始化

1、数组的概念

数组是由若干个相同类型的变量在内存中有序存储的集合

int a[10];//定义了一个整型的数组a，a是数组的名字，一维数组名是数组首元素地址&a[0]

数组中有10个元素

每个元素的类型int类型，而且在内存中是连续存储

这十个元素是a[0]~a[9]

a[0]~a[9]在内存中连续顺序存储

2、数组的分类

2.1、按元素的类型分类

1、字符数组：

即若干个字符变量的集合，数组中每个元素都是字符型的变量

char a[10];

a[0]~a[9]

2、短整型数组

short int a[10];

3、整型数组

int a[10];

4、长整型数组

long int a[10];

5、浮点型数组

float a[10];

6、指针数组

char *a[10];

int *a[10];

7、结构体数组

struct stu a[10]; //struct stu a;定义了一个结构体变量a

2.2按维数分

1、一维数组

int a[10] //类似地里一排萝卜坑，一个坑对应一个萝卜

2、二维数组

int a[2][5];//类似于地里有两个大坑，一个大坑放5个萝卜。

//二维：行列，2行5列

//由几个一维数组组成

实质：就是一维数组（在计算机存储空间中就没有二维的说法，还是一个连续一个的连续存储）

3、多维数组

int a[3][5][6]；//三块地，每块地有5个大坑，一个大坑放6个萝卜

三维数组是由多个相同的二维数组构成

依次类推.......

3、数组的定义

定义一个数组，在内存中分配空间

1、一维数组的定义

格式：

数据类型数组名 [数组元素个数]

int a [10];

char b [5];//定义了5个char类型变量的数组b

5个变量分别为b[0],b[1],b[2],b[3],b[4]

在数组定义的时候可以不给出数组元素的个数，根据初始化的个数来决定数组的大小

2、二维数组的定义

格式：

数据类型数组名[行的个数][列的个数]

int a[4][5];

定义了20个int类型变量，分别是

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

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

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

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

3、多维数组定义

int a[3][4][5];

依次类推.....

拓展：二维数组在定义的时候，可以不给出行数，但是必须要给出列数，二维数组的大小由初始化的行数决定

4、数组的初始化

定义数组的时候，顺便给数组的元素赋初值，即开辟空间的同时并且给数组元素赋值

1、一维数组的初始化

（1）全部初始化

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

代表意思：a[0]=1,a[1]=2,a[2]=3,a[3]=4,a[4]=5;

（2）部分初始化

int a[5]={2,3,4};初始化赋值不够后面补0

代表意思：a[0]=2,a[1]=3,a[2]=4,a[3]=0,a[4]=0;

#include<stdio.h>
void main()
{int a[5]={2,3,5};int i;             for(i=0;i<5;i++){ printf("a[%d]=%d\n",i,a[i]);}
}

2、二维数组初始化

（1）全部初始化

int a[2][2]={{1,2},{3,4}};

代表意思：a[0][0]=1,a[0][1]=2,

a[1][0]=3,a[1][1]=4

（2）部分初始化

int a[2][2]={{1,2},{3}};

代表意思：a[0][0]=1,a[0][1]=2,

a[1][0]=3,a[1][1]=0

全部初始化：

int a[2][3]={1,2,3,4,5,6};

部分初始化：

int a[2][3]={1,2,3};

5、数组元素的引用方法

1、一维数组元素引用

数组名[下标]；//下标就带代表数组元素在数组中的位置

int a[5];

a[0],a[1],a[2],a[3],a[4];

2.二维数组元素引用

数组名[行下标][列下标]

int a[4][5];

a[0][0],a[0][1],a[0][2],a[0][3],a[0][4]

a[1][0],a[1][1],a[0][2],a[0][3],a[1][4]

a[2][0],a[2][1],a[2][2],a[2][3],a[2][4]

a[3][0],a[3][1],a[3][2],a[3][3],a[3][4]

3、字符数组

char c1[]={‘c’,’ ’,’p’,’f’,’o’,’g’};

char c2[]=”c pfog”;

char a[][5]={

{‘b’,’a’,’s’,’i’,’c’},

{‘d’,’b’,’a’,’f’,’g’}

};

char a[][6]={“hello”,”world”};

字符数组的引用

用字符串方式赋值比字符逐个赋值要多占1个字节，用于存放字符串结束标志’\0’;
上面的数组c2在内存中的实际存放情况为：

3、由于采用了’\0’标志，字符数组的输入输出将变得简单方便

总结

1、数组初始化以及赋值：

写法1：int a[5]={1,2,3,4,5};//列表初始化，完全初始化

写法2：int a[5]={1,2};//部分初始化，其他没有初始化为0

写法3：int a[]={1,3};//[]不写元素个数，只能在定义数组时立马初始化才可以

写法4：int a[]; //错误写法

a[0]=56;

char b[];//错误写法

b[0]=’g’;

写法5：int a[3];//定义了数组，但是没有初始化

a[0]=45; //正确

a[1]=56; //正确

a[3]=90; //错误，数组越界

写法6：面试题会出现，实际开发基本不会这样写

把数组前面50个元素初始化为100，后面50个初始化为200

int b[100]={[0 ... 49]=100,[50 ... 99]=200};

注意：... 左右两边必须要有空格

2、数组的下标

从0开始，使用时不要越界

两个作用：（1）通过数组名下标去访问数组元素

（2）通过数组名下标去给数组元素赋值

数组越界所带来的危害（容易引起段错误）

例：int a[10];下标的范围0-9之间

1.往前越界

a[-2];//访问a[0]前面8个字节的地址里面的数据

2.往后越界

a[11]；//访问a[9]后面8个字节的地址里面的数据

段错误：Segmentation fault

由于程序员在代码中访问了非法地址导致的（经常见于指针没有初始化（野指针），数组越界，指针乱指）

3、数组的存储

数组在计算机中是连续存储（数组的地址是紧挨着的）

4、数组的大小

sizeof();//求任何类型数据的大小

strlen();//专门用来求字符串的实际长度

头文件：#include<string.h>

size_t strlen(const char *s);

返回值：字符串实际长度

参数：s--->你要计算的字符串长度

原理：计算字符串长度的时候，遇到\0认为字符串结束了

%s在打印字符串的时候，也是遇到\0认为字符串结束了

总结：（1）sizeof是运算符，strlen是函数

（2）sizeof适用范围广，strlen只能求字符串实际的长度

（3）sizeof求字符串长度的时候，会把\0算上

strlen求字符串长度的时候，不会把\0算上

字符串在计算机中的存储方式

字符串默认有一个结束标记\0(ascii值就是0)

char buf[10]=”hello”;//编译器会自动给字符串的末尾添加\0,不需要程序员操心

char buf[5]=”hello”;//本来编译器想自动添加\0,可惜你不给机会

注意的特例：

char buf[]={‘h’,’e’,’l’,’l’,’o’};//sizeof求出来是5，没有加\0

char buf[]=”hello”;//求出来是6（加上了\0）

7.空字符串，’A’和”A”的区别

char buf[10]=” ”;//空字符串

‘a’;//字符a 单个字符

“a”;//字符串a a和\0

8.数组重复使用，清空数组

（1）char类型的数组重复使用

char buf[10];

while(1)

{

scanf(“%s”,buf);假如第一次输入的字符串长一点，下一次输入的字符串短一点，scanf都会自动帮你在字符串后面添加\0保存到buf,短一点的字符串覆盖字符串的前面部分，并且有个\0在后面 “abcdefg\0” ----->“abc\0”--->““abc\0efg\0”---->显示只显示abc

}

（2）清空数组

数组先清空后使用（数组不清空，里面是一些随机数）

bzero

头文件：#include<string.h>

函数原型：void bzero(void *s,size_t n);

参数1：s-------->数组名

n--------->数组的大小

例子：int a[10];

bzero(a,10);

2)int buf[10]={0};//把数组清零，利用了部分初始化的原理，其余没有初始化的默认都是0

char buf[5]=0;

9.数组的怪异写法（了解）----->笔试

int buf[10];

0[buf]=11;//等价于buf[0]=11;

二维数组初始化以及赋值

写法1：int a[5][6]={45,67,98};//部分初始化正确

写法2：int a[][6]={78,90}; //正确

写法3：int a[][]={23,45};//错误

写法4：int a[5][]={12,34};//错误

写法5：int a[5][6]={{5},{8,9},{12,34}};//正确，分组初始化

写法6：int a[5][6]={{5},{8,9},12,34};//正确，分组初始化

写法7：int a[3][4]={{12,13},{14},{15,16,17}};//正确

int a[3][4]={12,13,{14},15,16,17};//错误，不满足从左至右连续分组

int a[3][4]={{12,13},{14},15,16,17}; //正确

int a[3][4]={{12,13},{14},{15,16},17};//错误，分组分多了，分了四组

写法8：int a[5][6]; //分别赋值

a[0][0]=77; //正确

a[3][4]=66; //正确

数组概念、定义、初始化相关推荐

c语言一维数组字符串数组初始化,一维数组的定义、初始化和引用
一维数组的定义.初始化和引用一维数组的定义.初始化和引用 1.一维数组的定义方式为: 类型说明符数组名［常量表达式］ (1)数组名的命名方法与变量名相同,遵循标识符命名规则; (2)数组是用方括号 ...
数组的定义、初始化和使用
数组的概念: 数组是在内存中连续存储的具有相同数据类型的一组数据的集合. 一维数组的定义: 定义方式: 类型说明符数组名[常量表达式]; 例如: int a[5]; 一维数组初始化: 一维数组的初始 ...
C语言二维数组的定义、初始化、赋值
二维数组的定义二维数组定义的一般形式是: dataType arrayName[length1][length2]; 其中,dataType 为数据类型,arrayName 为数组名,length1 ...
C语言二维数组的定义、初始化以及数组元素的引用
二维数组定义的一般形式为: 类型说明符数组名[常量表达式 ][常量表达式] 例如:float a[3][4],b[5][10]; 是定义a为3行4列的数组,b为5行10列的数组. 注意不可以写成fl ...
qt 二维数组初始化_C语言二维数组的定义、初始化、赋值
上节讲解的数组可以看作是一行连续的数据,只有一个下标,称为一维数组.在实际问题中有很多数据是二维的或多维的,因此C语言允许构造多维数组.多维数组元素有多个下标,以确定它在数组中的位置.本节只介绍二维 ...
JAVA（4）学习笔记：JVM虚拟机上的栈、大驼峰命名法和小驼峰命名法、实参和形参、重载方法、调用栈、递归练习（汉诺塔+斐波那契数列）、数组的定义、数组的初始化、增强for循环。
接上次的博客:JAVA学习(3)--知识整理以及一些简单程序(猜数字游戏.求各种自幂数.求出一个数字的二进制位中1的个数.获取一个数二进制序列中所有的偶数位和奇数位.求公约数的多种实现方式.输入密码程 ...
【C 语言】数组 ( 数组本质 | 数组长度定义 | 数组初始化 | 编译时初始化 | 显式初始化 - 重置内存 )
文章目录一.数组本质二.数组长度定义三.数组初始化 1.编译时初始化 2.显式初始化 ( 重置内存 ) 一.数组本质数组本质 : 类型角度 : 从数组元素类型角度分析 , 数组是相同类型 ...
变量初始化赋值_java数组的定义及初始化
数组数组有两种定义形式. 数组的定义: 这一种形式使用的频率高,推荐使用. int［］ ints={1,2,3}; 第二种形式(容易使人混淆因为在开发中可能把这个看成一个数组类型而不是变量名) in ...
1.2 一维数组的定义、赋值和初始化
当数组中每个元素都只带有一个下标时,这种数组就是"一维数组".一维数组(one-dimensional array)实质上是一组相同类型数据的线性集合,是数组中最简单的一种数组. ...

数组概念、定义、初始化

总结

数组概念、定义、初始化相关推荐

最新文章

热门文章