C语言二维数组

骑猪看日落 2022-08-19 13:17 222阅读 0赞

\# 二维数组基本概念

\#\#1.二维数组的基本概念

\- 所谓多维数组就是一个一维数组的每个元素又被声明为一 维数组,从而构成二维数组. 可以说二维数组是特殊的一维数组。

\- 示例

+int a\[2\]\[3\]

+可以看作由一维数组a\[0\]和一维数组a\[1\]组成，这两个一维数组都包含了3个int类型的元素

\#\#2.二维数组的定义

\- 格式:

+数据类型 数组名\[一维数组的个数\]\[一维数组的元素个数\]

\*  数据类型 数组名\[行数\]\[列数\]

+其中"一维数组的个数"表示当前二维数组中包含多少个一维数组

+其中"一维数组的元素个数"表示当前前二维数组中每个一维数组元素的个数

\#\#3.二维数组的初始化

\- 二维数的初始化可分为两种:

+定义的同时初始化

\* 按行分段赋值

\* 按行连续赋值

+先定义后初始化

\- 定义的同时初始化

\- 先定义后初始化

int a\[2\]\[3\];

a\[0\]\[0\] = 80;

a\[0\]\[1\] = 75;

a\[0\]\[2\] = 92;

a\[1\]\[0\] = 61;

a\[1\]\[1\] = 65;

a\[1\]\[2\] = 71;

\- 按行分段赋值

int a\[2\]\[3\]=\{ \{80,75,92\}, \{61,65,71\}\};

\- 按行连续赋值

int a\[2\]\[3\]=\{ 80,75,92,61,65,71\};

\- 其它写法

+完全初始化,可以省略第一维的长度

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

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

+部分初始化,可以省略第一维的长度

\* 为初始化的部分默认为0

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

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

>+ 注意: 有些人可能想不明白，为什么可以省略行数，但不可以省略列数。也有人可能会问，可不可以只指定行数，但是省略列数？

其实这个问题很简单，如果我们这样写：

int a\[2\]\[\] = \{1, 2, 3, 4, 5, 6\}; // 错误写法

大家都知道，二维数组会先存放第1行的元素，由于不确定列数，也就是不确定第1行要存放多少个元素，所以这里会产生很多种情况，可能1、2是属于第1行的，也可能1、2、3、4是第一行的，甚至1、2、3、4、5、6全部都是属于第1行的

+指定元素的初始化

\* 未初始化的部分默认为0

int a\[2\]\[3\]=\{\[1\]\[2\]=10\};

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

\#\#3.二维数组的应用

\- 生活中的应用

\- 游戏中的应用

\# 二维数组与函数

\#\#1.二维数组的元素作为函数参数

\- 二维数组的元素就相当于变量，作为函数参数与变量相同

void test(char c);

int main(int argc, const char \* argv\[\]) \{

char cs\[2\]\[3\] =

\{'l', 'n', 'j'\},

\{'l', 'm', 'j'\}

\};

printf("cs\[0\]\[0\] = %c\\n", cs\[0\]\[0\]);

test(cs\[0\]\[0\]);

printf("cs\[0\]\[0\] = %c\\n", cs\[0\]\[0\]);

return 0;

void test(char c)

c= 'w';

printf("我被执行了\\n");

输出结果:

cs\[0\]\[0\] = l

我被执行了

cs\[0\]\[0\] = l

\#\#2.二维数组中的一维数组作为函数

\- 二维数组的一维数组实际上就是一个一维数组，作为函数参数与一维数组相同

void test(char c\[\]);

int main(int argc, const char \* argv\[\]) \{

char cs\[2\]\[3\] =

\{'l', 'n', 'j'\},

\{'l', 'm', 'j'\}

\};

printf("cs\[0\]\[0\]= %c\\n", cs\[0\]\[0\]);

test(cs\[0\]);

printf("cs\[0\]\[0\] = %c\\n", cs\[0\]\[0\]);

return 0;

void test(char c\[\])

c\[0\] = 'w';

printf("我被执行了\\n");

输出结果:

cs\[0\]\[0\] = l

我被执行了

cs\[0\]\[0\] = w

\`\`\`

\#\#3.二维数组作为函数参数

\- \*\*二维数组作为函数参数是地址传递\*\*

\- 二维数组作为函数形参，参数中一维数组的元素个数不可以省略

void test(char cs\[2\]\[\]) // 错误写法

printf("我被执行了\\n");

void test(char cs\[2\]\[3\]) // 正确写法

printf("我被执行了\\n");

void test(char cs\[\]\[3\]) // 正确写法

printf("我被执行了\\n");

\- 二维数组作为函数参数，在被调函数中不能获得其有多少行，需要通过参数传入。

void test(char cs\[2\]\[3\])

int row = sizeof(cs);

printf("row = %zu\\n", row);

输出结果:

row = 8

\- 二维数组作为函数参数，在被调函数中可以计算出二维数组有多少列

void test(char cs\[2\]\[3\])

size\_t col = sizeof(cs\[0\]);

printf("col = %zd\\n", col);

输出结果:

col = 3

\# 字符串常用方法

\#\#1.字符串长度

\- 利用sizeof字符串长度

+因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。

char name\[\] = "520it";

int size = sizeof(name);// 包含\\0

printf("size = %d\\n", size);

输出结果:6

\- 利用系统函数

+格式: strlen(字符数组名)

+功能:测字符串的实际长度(不含字符串结束标志‘\\0’)并作为函数返回值。

char name\[\] = "520it";

size\_t len = strlen(name2);

printf("len = %lu\\n", len);

输出结果:5

\- 以“\\0”为字符串结束条件进行统计

/\*\*

\*  自定义方法计算字符串的长度

\* @param name 需要计算的字符串

\* @return 不包含\\0的长度

\*/

int myStrlen2(char str\[\])

//    1.定义变量保存字符串的长度

int length = 0;

while (str\[length\] != '\\0')

length++;//1 2 3 4

return length;

/\*\*

\*  自定义方法计算字符串的长度

\* @param name  需要计算的字符串

\* @param count 字符串的总长度

\* @return 不包含\\0的长度

\*/

int myStrlen(char str\[\], int count)

//   1.定义变量保存字符串的长度

int length = 0;

//   2.通过遍历取出字符串中的所有字符逐个比较

for (int i = 0; i < count; i++) \{

//       3.判断是否是字符串结尾

if (str\[i\] == '\\0') \{

return length;

length++;

return length;

\# 字符串练习

\- 编写一个函数char\_contains(charstr\[\],char key)，

如果字符串str中包含字符key则返回数值1，否则返回数值0

int charContaines(char name\[\], char key)

int index = 0;

while (name\[index\] != '\\0') \{

if (key == name\[index\]) \{

return 1;

index++;

return 0;

int charContaines(char name\[\], char key)

//   int index = 0;

int index = -1;

while (name\[++index\]) \{

if (key == name\[index\]) \{

return 1;

return 0;

int charContaines(char name\[\], char key)

int index = -1;

//        取出name中的元素判断是不是要找的key,如果不是就继续找

//        但是必须要求取出的元素也不是\\0,因为如果取出的元素是\\0代表字符串已经遍历完了

while (name\[++index\] != key && name\[index\] != '\\0');

//   循环结束只有两种可能,1.找到了key, 2.字符串遍历到了结尾

//    判断当前索引对应的元素是否是\\0,如果是\\0代表字符串到了结尾都没有找打

//   int rs = name\[index\] == '\\0' ? 0 : 1;

//   int rs = name\[index\] ? 1 : 0;

//   return rs;

return name\[index\] ? 1 : 0;

\# 字符串数组

\#\#1. 字符串数组基本概念

\- 字符串数组其实就是定义一个数组保存所有的字符串

+1.一维字符数组中存放一个字符串，比如一个名字char name\[20\] = “nj”

+2.如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names\[15\]\[20\]可以存放15个学生的姓名(假设姓名不超过20字符)

+3. 如果要存储两个班的学生姓名，那么可以用三维字符数组char names\[2\]\[15\]\[20\]

\#\#2.字符串数组的初始化

1.char names\[2\]\[10\] = \{ \{'l','n','j','\\0'\},\{'l','m','j','\\0'\} \};

2.char names2\[2\]\[10\] = \{ \{"lnj"\},\{"lmj"\} \};

3.char names3\[2\]\[10\] = \{ "lnj","lmj" \};

\# 字符串输入输出

\#\#1.字符串输出

\- 在采用字符串方式后,字符数组的输入输出将变得简单方便。除了上述用字符串赋初值的办法外,还可用printf函数和scanf函数一次性输出输入一个字符数组中的字符串,而不必使用循环语句逐个地输入输出每个字符。

\- 使用的格式字符串为“%s”,表示输入、输出的是一个字符串

字符串的输出

\- 输出

+%s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出，直到遇到\\0位置

char ch\[\] = "lnj";

printf("%s\\n", ch);

\- \\0引发的脏读

char name\[\] = \{'c', 'o', 'o', 'l' , '\\0'\};

char name2\[\] = \{'l', 'n', 'j'\};

printf("name2 = %s\\n", name2);

输出结果: lnjcool

\#\#2.字符串输入

char ch\[10\];

scanf("%s",ch);

\- 注意：

+对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度

+ch最多存放由9个字符构成的字符串，其中最后一个字符的位置要留给字符串的结尾标示‘\\0’当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符。

\#\#2.练习

\- 使用 scanf() 从控制台输入一个字符串,然后使用 printf()将其输出。

char str\[9\];

scanf("%s", str);

printf("str = %s\\n", str);

\# 指针基本概念

\#\#1.什么是地址

\- 生活中的地址:

\- 内存地址:

\- 地址与内存单元中的数据是两个完全不同的概念

+地址如同房间编号

+内存单元如同房间

+内存单元中存放着数据

\- 变量地址:

+系统分配给"变量"的"内存单元"的起始地址

如:

char c = 'a'; // 占用1个字节

那么变量c的地址为:0x10A5

int n = 250; // 占用4个字节

那么变量c的地址为:0x10A1

\#\#2.什么是指针

\- 在计算机中所有数据都存储在内存单元中,而每个内存单元都有一个对应的地址, 只要通过这个地址就能找到对应单元中存储的数据. 由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”

\- 内存单元的指针(地址)和内存单元的内容是两个不同的概念。

\# 指针变量基本概念

\#\#1.什么是指针变量

\- 在C语言中,允许用一个变量来存放指针,这种变量称为指针变量。因此,一个指针变量的值就是

某个内存单元的地址或称为某内存单元的指针。

+严格意义上说,指针是一个地址,是一个常量

+针变量是存放一个地址,是一个变量。

\- 示例

\#\#2.定义指针变量的格式

\- 指针变量的定义包括两个内容:

+指针类型说明,即定义变量为一个指针变量;

+指针变量名;

!\[\](./images/zzbldygs.png)

>+ 其中,\*表示这是一个指针变量,变量名即为定义的指针变量名,类型说明符表示本指针变量所指向的变量的数据类型。

\- 示例

char \*p; // 一个用于指向字符形变量的指针

int \*q; // 一个用于指向整形变量的指针

long \*t; // 一个用于指向长整形变量的指针

float \*r; // 一个用于指向单精度浮点形变量的指针

double \*s; // 一个用于指向双精度浮点形变量的指针

\- 注意

+1)在定义指针时,“\*”号表示定义的变量是指针变量,变量的值只能存放地址。

+2)一个类型的指针只能指向同类型的变量,不能指向其他类型的变量。

\+ 3)指针也可以被声明为全局、静态局部和局部的。

\# 指针变量初始化

\#\#1.指针变量的初始化方法

\- 指针变量初始化的方法有两种:定义的同时进行初始化和先定义后初始化

+ 定义的同时进行初始化

int a = 5;

int \*p = &a;

+ 先定义后初始化

int a = 5;

int \*p;

p=&a;

+ 把指针初始化为NULL

int \*p=NULL;

int \*q=0;

\- 不合法的初始化:

+ 指针变量不能被赋值一个整数值(因为我们不知道这个整形常量是内存哪块地址

int \*p;

p =  250; // 错误写法

+ 被赋值的指针变量前不能再加“\*”

int \*p;

\*p=&a; //错误写法

\- 注意:

\- 多个指针变量可以指向同一个地址

-指针的指向是可以改变的

int a = 5;

int \*p = &a;

int b = 10;

p = &b; // 修改指针指向

\- 指针没有初始化里面是一个垃圾值,这时候我们这是一个野指针

+ 野指针可能会导致程序崩溃

+ 野指针访问你不该访问数据

+ 所以指针必须初始化才可以访问其所指向存储区域

\#\#2.访问指针所指向的存储空间

\- C语言中提供了地址运算符&来表示变量的地址。其一般形式为:

+ &变量名;

\- C语言中提供了\*来定义指针变量和访问指针变量指向的内存存储空间

+ 在定义变量的时候 \* 是一个类型说明符,说明定义的这个变量是一个指针变量

int \*p=NULL; // 定义指针变量

+ 在不是定义变量的时候 \*是一个操作符,访问指针所指向存储空间

int a = 5;

int \*p = &a;

printf("a =%d", \*p); // 访问指针变量

\# 指针练习

\#\#1.

\-  定义一个函数交换两个变量的值

void swap(int\*v1,int \*v2)

int temp;

temp = \*v1;

\*v1 = \*v2;

\*v2 = temp;

\- 写一个函数，同时返回两个数的和与差

intsumAndMinus(int v1, int v2, int \*v3)

\*v3 = v1 - v2;

return v1 + v2;

\# 多级指针

\#\#1.二级指针介绍

\- 如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针变量。也称为“二级指针”

char c = 'a';

char \*cp;

cp = &c;

char \*\*cp2;

cp2 = &cp;

printf("c = %c", \*\*cp2);

\#\#2.多级指针介绍

int \*\*\*m1; 取值\*\*\*m1

int \*\*\*\*\*m2 取值\*\*\*\*\*m2

\# 指针类型

\#\#1.指针为什么要区分类型

\- 在同一种编译器环境下,一个指针变量所占用的内存空间是固定的。比如,在16位编译器环境下,任何一个指针变量都只占用8个字节,并不会随所指向变量的类型而改变。

\- 虽然所有的指针都只占8个字节,但不同类型的变量却占不同的字节数。

+ 一个int占用4个字节，一个char占用1个字节，而一个double占用8字节；

+ 现在只有一个地址，我怎么才能知道要从这个地址开始向后访问多少个字节的存储空间呢，是4个，是1个，还是8个。

+ 所以指针变量需要它所指向的数据类型告诉它要访问多少个字节存储空间

\# 指针与数组

\#\#1.数组指针的概念及定义

\- 数组元素指针

+ 一个变量有地址,一个数组包含若干元素,每个数组元素都有相应的地址 指针变量可以指向数组元素(把某一元素的地址放到一个指针变量中) 所谓数组元素的指针就是数组元素的地址

printf(“%p %p”, &(a\[0\]), a);

输出结果:0x1100, 0x1100

\`\`\`

>+ 注意: 数组名a不代表整个数组,只代表数组首元素的地址。

>+ “p=a;”的作用是“把a数组的首元素的地址赋给指针变量p”,而不是“把数组a各元素的值赋给 p”

\#\#2.使用指针引用数组元素

\- 可以用指针去访问数组

int main (void)

int a\[5\] = \{2, 4, 6, 8, 22\};

int \*p;

// p = &(a\[0\]); /\* p has addressof  a\[1\]\*/

p = a;

printf(“%d %d\\n”,a\[0\],\*p);

输出结果: 2, 2

\`\`\`

\- 在指针指向数组元素时,允许以下运算:

+ 加一个整数(用+或+=),如p+1

+ 减一个整数(用-或-=),如p-1

+ 自加运算,如p++,++p

+ 自减运算,如p--,--p

>+ 如果指针变量p已指向数组中的一个元素,则p+1\`\`\`指向\`\`\`同一数组中的下一个元素,p-1\`\`\`指向\`\`\`同 一数组中的上一个元素。

\- 结论:

+ 引用一个数组元素,可用下面两种方法:

\* 下标法,如a\[i\]形式

\* 指针法, \*(p+i)形式

\- 注意:

+ 数组名虽然是数组的首地址，但是，数组名所所保存的数组的首地址是不可以更改的

\`\`\`

int x\[10\];

x++; //illegal

int\* p = x;

p++; //legal

\#\#3.指针变量之间运算

\- 两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。

+ 实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。

+ (pointer2地址值 -pointer地址值) /sizeof(所指向数据类型)

\- 注意:

+ 指针之间可以相减,但不可以相加(相加无意义)

\# 指针与字符串

\#\#1.字符串指针

\- 定义字符串的两种方式

+ 字符数组

\`\`\`

char string\[\]=”Ilove China!”;

printf("%s\\n",string);

+ 字符串指针指向字符串

\* 格式: \`\`\`char \*变量名="字符串内容";\`\`\`

\`\`\`

char\*str="abc"

\`\`\`

\- 字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别

\`\`\`

char c = 'b';

char \*p=&c;// 表示p是一个指向字符变量c的指针变量。

char \*s="CLanguage"; // 则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。

\`\`\`

\- 注意:

+ 1、使用字符数组来保存的字符串是保存栈里的,保存栈里面东西是可读可写,所有我 们可以改变里面的字符当把一个字符串常量赋值一个字符数组的时候,那么它会把字符串常量中的没有字符都放到字符数组里面

+ 2、使用字符指针来保存字符串,它保存的是字符串常量地址,常量区是只读的,所 以我们不可以修改字符串中的字符

\#\#2.字符串指针使用注意事项

\- 可以查看字符串的每一个字符

\`\`\`

char \*str ="lnj";

for(int i = 0; i< strlen(str);i++)

printf("%c-", \*(str+i));

输出结果:l-n-j

\`\`\`

\- 不可以修改字符串内容

\`\`\`

char \*str ="lnj";

\*(str+2) = 'y';// 错误

\`\`\`

\- 不能够直接接收键盘输入

\`\`\`

char \*str;

scanf("%s",str);

\`\`\`

>+ 错误的原因是:str是一个野指针,他并没有指向某一块内 存空间,所以不允许这样写如果给str分配内存空间是可以这样用 的

\# 返回指针的函数

\---

\#\#1.指针函数概念

\- 前面我们介绍过,所谓函数类型是指函数返回值的类型。在C语言中允许一个函数的返回值是一个指针(即地址),这种返回指针值的函数称为指针型函数。

\#\#2.指针函数的定义和使用

\- 格式:

\`\`\`

类型说明符 \*函数名(形参表) \{

/\*函数体\*/

\`\`\`

>+ 其中函数名之前加了“\*”号表明这是一个指针型函数,即返回值是一个指针。类型说明符表示了 返回的指针值所指向的数据类型。

\# 指向函数指针

\#\#1.为什么指针可以指向一个函数？

\- 函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址，即函数的入口地址。函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。因此，可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。

\#\#2.针函数的定义和使用

\- 格式:

\`\`\`

函数的返回值类型 (\*指针变量名)(形参1, 形参2, ...);

\`\`\`

+ 其中“类型说明符”表示被指函数的返回值的类型。

+ “(\* 指针变量名)”表示“\*”后面的变量是定义的指针变量。

+ 最后的空括号表示指针变量所指的是一个函数。

\`\`\`

int sum(int a,int b)

return a + b;

int (\*p)(int,int);

p = sum;

\`\`\`

\- 技巧

+ 1、把要指向函数头拷贝过来

+ 2、把函数名称使用小括号括起来

+ 3、在函数名称前面加上一个\*

+ 4、修改函数名称

\---

\- 应用场景

+ 调用函数

+ 将函数作为参数在函数间传递

\#\#3.使用注意

\- 由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的

\- 函数调用中"(\*指针变量名)"的两边的括号不可少,其中的\*不应该理解为求值运算,在此处它 只是一种表示符号

\# 字符串的基本概念

\#\#1.字符串概念

\- 字符串是位于双引号中的字符序列

+ 在内存中以“\\0”结束,所占字节比实际多一个

\---

\#\#2.字符串的初始化

\- 在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。前面介绍字符串常量时,已说明字符串总是以‘\\0’作为串的结束符。因此当把一个字符串存入一个数组时,也把结束符‘\\0’存入数组,并以此作为该字符串是否结束的标志。有了‘\\0’标志后,就不必再用字符数组的长度来判断字符串的长度了。

\- 初始化

\`\`\`

char name\[9\] = "lnj"; //在内存中以“\\0”结束， \\0ASCII码值是0

char name1\[9\] = \{'l','n','j','\\0'\};

char name2\[9\] = \{'l','n','j',0\};

char name3\[9\] = \{'l','n','j'\};//静态数组如果没有赋值默认就是0，0就相当于\\0

\`\`\`

\- 错误的初始化方式

\`\`\`

//不正确地写法，结尾没有\\0 ，只是普通的字符数组

char name4\[\] = \{'l','n','j'\};

//   \\0的作用：字符串结束的标志