【C语言数组】数组的创建和初始化 内存中的存储 冒泡排序 sizeof 数组名

【C语言精讲】——创建数组、使用数组(一维数组、二维数组) 详细讲解了C语言中数组的创建、使用及注意事项。 阅读详情


一、一维数组的创建和初始化

1、数组的创建

数组是一组相同类型元素的集合

#include <stdio.h>

int main()
{
	int arr[20];

	return 0;
}

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


2、数组初始化

2.1、不完全初始化

int main()
{
	int arr1[20] = { 1, 2, 3 }; // 不完全初始化,剩余的默认初始化为0
	int arr2[] = { 1, 2, 3 }; // 没有指定大小 根据初始化内容确定

	char arr3[] = "abc"; // a b c \0  -- 4个字节
	char arr4[] = { 'a', 'b', 'c' }; // a b c
	char arr5[] = { 'a', 98, 'c' }; // a b c

	return 0;
}

2.2、不初始化

int arr[5]; // 全局变量不初始化 默认放0

int main()
{
	int arr1[5];
	// 局部变量不初始化 放的是随机值

	return 0;
}

3、一维数组的使用

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

3.1、用下标打印1-10

#include <stdio.h>

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int i = 0; //做下标

	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

3.2、sizeof 计算数组的元素个数

#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;
}

// float sc[5] = { 0.0f, 3.0f };
// 结构体数组业可以创建

总结:
1.数组是使用下标来访问的,下标是从0开始。
2.数组的大小可以通过计算得到。


4、一维数组在内存中的存储

4.1、连续递增

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]); // 连续递增4  一个int4个字节的地址 10个
	}

	return 0;
}

随着数组下标的增长,元素的地址,也在有规律的递增。 由此可以得出结论:数组在内存中是连续存放的
数组随着下标的增长,地址是由低到高变化的


4.2、 整形指针加1是4个字节

int main()
{
	int a = 10;
	int* p = &a;

	printf("%p\n", p);
	printf("%p\n", p+1);

	return 0;
}

在这里插入图片描述


二、二维数组的创建和初始化

1、二维数组的创建

int main()
{
	int arr[3][4];
	char arr[3][5];
	double arr[2][4];

	return 0;
}

2、二维数组的初始化

整形数组

int main()
{
	int arr1[3][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 三行五列 一行放满换下一行
	int arr2[3][5] = { {1, 2}, {3, 4}, {5, 6} }; // 第一行1 2 0 0 0  第二行3 4 0 0 0  第三行5 6 0 0 0

	return 0;
}

在这里插入图片描述


行列省略

int main()
{
	int arr3[][5] = { {1, 2}, {3, 4}, {5, 6} };
	// 二维数组初始化可以省略行,但必须有列

	return 0;
}

字符数组

int main()
{
	char ch1[4][6] = { 'a', 'b' }; // 第一行"ab" 而三行没有
	char ch2[4][6] = { {'a'}, {'b'} }; // 第一行"a" 第二行"b" 第三四行没有
	char ch3[4][6] = { "abc", "def", "qwe" }; // 第一行"abc" 第二行"def" 第三行"qwe" 第四行没有

	return 0;
}

在这里插入图片描述


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++) // 0~2
	{
		int j = 0;
		for (j = 0; j < 5; j++) // 0~4
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	// 1 2 3 0 0
	// 4 5 0 0 0
	// 6 7 8 9 10
	return 0;
}

4、二维数组在内存中的存储

#include <stdio.h>

// 打印第i行第j列的地址
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]); 
		}
	}

	return 0;
}

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


5、连续存放

5.1、一维数组

#include <stdio.h>

int mian()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int* p = arr; // arr数组名是首元素的地址
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", *p);
		p++;
	}
	printf("\n");
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}

	return 0;
}

5.2、二维数组也是连续存放的

#include <stdio.h>

int main()
{
	int arr[3][5] = { {1, 2, 3}, {4, 5}, {6, 7, 8, 9, 0} };
	int* p = &arr[0][0]; // 第一行第一列的数组
	int i = 0;
	for (i = 0; i < 15; i++)
	{
		printf("%d ", *p); // 1 2 3 0 0 4 5 0 0 0 6 7 8 9 0
		p++;
	}

	return 0;
}

三、数组越界

数组的下标是有范围的,规定从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]); // 1 2 3 4 5 -858993460 
		// 超出了0-4的范围 随机值
	}

	return 0;
}

四、数组作为函数参数

冒泡排序

1、什么是冒泡排序

冒泡排序的核心思想:两两相邻的元素进行比较 排成升序
一趟冒泡排序 可以搞定一个数字 让它来到最终应该出现的位置上
10个元素最多进行9趟冒泡排序可以完成升序 -> n个元素n-1趟


2、冒泡排序函数的错误设计

#include <stdio.h>

void Sort(int arr[])
{
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序
	Sort(arr);
	
	//Print(arr);

	return 0;
}

数组传参拿指针接收,void Sort(int arr[])本质上是void Sort(int* arr)整形指针
arr是指针,那么sizeof(arr)算出的指针大小是4。sizeof(arr[0])第一个元素是整形,大小是4。4/4=1


3、冒泡排序函数的正确设计

#include <stdio.h>

// void Sort(int arr[], int sz)
void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参,单独放在sizeof内部的时候,如:sizeof(arr),这里的arr表示整个数组,不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

当数组传参的时候,实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式: int arr[] 表示的依然是一个指针: int* arr 。
那么,函数内部的 sizeof(arr) 结果是4。


4、加上print函数

#include <stdio.h>

void Print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
		// printf("%d ", *(p + i));
		// printf("%d ", *p++); // 先简引用再++
	}
}

void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参,单独放在sizeof内部的时候,如:sizeof(arr),这里的arr表示整个数组,不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

4、优化 flag 提高效率

#include <stdio.h>

void Print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", p[i]);
		// printf("%d ", *(p + i));
		// printf("%d ", *p++); // 先简引用再++
	}
}

void Sort(int* arr, int sz)
{
	int i = 0;
	// 冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		// a一趟冒泡排序的过程
		int j = 0;
		
		int flag = 1; // 假设已有序

		for (j = 0; j < sz - 1 - i; j++) // 第一次9趟 第二次8趟
		{
			if (arr[j] > arr[j + 1]) // 升序
			{
				// 交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0; // 如果发现有交换 就把flag设为0 本次排序无序
			}
		}

		if (flag == 1) // 如果没有交换 说明已有序 break跳出 提高效率
		{
			break;
		}
	}
}

int main()
{
	int arr[] = { 1, 3, 5, 2, 6, 9, 4, 8, 7, 0 };
	// 数组传参
	// 排序

	// 数组名如果没有传参,单独放在sizeof内部的时候,如:sizeof(arr),这里的arr表示整个数组,不是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]); // 此时sizeof(arr)计算的是整个数组的大小 40 / 4

	// 传参在传递给函数的时候 ==数组名会降级变成首元素地址==
	Sort(arr, sz);

	Print(arr, sz);

	return 0;
}

五、数组名是什么?

数组名是数组首元素的地址(有两个例外)

// 如果数组名是首元素地址,那么:
// int arr[10] = { 0 };
// printf("%d\n", sizeof(arr));
// 为什么输出的结果是:40?

数组名是数组首元素的地址(有两个例外):
1.sizeof(数组名),这里的数组名表示整个数组,sizeof(数组名)计算的是整个数组的大小。
2.&数组名,这里的数组名表示整个数组,取出的是数组的地址。

#include <stdio.h>

int main()
{
	int arr[10] = { 1, 2, 3, 4, 5 };

	printf("%p\n", arr); // 首元素的地址
	printf("%p\n", &arr[0]); // 首元素的地址
	printf("%p\n", &arr); // 数组的地址

	printf("------------------------------------------\n");

	printf("%p\n", arr + 1); // 差4
	printf("%p\n", &arr[0] + 1); // 差4
	printf("%p\n", &arr + 1); //差40  因为此数组是10个元素 一个元素是一个整形 10个元素就是10个整形 大小是40 

	return 0;
}

指向元素的指针+1会跳过一个元素
指向数组的指针+1会跳过一个数组

2025年三级等保新规实战:从零开始搭建企业安全防护体系(附完整配置清单) 本文详细解析2025年三级等保新规的核心变化,提供从零开始搭建企业安全防护体系的实战指南。重点介绍动态防护能力、实战化攻防验证和全链路数据保护等关键要求,并附完整配置清单,帮助企业高效合规。 阅读详情

相关推荐

告别Modern Standby烦恼:在Windows 11中手动启用S3睡眠模式的完整指南

本文详细介绍了如何在Windows 11中手动启用S3睡眠模式,解决Modern Standby(S0模式)导致的笔记本睡眠后耗电问题。通过注册表修改、电源选项调整、BIOS设置等步骤,帮助用户恢复传统深度睡眠功能,显著提升电池续航表现。

weixin_30271335的博客 567

C语言总结3--数组

一维数组的创建、初始化、使用、在内存中的存储 1.数组没有初始化时,里面存储的内容是乱码的;数组只能整体被初始化,不能被整体赋值. #include <stdio.h> #include <string.h> int main() { char arr1[] = { 'a', 'b', 'c' }; char arr2[] = "abc"; int arr3[] = {0};//将数组初始化为0 printf("%d\n", sizeof(arr1));//3 p

weixin_43807876的博客 485

【笔记软件obsidian】从入门到精通

目录 一、前言 二、下载及安装 三、【选修】ios用户如何通过iCloud进行三平台同步 四、基本Markdown语法 五、【选修】插件的下载及安装方式 六、

patrick的博客 9万+

C语言_0304笔记_数组:数组运算/初始化/sizeof/数组里有几个数/新素数判断/二维数组/3*3井字棋

计科人的回炉重造

Shmily_as33的博客 582

π_RL:解锁流匹配VLA强化学习后训练的关键技术与实战解析

本文深入解析了π_RL框架如何通过流匹配(flow matching)与强化学习(RL)的结合,解决视觉语言动作模型(VLA)在后训练中的关键挑战。详细介绍了Flow Noise和Flow SDE两大核心技术,以及它们在机器人控制任务中的实战效果,显著提升了模型的性能、数据效率和泛化能力。

weixin_29061531的博客 225

多臂老虎机——入门强化学习

多臂老虎机(Multi-Armed Bandit,MAB)问题是强化学习的经典入门例子,也是理解探索与利用(exploration-exploitation)平衡的重要案例。

qq_56683019的博客 2466

数组的初始化,求数组的大小

1.sizeof()是关键字:sizeof关键字,能计算括号中对呀数据的内存空间大小。for()括号里面的len和len-1。从小到大或者从大到小主要改变if那块代码的交换。

m0_74156325的博客 403

Hyper-V创建Ubuntu虚拟机设置固定IP

本文记录使用hyper-v创建ubuntu虚拟机,为虚拟设置固定IP且通过物理机可访问。

2626

5、简单引用使用

#include&lt;iostream&gt; using namespace std; /** 1、变量的本质实质是一段连续的内存空间的别名,相当于一个门牌号。 2、程序中通过变量来申请和命名内存空间。 3、通过变量的名字可以使用存储空间。 4、对一段联系的内存空间只能够取一个别名吗?有 5、引用相当于取一个别名; 6、引用是c++的语法范畴。 7、普通引用是必须...

沿海奔跑的少年 264

Qt Quick/QML入门到精通_专栏demo对应文章目录(目前50个左右demo/长期更新)

自定义图标下拉列表框的效果如下所示:自定义三态按钮的效果如下所示:传送门:53.qt quick-自定义三态按钮、自定义图标下拉列表框_诺谦的博客-CSDN博客传送门:59.qt quick-qml调色板(颜色取色器)实现、自定义QQuickStyle样式_诺谦的博客-CSDN博客63.qt quick-QML侧边滑动栏(不需要任何图片资源,支持自定义左右方向和大小)_诺谦的博客-CSDN博客_qt实现好看侧边栏。...

抵抗时间扭曲,坚持做一件有意义的事 2万+

支持UE4.27、UE5.0、UE5.1、UE5.2、UE5.3、UE5.4、UE5.5的VS2022一键安装方法

本文提供了两种安装VS2022以支持UE5开发的方案。方案一通过百度网盘提供一键安装包,下载解压后以管理员身份运行批处理文件即可完成安装。方案二需从微软官网下载安装程序,通过创建包含特定参数的批处理文件来自定义安装组件。两种方案都需保持联网环境,建议先卸载旧版VS。安装完成后可测试打包UEC++项目Windows包。

2501_93651177的博客 361

Java 数组:数组声明创建与初始化、数组内存分析、多维数组、冒泡排序、二分查找法

文章目录Java数组1、数组声明创建与初始化2、内存分析3、多维数组4、Arrays类5、冒泡排序 面试常遇见6、稀疏数组 重点 压缩数组7、二分查找法(折半查找法) 面试常见 Java数组 数组是相同类型数据的有序集合。每个数据称一个数组元素,每个元素可通过下标来进行访问。 1、数组声明创建与初始化 语法: dataType[] arrayRefVar; // 首选,推荐使用 dataType...

阿星小天地 438

26届数字IC秋招笔试面试全攻略 - CPU基础架构-数字IC设计专家

本文介绍了CPU基础架构的三大关键技术:流水线、冒险处理和指令集设计。首先解析了经典五级流水线结构(取指、译码、执行、访存、写回)及其性能指标。其次详细阐述了三种流水线冒险(数据、控制、结构)及解决方案,如数据前递、分支预测等。最后对比了RISC与CISC指令集特点,并以RISC-V为例说明指令格式设计原则。全文系统梳理了CPU核心架构知识,为数字IC设计提供重要参考。

2301_79143213的博客 934

C语言中的数组(详解)

代码中 sizeof(arr)表示计算整个数组arr的大小,而sizeof(arr[0])表示计算数组中首元素的大小(随便计算一个元素就行,因为每个元素的大小都是相等的,这里是选取了首元素),所以sz就是数组元素的个数。对于数组的使用我们之前介绍了一个操作符: [] ,下标引用操作符,即arr[0]为数组首元素,arr[4]为最后一个元素。C语言本身是不做数组下标的越界检查,编译器也不一定报错,但是编译器不报错,并不意味着程序就是正确的,当数组传参的时候,实际上只是把数组的首元素的地址传递过去了。

m0_68662723的博客 1万+

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

【初阶C语言】数组(详解)

C语言数组详细配图讲解

m0_75058342的博客 1818

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

C · 初阶 | 数组?看一遍就够了

数组(Array)是有序的元素序列。若将有限个类型相同的变量的集合命名,那么这个名称为数组名。组成数组的各个变量称为数组的分量,也称为数组的元素,有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中,为了处理方便, 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。数组是用于储存多个相同类型数据的集合。

CGod的博客 3003

【C语言】带你玩转数组(全程高能)

✨作者:@平凡的人1 ✨专栏:《C语言从0到1》 ✨一句话:凡是过往,皆为序章 ✨说明: 过去无可挽回, 未来可以改变 目录 前言😄 一维数组⭐️ 一维数组的创建🍁 变长数组🍁 初始化🍁 使用🍁 越界问题🍁 在内存中的存储🍁 拓展:sizeof和strlen()的区别🍁 怎么理解sizeof是一个操作符?✅ 二维数组⭐️ 二维数组的创建🍁 初始化🍁 使用🍁 在内存中的存储🍁 数组作为函数参数⭐️ 错误的冒泡排序🍁 数组名🍁 正确的冒泡排序🍁 .

weixin_60478154的博客 1686

(!!新手必看!!)手撕C语言初阶---数组

一维数组的创建和初始化 数组的创建 数组是一组相同类型元素的集合。 数组的创建方式: 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]; 注:数组创建,

Edward_Asia的博客 858

【C语言】一维数组和二维数组(详解)

【C语言】数组部分的详细讲解,今天是腊月二十九,除夕夜前一天,提前祝大家新年快乐,大展宏“兔”!

qq_63320529的博客 692

C语言数组

目录一维数组的创建和初始化数组的创建数组的初始化补充:sizeof与strlen的区别不同存储方式sizeof和strlen的值一维数组的使用 一维数组的创建和初始化 数组的创建 数组是一组相同类型元素的集合。数组的创建方式: type_t arr_name [const_n] //type_t 是指数组的元素类型 //const_n 是一个常量表达式,用来指定数组的大小 数组创建的实例 创建一个数组存放10个整型 //正确 int arr[10]; //错误 int n = 10; char ch[n

cyrilcloud的博客 294

C语言:数组

一维数组的创建和初始化 数组的创建 数组是一组相同类型元素的集合。数组的创建方式 type_t arr_name {const_n} //type_t是指数组的元素类型 //const_n是一个常量表达式,用来指定数组大小

weixin_61926920的博客 358

c语言初阶——数组

数组在函数中使用时,需要注意的是,在函数中的arr已经作为了指针,sizeof函数已经无法生效,因此要外部获取数组长度。注意:c语言中字符串是以"\0"结尾的,也就是说一个字符串"abc"实际上是四个字符'a','b','c','\0'.

qq_55791111的博客 697

笔记13(C语言 数组)

注: 本笔记参考B站up 鹏哥C语言的视频 一维数组的创建和初始化 数组的创建 数组,就是一组相同类型的元素的集合。 数组的创建方式: type_t arr_name [const_n]; //type_t 是指数组的元素类型; //const_n 是一个常量表达式,用来指定数组的大小 (小知识:C99语法下支持变长数组,可以用变量来指定数组的大小。) 实例: #include<stdio.h> int main() { int arr[8]; char a..

w_pab的博客 683

C语言数组详解

C语言数组详解(看了就会)

czh1592272237的博客 293

【C】数组+冒泡排序

✨博客主页:心辛向荣 ✨系列专栏:【从0到1,C语言学习】 ✨一句短话:你若盛开,蝴蝶自来! ✨博客说明:尽己所能,把每一篇博客写好,帮助自己熟悉所学知识,也希望自己的这些内容可以帮助到一些在学习路上的伙伴,文章中如果发现错误及不足之处,还望在评论区留言,我们一起交流进步!😊 💻前言 🍁这篇博客总结数组当中的知识点,理解熟悉数组的使用。 💻目录 一.数组的创建使用和初始化 ——1.一维数组 ——2.二维数组 二.数组在内存中的存储 ——1.一维 ——2.二维 三.数组越界和数组名 ——1.对于二..

trong_ 的烂笔头 1195

史上最强C语言教程----数组(初阶)

史上最强C语言教程----数组(初阶)

m0_57304511的博客 1万+
上一篇: 【C语言函数】 - 库函数、自定义函数、函数参数、函数调用、嵌套调用链式访问、递归与迭代、缓冲区
下一篇: 【C语言】三子棋游戏
三春去后诸芳尽
博客等级 码龄6年 2631粉丝 109原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三春去后诸芳尽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值
⌂ 换网址