Linux--C语言之数组（一维、二维和字符）

于 2024-08-10 21:17:49 发布
阅读量788 收藏 6
点赞数 19
文章标签： linux c语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75773226/article/details/141096114
版权

文章目录

一、数组

（一）数组的概念

​ 数组是相同类型，有序数据的集合。

（二）数组的特征

1.数组中的数据被称为数组的元素，是同构的

2.数组中的元素存放在内存空间里 （char player_name[6]：申请在内存中开辟6块连续的基于char类型的变量空间）

（三）衍生概念：下标（索引）

1.下标或索引代表了数组中元素距离第一个元素的偏移位置。

2.数组中元素的地址值，下标越大，地址值越大。（每一块内存空间都有一个独有的内存地址）。

3.数组的下标是从0开始的。

二、一维数组

（一）数组的定义

类型说明符 数组名[数组容量]

说明：

1.数组的类型说明符由数组中的元素来决定，也就是元素是什么类型，数组就是什么类型

2.数组名也是标识符， 我们所说的数组(名)，大家可以理解为数据类型是数组的变量(名)。

3.数组容量也可以叫做常量表达式，举例：int ages[10]、int lcd[1024*768]

4.类型：代表了数组中元素的类型

5.容量：数组中能存储多少个元素，数组容量可以是一个常量、常量表达式，还可以是符号常量，但必须是整型。

6.深入理解：

​ （1）定义一个数组，相当于申请了一个可以容纳所指定元素数量的内存单元。所申请的内存单元是连续的。

​ （2）定义一个数组，相当于定义了多个匿名变量，这些变量可以通过==数组名[下标]==来标识。

举例：

// 定义一个数组
int arr[10];
// 问题：上面数组中，最小下标0，最大下标9

经过上面的案例，分析得到

数组的最大下标 = 数组元素个数（数组容量） - 1

（二）数组元素的访问

1.原则：数组中的元素不能一次性访问所有元素，只能一个一个的访问。

2.访问方式：

数组名[下标]

举例：

// 定义一个容纳10个元素的int数组
int arr[10];
// 给数组的第一个元素进行赋值
arr[0] = 89;
// 访问数组的第一个元素
int a = arr[0];
// 问题：以下访问是否正确
int b = arr[10]; // error，下标越界异常

注意：数组元素的访问一定不能越界。

案例：

/*
需求：一维数组案例-引用数组元素。利用循环给数组元素a[0]~a[9]赋值0~9，并且逆序输出
*/

#include <stdio.h>

int main()
{
	// 创建一个数组
	int arr[10];
    
	// 使用for循环给数组赋值
	for(int i = 0;i < 10;i++)
	{
		arr[i] = i;
	}
    
	// 逆序输出
	// 我们通过循环将数组中的元素一个个取出来，称之为遍历
	for(int i = 9;i >= 0;i--)
	{
		printf("%d ",arr[i]);
	}
    
	printf("\n"); // 纯粹换行
    
	return 0;
}

（三）数组的初始化

定义数组的同时，用指定数据来给对应元素赋值。

简化数组定义后，需要对元素一一赋值操作。

语法规则：

类型 数组名[容量] = {常量1，常量2，常量3...};

注意事项：

数组可以部分初始化：也就是可以给数组中前几个元素初始化，未被初始化的元素系统将自动初始化，如0；如果定义数组时未指定数据容量，则系统会根据初始化元素的个数来决定数组容量。

// 1. 如果定义数组时只给数组前几个初始化，后续剩余元素会自动完成初始化，比如赋值0
int arr[10] = {1,2,3,4,5} // 推荐写法，等价于以下写法
int arr[10] = {1,2,3,4,5,0,0,0,0,0}

// 2. 如果定义数组时未指定数据容量，根据初始化元素个数来决定容量
int arr[] = {1,2,3,4,5} // 推荐写法，等价于以下写法
int arr[5] = {1,2,3,4,5}

衍生概念：

柔性数组：柔性数组的概念是在C99标准，针对结构体的最后一个成员可以是一个未指定大小的数组；广义简单理解：数组容量待定或者待确定的数组，举例： int arr[] = {1,2,3,4,5}

面试题：

在不知道数组类型的情况下，如何确定数组元素的个数

int length = sizeof(arr) / sizeof(arr[0])

说明：

1. arr就是我们计算的数组本身，‘sizeof(arr)’用来计算该数组中总的字节大小。
2. ‘sizeof(arr[0])’用来计算数组中一个元素所占的字节大小，因为数组中的元素类型相同，所以计算哪一个都行。
3. ‘sizeof(arr)/sizeof(arr[0])’就是用数组中总的字节数除以每一个元素所占的字节数，从而得到元素的个数。

在这里插入图片描述

（四）一维数组案例

案例1：

/*
需求：一维数组案例-斐波拉契数列
*/
#include <stdio.h>

int main()
{
	int i;// 循环变量
	int f[20] = {1,1}; // 定义一个数组，用来存储数列，默认存储第1位和第2位
    
	int length = sizeof(f)/sizeof(f[0]);// 计算数组的元素个数
    	
	// 生成数列存入数组
	for(i = 2;i < length;i++)
	{
		// 给数组元素赋值，从数组的第3个元素开始
		f[i] = f[i - 2] + f[i - 1];
	}
    
	// 遍历数组
	// 通过循环将数组中的每一个元素取出来，称之为遍历
	for(i = 0;i < length;i++)
	{
    	// 遍历的时候，要求一行显示5个数
		if(i % 5 == 0)
		{
			printf("\n");
		}
        
		printf("%6d",f[i]);
	}
    
	printf("\n");
    
	return 0;
}

三、数组的典型应用：数据排序

冒泡排序

（一）向后冒泡

思想：

1.一次只排好一个数，针对n个数，最差情况需要 n-1次就可以排好

2.每次排序将相邻数据两两比较，将较大或较小的数据向后交换，等所有数据都比较完成，将较

大/较小的数就会出现在最后，这也是该数应该有的位置。

3.在余下的数中，再次应用第2步的操作，直到只剩下一个数。

（二）向前冒泡

思想：

1.一次只排好一个数，针对n个数，最差情况需要n-1次就可以排好

2.每次排序假定第一个元素是最大/最小的，用第一个元素的后面的元素一一与第一个元素比较，遇到较大/较小的和第一个元素交换，访问完数组的最后一个元素，就排好了一个数；

3.在余下的数中，再次应用第2步的操作，直到只剩下一个数。

（三）一维数组案例

案例2：

/*
需求：一维数组案例-冒泡排序
*/
#include <stdio.h>

int main()
{
	// 创建一个数组，用来存储排序的数列
	int arr[11];
	int i,j,temp;// i:比较的轮数，j:每一轮比较的次数，temp:临时变量，用来比较时交换数据
    
	printf("请输入11个测试整数：\n");
    
	// 计算数组的大小
	int length = sizeof(arr) / sizeof(int); // 这里 sizeof(int) 等价于sizeof(arr[0]);
    
	// 通过循环录入数据
	for(i = 0;i < length; i++)
	{
		scanf("%d",&arr[i]);
	}
	printf("\n");
    
	// 对数组arr使用冒泡进行排序（注意：我们使用标准冒泡，大家也可以自行补充优化版的冒泡，如鸡尾酒排序法等等）
	// 外层循环：控制比较的轮数，因为有11个数，所以我们需要比较 length -1 轮，也就是比较10轮
	for(i = 0;i < length -1;i++)
	{
		// 内层循环：每一轮比较的次数，每一轮比较的次数为 length - 1 - i， 3-1-0=2,3-1-1=1,3-1-2=0
		for(j = 0;j < length-1-i;j++)
		{
			// 相邻的两个数进行比较，满足条件交换位置
			if(arr[j] > arr[j+1])
			{
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
    }
    
	printf("冒泡排序后遍历数组：\n");
    
	for(i = 0; i < length; i++)
	{
		printf("%4d",arr[i]);
	}
    
	printf("\n");
    
	return 0;
}

案例3：

/*
需求：一维数组案例-从键盘输入年、月、日，计算并输出该日是该年的第几天。
*/
#include <stdio.h>

int main()
{
	// 定义变量：年，月，日,统计总天数，循环变量，用来遍历当前月前面的月份
	int year,month,day,sum,k;
	// 定义一个数组，用来存放1～12月每月的天数
	int t[] = {31,0,31,30,31,30,31,31,30,31,30,31};// 柔性数组
    
	printf("请输入年份、月份、天：\n");
	scanf("%d,%d,%d",&year,&month,&day);
    
	// 因为二月比较特殊，存在平年和润年这样的因素，所以需要进行平年和润年的判断
	if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
	{
		t[1] = 29; // 润年 2月 29天
	}
	else
	{
		t[1] = 28; // 平年 2月 28天
	}
    
	sum = day; // 默认记录最后一个月的天数
    
    // 这是该年的第几天
	for(k = 0; k < month -1;k++)
	{
		sum += t[k]; // 叠加前几个月的天数
	}
    
	printf("%d月%d日是%d年的第%d天。\n",month,day,year,sum);
    
	return 0;
}

四、二维数组

（一）定义

  1. 二维数组本质上是一个行列式的组合，也就是说二维数组是有行和列两部分构成。二维数组数据是通过行列进行解读。

  2. 二维数组可被视为一个特殊的一维数组，相当于二维数组又是一个一维数组，只不过它的元素是一维数组。

语法：

类型 数组名[行数][列数]；

举例：

int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; // 等价于以下写法
int arr[][3] = {{1,2,3},{4,5,6},{7,8,9}}; // 柔性数组
int arr[3][] = {{1,2},{4,5,6},{7}} // 等价于 {{1,2,0},{4,5,6},{7,0,0}}

（二）应用场合

主要应用于数据有行列要求的情况。

（三）特殊写法

  1. 下标可以是整型表达式，如：a[2-1][2*2-1]
  2. 下标可以是已经有值的变量或数组元素, 如：a[2*x-1][b[3][1]]
  3. 数组元素可以出现在表达式中， 如： b[1][2]=a[2][3]/2

（三）初始化

  1. 分行给二维数组赋初值
int a[3][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12}};
  1. 可将所有数据写在一个花括号内，按照排列顺序对元素赋值。
int a[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12}; // 等价于上面的写法
  1. 可对部分元素赋初值，其余未赋值部分自动填充 0 | \0 | 0.0...
int a[3][4] = {{1},{5,6},{9}}; // 等价于 int a[3][4] = {{1,0,0,0},{5,6,0,0},{9,0,0,0}}
  1. 在分行赋初值是，也可以省略第1维的长度。
int a[][4] = {{1,2,3},{0},{0,10}}; // 等价于 int a[][4] = {{1,2,3,0},{0,0,0,0},{0,10,0,0}}

案例：

案例1：

/**
* 案例：二维数组的遍历
*/
#include <stdio.h>

int main()
{
	int arr[][3] = {{1},{2,4},{5,6,7}};// 经过论证：二维数组我们必须指明第2维的数组的长度
	// 获取行元素的大小
	int length = sizeof(arr) / sizeof(arr[0]); // 如果是二维数组，第1维的长度，应该是如左侧这样获取
    
	printf("length:%d\n",length);
    
	// 遍历二维数组，需要使用双层for循环，外层遍历行，内层遍历每一行的列
	for(int row = 0;row < length;row++)
	{
		// 获取列元素的总大小
		int len = sizeof(arr[row]) / sizeof(int);
        
		for(int col = 0; col < len; col++)
		{
			// 获取列元素
			printf("%3d",arr[row][col]);// 意思是获取数组arr 第row行第col列
		}
        
		printf("\n");
	}
    
	return 0;
}
// 数据类型，分支结构，循环结构，数组

案例2：

/**
* 需求：二维数组案例-矩阵的转置（就是将一个2行3列的数组转换为3行2列的数组）
*/
#include <stdio.h>

int main()
{
	// 准备2个数组，存放转前和转后的数据
	int arr_before[2][3] = {1,2,3,4,5,6};
	int arr_after[3][2] = {0};// 初始化，每一列上都是0
    
	// 遍历arr_before
	for(int i = 0;i < sizeof(arr_before)/sizeof(arr_before[0]);i++)
	{
		for(int j = 0;j < sizeof(arr_before[i])/sizeof(int);j++)
		{
			// 转置
    		arr_after[j][i] = arr_before[i][j];
		}
	}
    
	// 遍历arr_after
	for(int i = 0;i < sizeof(arr_after)/sizeof(arr_after[0]);i++)
	{
		for(int j = 0;j < sizeof(arr_after[i])/sizeof(int);j++)
		{   
			// 输出
			printf("%4d",arr_after[i][j]);
		}
		printf("\n");
	}
    
	return 0;
}

案例3：

/**
* 需求：二维数组案例-准备一个int类型的二维数组，求该数组中大的最大值，以及对应的行号，列号
*/
#include <stdio.h>

int main()
{
	// 准备一个二维数组
	int arr[3][4] = {{1,2,3,4},{9,8,7,6},{-10,10,-5,2}};
	// 创建变量，用保存最大值、行号、列号
	int max = arr[0][0],row=0,col=0;
    
	// 遍历集合
	for(int i = 0;i < sizeof(arr) / sizeof(arr[0]);i++)
	{
		for(int j = 0;j < sizeof(arr[i]) / sizeof(arr[i][0]);j++)
		{
			// 判断最大值
			if(arr[i][j] > max)
			{
				max = arr[i][j];
				row = i;
  				col = j;
			}
		}
	}
    
	printf("max=%d,row=%d,col=%d\n",max,row,col);
    
	return 0;
}

五、字符数组

（一）概念

  1. 元素类型为char字符型的数组，字符数组往往是用来存储字符串数据的。需要注意的一点是，我们C语言中的字符是字节字符。

  2. 字节字符：也就是一个字符占1个字节

  3. 测试题：

char a = 'A' // 正确
char b = '1' // 正确
char c = 65 // 正确 这是ASCII码编号，对应的值是 'A'
char d = "A" // 错误，这是字符串的写法，也是char数组的写法，char d[1] = "A"
char e = '马' // 错误，中文一个字符超过1一个字节
  1. 语法：
char 数组名[容量];
char 数组名[行容量][列容量];
  1. 字符数组的语法就是之前所学一维数组和二维数组的语法，只不过数据类型是char而已。

注意:

如果我们的char数组初始化的时候，没有完全赋完值的时候，空出来的地方使用\0进行填充。

字符案例

案例1：

/**
* 需求：字符数组案例-输出一个字符串（I LOVE YOU!）
*/
#include <stdio.h>
int main()
{
	// 准备一个测试字符串 I LOVE YOU！
	char arr[11] = {'I',' ','L','O','V','E',' ','Y','O','U','!'};
    
	// 通过一个for循环进行遍历输出
	for(int i = 0;i < sizeof(arr)/sizeof(char);i++)
	{
		printf("%c",arr[i]);
	}
	printf("\n");
    
	return 0;
}

案例2：

/**
* 需求：字符数组案例-输出一个用字符组成的菱形图案
*/
#include <stdio.h>

int main()
{  
	// 准备数据
	char arr[5][5] = {{' ',' ','*',' ',' '},{' ','*',' ','*',' '},{'*',' ',' ',' ','*'},{'','*',' ','*',' '},{' ',' ','*',' ',' '}};
    
	// 遍历数组
	for(int i = 0;i < sizeof(arr)/sizeof(arr[0]);i++)
	{
		for(int j = 0;j < sizeof(arr[i])/sizeof(char);j++)
		{
			// 打印菱形
			printf("%c",arr[i][j]);
   	 	}
        
		// 内层循环每结束一轮，就是一行
		printf("\n");
	}
    
	printf("\n");
    
	return 0;                                                                           
}

（二）字符串和字符串结束标志

说明：

  1. C语言规定，字符串以字符’\0’作为结束标志
  2. 编译系统对字符串常量自动加一个’\0’作为结束标志
  3. 程序中往往通过判断’\0’来检测字符串是否结束
  4. '\0’的ASCII码为0，不是一个可显示的字符，是“空操作符”，什么都不做，不会增加有效字符，仅是一个供判别的标志

（三）字符数组的多样表示

我们的char数组可以以数组的方式一个个输出每个字符；我们的char数组也可以以字符串的方式整体进行输出所有字符。具体如下面案例：

/*
需求：字符数组->字符串
*/
#include <stdio.h>
int main()
{
	// 字符串第1种表示：
	char s1[] = {'h','e','l','l','o',' ','w','o','r','l','d'};
	// 字符串第2种表示：
	char s2[] = {"hello world"};
	// 字符串第3种表示：
	char s3[] = "hello world";
    
    // 测试，使用字符串方式打印，这样就不用一一遍历
	printf("%s\n",s1);
	printf("%s\n",s2);
	printf("%s\n",s3);
    
	return 0;
}

注意

  1. 字符串的长度与字符数组的长度不一定相同。

  2. 利用字符串常量可以对字符数组进行初始化，但不能用字符串常量为字符数组赋值。

// 正确写法：利用字符串常量给字符数组初始化
char b[15] = "China";

// 错误写法：利用字符串常量给字符数组赋值
char b[15];
b[15] = "China";

（四）字符串的基础操作

1.字符串输入

scanf(“%s”,数组名)

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
    scanf("%s",name);// 如果是字符串，这里不是变量地址，是变量名
    
	printf("您的姓名是：%s\n",name);
    
	return 0;
}

注意：

采用scanf进行字符串输入，要求字符串中不能存在空格，否则字符串遇到空格会结束。

fgets(数组名,数组容量，stdin);

说明：采用fgets进行字符串输入，可获取所有输入的字符串，包含\n，在实际的字符串处理时，我们可能需要处理\n

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
    
	fgets(name,sizeof(name)/sizeof(char),stdin);// 输入，返回地址
    
	puts(name);// 输出
    
	return 0;
}

注意：

  1. 如果输入的字符串不包含空格和换行 ，可以使用scanf() | fgets();
  2. 如果输入的字符串需要包含空格和换行，只能使用fgets();
  3. 经过对比，我们发现，在字符串的输入中，fgets()更好；

2.字符串输出

puts(数组名)

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
	scanf("%s",name);
    
	puts(name);// 输出 问题？字符串如何拼接
    
	printf("您的姓名是：%s\n",name);
    
	return 0;
}
printf(“%s”,数组名);

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
	scanf("%s",name);
    
	printf("您的姓名是：%s\n",name);
    
	return 0;
}

3.字符串拼接

strcat(数组名,“需要拼接的字符串”)
注意：需要引入#include <string.h>

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>
#include <string.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
	fgets(name,sizeof(name)/sizeof(char),stdin);// 输入，返回地址
    
	puts(strcat(name," 跑着！"));// 拼接
    
	return 0;
}

4.字符串拷贝

strcpy(数组名,字符串)
注意：需要引入 <string.h>库

说明：这个方法适合给字符串赋值用。

char str[16] = "马杰克" // 初始化，正确
    
char str[16]; str[16] = "马杰克" // 赋值，错误
    
char str[16]; strcpy(str,"马杰克") // 赋值，正确，结果：马杰克

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>
#include <string.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char name[20];
    
	printf("请输入您的姓名：\n");
	scanf("%s",name);
    
	strcpy(name,"你好");
	printf("%s\n",name);// 输出
    
	return 0;
}

5.字符串比较

strcmp(字符串1,字符串2);
注意：
  1. 需要引入 <string.h>
  2. 返回的结果是boolean

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>
#include <string.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char username[20];
    
	printf("请输入您的账户：\n");
	scanf("%s",username);
    
	if(strcmp(username,"admin"))
	{
		printf("账户输入错误！\n");
	}
	else
	{
		printf("账户输入正确！\n");
	}
    
	return 0;
}

5.获取字符串长度

strlen(字符串)
注意：
  1. 需要 <string.h>
  2. 返回字符串长度

案例：

/*
* 需求：字符数组-字符串的输入输出
*/
#include <stdio.h>
#include <string.h>

int main()
{
	// 创建一个变量，用来存放人的名字
	char username[20];
    
	printf("请输入您的账户：\n");
	scanf("%s",username);
    
	// 获取字符串长度
	unsigned long len = strlen(username);
    
	if(strcmp(username,"admin"))
	{
		printf("账户输入错误！%lu\n",len);
	}
	else
	{
		printf("账户输入正确！%lu\n",len);
	}
    
	return 0;
}
2201_75773226
关注
  • 19
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言总结（一维数组、二维数组、字符数组和字符串）
csuft20164442的博客
01-23 12万+
C语言总结第七章、数组一维数组一维数组的定义一维数组的引用一维数组的初始化程序举例二维数组及多维数组二维数组的定义二维数组元素的引用二维数组元素的初始化程序举例字符数组和字符串字符数组 第七章、数组 数组是构造数据类型之一 数组： 有序数据的集合,用数组名标识 元素： 属同一数据类型,用数组名和下标确定 一维数组 一维数组的定义 定义方式： 例： int a[6] 一维数组的引用 1、数组...
二维数组复制字符串c语言,C语言--关于二维数组,字符串数组,多维数组
weixin_39526238的博客
05-17 1697
int main(int argc, const char * argv[]){@autoreleasepool {#pragma mark-----------二维数组int a[3][4]={{1,2,3,4},{5,6,7,8},{12,10,11,12}};//打印二维数组for (int i = 0; i<3; i++) {for (int j =0; j<4; j++) {...
C语言第九弹---二维数组
熬夜学习编程的小林的博客
01-26 1775
1、二维数组的创建1.1、二维数组的概念​1.2、⼆维数组的创建2、二维数组的初始化2.1、不完全初始化​2.2、完全初始化​2.3、按照行初始化​2.4、初始化时省略行，但是不能省略列​3、⼆维数组的使用3.1、⼆维数组的下标3.2、⼆维数组的输入和输出4、⼆维数组在内存中的存储5、C99中的变长数组​6、数组练习总结
C语言学习之一维字符数组&二维字符数组
qq_41878292的博客
08-11 665
【代码】C语言学习之一维字符数组&二维字符数组。
C语言数组基础知识详解---一维数组，二维数组，数组访问，二分查找
fhvyxyci的博客
06-22 1195
一维数组，二维数组，数组访问，二分查找
[ C语言 ] 数组-- 一维数组-- 二维数组--（1）
CSDN博客
11-06 2579
文章目录 前言 一，数组 二，一维数组 三，二位数组 ​​​​​​总结 前言 本篇文章主要记录数组的相关概念 主要包括：数组-- 一维数组-- 二维数组 ——————————————————————————————————————————— ****正文开始*** 一，数组 1.1.数组的定义： 数组是一组相同类型元...
c语言二维数组字符串赋值,C语言笔记（二）--- 数组、函数
weixin_39525118的博客
05-17 5925
七、数组在C语言中，数组属于构造数据类型。数组根据元素的类型不同，数组又可以分为 数值数组 、字符数组 、指针数组 、结构数组 等各种类别。本章介绍 数值数组 和 字符数组 。1. 一维数组的定义和引用定义： 类型说明符 数组名 [常量表达式];例如：int a[10]; float b[10],c[20]; char ch[20];下标从 0 开始；不能在 [] 中使用变量来表示元素的个数...
c语言 --- 二维数组
weixin_60569662的博客
03-15 8132
认识二维数组 如何创建二维数组 //NO.1 如何创建二维数组，固定语法： 类型 数组名[数组长度1][数组长度2]; int array[2][2]; //数组长度1: 2-->行 //数组长度2: 2-->列 //总元素个数：数组长度1*数组长度2==行*列 //最大下标是: 数组名[数组长度1-1][数组长度2-1] 最大下标是array[1][1] 不可能是array[2][2] 在内存上的长相：在内存中是一段连续的内存，可以人为地让它有行有列 常规操作
【C语言】动态分配二维字符串数组
热门推荐
谁吃薄荷糖
10-27 1万+
动态分配一个二维字符串数组 （1） 分配可能不连续的内存 申请 char**pps8Output = (char **) malloc(n * sizeof(char *)); 对于pps8Output而言，它获得了一块动态分配的连续内存，这块连续的内存可以放n个char *指针。 下面为每一行malloc一次内存，这样分配的内存就不一定是连续的。 for (int i = 0; i < n; i++) { pps8Output[i] = (char *) malloc(lens * si
初学C语言-二维数组与字符数组
czh2637750821的博客
11-27 5974
二维数组与字符数组 二维数组 简单地说就是具有两个下标的数组称为二维数组。 二维数组的定义形式 存储类型 类型说明符 数组标识符[常量表达式1] [常量表达式2] 例如： static int a[2][3],b[2][3]; char c[10][10]; ...
c语言基础-c语言编程基础之二维字符串数组示例-Bigtram分词.zip
03-17
本压缩包文件“c语言基础-c语言编程基础之二维字符串数组示例-Bigtram分词.zip”显然是围绕C语言的二维字符串数组以及Bigtram分词技术展开的教程或示例代码。下面我们将深入探讨这两个核心概念。 首先，我们来理解...
IOS开发之路--C语言数组和字符串
09-04
4. **一维数组的使用限制**：数组的长度一旦声明就不能改变，尝试访问超出数组长度的元素会导致未定义行为，编译器通常不会检查这种错误。例如，`a[2] = 3;` 超出了数组a的长度，虽然能编译通过，但在运行时可能引发...
一道 C语言 二维数组作业题目
01-06
有下面这样的一个二维表，请将其使用二维数组输出 姓名 语文 数学 英语 张三 80 70 90 李四 40 50 90 王五 90 98 100 题解 与几位童鞋交流了一下发现他们都把汉字单独拿出来了，只用数组存储的成绩，...
C语言中二维数组作为函数参数来传递的三种方法
08-25
C语言中二维数组作为函数参数来传递的三种方法 在C语言中，二维数组作为函数参数来传递是非常常见的操作。但是，如何正确地传递二维数组作为函数参数却是许多初学者和开发者经常混淆的地方。今天，我们将详细介绍...
C语言二维数组几种常用的表示方法
01-01
（2）、第二种是用一维数组来表示二维数组，从显示的元素地址可以看出，二维数组和一维数组表示的二维数组在内存中的储存方式其实是一样的，不过使用二维数组看起来要简单些，只要不用进行地址转换。 （3）、第三...
系统控制和管理接口：在Linux中利用电源和性能域进行平台资源抽象
最新发布
csdnsqst0046的博客
08-09 561
在本文中，您可以了解到如何利用我们的方法将复杂性从Linux驱动程序（需要为每个平台编写不同的开发程序）转移到固件。由于固件已经适配了平台，因此固件知道需要采取哪些手段来配置外设。您可以了解我们如何定义逻辑性能和电源域，而不是单独处理每个平台资源。您还可以了解到我们如何努力实现这一目标，以及您如何进行尝试并做出贡献。
Linux安全与高级应用（四）深入探索MySQL数据库：安装、管理与安全实践
洛秋的博客
08-07 1368
Linux：作为操作系统，提供稳定的运行环境。Apache：作为Web服务器，处理HTTP请求。MySQL：作为数据库管理系统，存储和管理数据。：作为脚本语言，生成动态网页。LAMP平台的优势在于其成本低廉、可定制性强、易于开发、方便易用且安全稳定。这使得LAMP成为许多企业和开发者的首选平台。通过以上步骤，我们完成了LAMP平台的部署及其主要组件的配置和测试。LAMP平台的搭建不仅为Web开发提供了一个强大的环境，同时也展现了其在成本和效率上的优势。
linux 011 注释13：缺页中断，新设计艺术团队第二版，第四章 4-39 至 4-48
zhangzhangkeji的博客
08-06 210
（133） 4-42 函do_no_page。
linux docker安装 gitlab后忘记root密码如何找回
爱丫爱的博客
08-06 306
docker 安装git 忘记root 密码如何重新设置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值