C语言柔性数组详解：让你的程序更灵活

柔性数组

    • 一、前言
    • 二、柔性数组的用法
    • 三、柔性数组的内存分布
    • 四、柔性数组的优势
    • 五、总结

一、前言

仔细观察下面的代码，有没有看出哪里不对劲？

struct S
{
	int i;
	double d;
	char c;
	int arr[];
};

还有另外一种写法：

struct S
{
	int i;
	double d;
	char c;
	int arr[0];
};

你应该一眼就看到了，结构体的最后一个成员数组的写法是int arr[];或者是int arr[0]，这两种写法是等价的，意思是这个数组的大小是不确定的、未知的、可以变化的。

C99允许这种特殊的结构体存在。这样的结构体满足下面两个条件：

  1. 最后一个成员变量是一个大小可以变化的数组。
  2. 这个成员数组前面至少有另外一个成员变量。

我们称这个大小可以变化的成员数组为柔性数组。

注意，柔性数组不能是结构体里唯一一个成员，下面的代码是不允许的：

struct S
{
	int arr[0];
};

这篇文章里，我将重点探讨柔性数组的用法、内存分布以及和优势。

二、柔性数组的用法

我不建议在栈上直接定义有柔性数组的结构体，也就是这么写：

struct S s;

因为柔性数组的大小是可以变化的，我建议在堆上申请空间，采取动态内存管理的方法，这样就能发挥出柔性数组大小可以改变的优势。

假设我们使用malloc()函数来开辟空间，一开始应该malloc出多大的空间呢？要回答这个问题，首先我们要知道sizeof(struct S)是多少。

事实上，sizeof(struct S)计算出来的结果是该结构体不考虑柔性数组的大小。如果我们想要给柔性数组开辟空间，malloc出来的大小应该是sizeof(struct S)加上柔性数组的大小。

假设这个柔性数组在结构体中的声明是int arr[0];，我想给这个数组的大小是40个字节，这样这个数组就能存储10个int，那么一开始malloc的大小就应该是sizeof(struct S)+10*sizeof(int)，具体的例子如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	return 0;
}

该结构体中的i,d,c等变量可以正常使用。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->i = 10;
	ps->d = 3.14;
	ps->c = 'F';

	return 0;
}

柔性数组也可以像正常的数组一样访问，比如把1~10放进去。注意此时这个数组的容量是10个int，不能越界访问。使用的例子如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->i = 10;
	ps->d = 3.14;
	ps->c = 'F';

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	return 0;
}

我们还可以对柔性数组扩容，如果我们想让这个柔性数组的容量是20个int，整个结构体的新的大小就是sizeof(struct S)+20*sizeof(int)，因为sizeof(struct S)是不考虑柔性数组的大小时计算的结构体大小。只需要对ps进行realloc就行了。实现代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->i = 10;
	ps->d = 3.14;
	ps->c = 'F';

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	struct S* tmp = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps = tmp;
	}

	return 0;
}

扩容后的柔性数组的空间更大了，我们可以把11~20都放进去。实现代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->i = 10;
	ps->d = 3.14;
	ps->c = 'F';

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	struct S* tmp = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps = tmp;
	}

	for (int i = 10; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}
	
	for (int i = 0; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	return 0;
}

当然最后别忘了free掉ps，否则会导致内存泄漏。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S) + 10 * sizeof(int));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->i = 10;
	ps->d = 3.14;
	ps->c = 'F';

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	struct S* tmp = (struct S*)realloc(ps, sizeof(struct S) + 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps = tmp;
	}

	for (int i = 10; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}
	
	for (int i = 0; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	free(ps);
	ps = NULL;

	return 0;
}

对于柔性数组的使用，在上面的例子中，可以总结出几个要点：

  1. malloc出来的大小是sizeof(struct S)加上柔性数组的大小，calloc同理。
  2. 扩容时realloc出来的新大小也是sizeof(struct S)加上柔性数组的新大小。
  3. 每次使用malloc和realloc等函数时，需要检查返回值，否则可能导致对NULL指针的解引用（这点是动态内存管理的常识了）。
  4. 一定要记得柔性数组的容量是多少，不要越界访问了，空间不够记得扩容。
  5. 记得free，防止内存泄漏。

三、柔性数组的内存分布

柔性数组是结构体的一个成员数组，在前面的例子中，整个结构体都是在堆上malloc出来的。此时，整个结构体都存储在堆上的一块连续的空间里，包括前面几个成员变量i,d,c和柔性数组arr。也就是这样：
在这里插入图片描述
只不过数组arr的大小是可以改变的，所以叫“柔性数组”。

有些朋友可能会说了，我不需要柔性数组也能实现类似这样的效果呀！我在结构体里存一个指针，指向一块malloc出来的空间，这块空间也是堆上的，可以动态管理。也就是说，像下面这样定义结构体：

struct S
{
	int i;
	double d;
	char c;
	int* arr;
};

这样似乎还简单一点，先malloc出一个struct S出来，malloc的大小就是sizeof(struct S)，像这样：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	return 0;
}

然后再malloc出10个int的大小出来，用结构体中的arr指针来管理这块空间，像这样：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		printf("2: malloc()->%s\n", strerror(errno));
		return 1;
	}

	return 0;
}

此时arr就可以当成一个数组来使用了，比如把1~10放进去。同样还是要注意不要越界访问。示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		printf("2: malloc()->%s\n", strerror(errno));
		return 1;
	}

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}
	
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	return 0;
}

你如果觉得空间不够，还可以扩容。比如，你可以把结构体中的arr进行realloc，新的大小能存放20个int。示例代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		printf("2: malloc()->%s\n", strerror(errno));
		return 1;
	}

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}
	
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	int* tmp = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps->arr = tmp;
	}

	return 0;
}

此时，你就可以把11~20也放进去。实现代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		printf("2: malloc()->%s\n", strerror(errno));
		return 1;
	}

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	int* tmp = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps->arr = tmp;
	}

	for (int i = 10; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	return 0;
}

最后别忘了把arr和ps都free掉，而且顺序不能错了。如果你先free掉了ps，结构体就没了，里面的arr就成为了野指针，内存就泄露了。实现代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int main()
{
	struct S* ps = (struct S*)malloc(sizeof(struct S));
	if (ps == NULL)
	{
		printf("malloc()->%s\n", strerror(errno));
		return 1;
	}

	ps->arr = (int*)malloc(10 * sizeof(int));
	if (ps->arr == NULL)
	{
		printf("2: malloc()->%s\n", strerror(errno));
		return 1;
	}

	for (int i = 0; i < 10; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 10; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");

	int* tmp = (int*)realloc(ps->arr, 20 * sizeof(int));
	if (tmp == NULL)
	{
		printf("realloc()->%s\n", strerror(errno));
		return 1;
	}
	else
	{
		ps->arr = tmp;
	}

	for (int i = 10; i < 20; i++)
	{
		ps->arr[i] = i + 1;
	}

	for (int i = 0; i < 20; i++)
	{
		printf("%d ", ps->arr[i]);
	}

	free(ps->arr);
	ps->arr = NULL;
	free(ps);
	ps = NULL;

	return 0;
}

那这种实现的内存分布是怎么样的呢？这个结构体是存储在堆上的，用ps来管理，结构体里的一个指针arr又指向了堆上的另一块空间，如下图：
在这里插入图片描述
这种实现方式和柔性数组的方式感觉差不多呀！都是在堆上有个结构体，结构体里有个大小可以变化的数组。那为什么非要搞出来个柔性数组的概念呢？那是因为，柔性数组有它独特的优势。

四、柔性数组的优势

前面我们先用柔性数组实现了一种效果，又不使用柔性数组实现了相似的效果，对比两种实现方式，我们可以做一些总结：

  1. 使用上：柔性数组malloc了一次，free了一次；不使用柔性数组要malloc两次，free两次。柔性数组的使用更加简单，不容易出错。如果不使用柔性数组，可能会忘记free掉结构体里的arr指针，导致内存泄漏。
  2. 效率上：柔性数组的存储空间是连续的，访问时效率更高。

所以，虽然有相似的效果，我更推荐使用柔性数组的方式。

五、总结

在这篇博客里，重点需要掌握以下几点：

  1. 如果结构体里最后一个成员变量是一个数组，并且大小可以变化，这个成员数组就叫做柔性数组。一个结构体里，除了柔性数组外必须至少有一个成员变量。
  2. 使用sizeof计算含有柔性数组的结构体大小时，只计算除柔性数组之外的空间大小。
  3. 使用柔性数组，比不使用柔性数组操作更加简单，不易出错，且效率更高。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/456495.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

全球首个 AI 软件工程师 Devin它来了！

全球首个 AI 软件工程师 Devin它来了！

如果您想每日获取AI最新新闻，欢迎关注文章底部的公众号 Cognition AI 发布 AI 软件工程师 Devin 初创公司 Cognition 近日发布公告，宣布推出全球首个 AI 软件工程师 Devin，并号称会彻底改变人类构建软件的方式。Devin 擅长长期推理能力，可以自主规划和完成软件项目，并在此…
阅读更多...
国产开源数据库厂商

国产开源数据库厂商

这是ren_dong的第36篇原创 前言 开源数据库即免费的社区数据库&#xff0c;其源代码可供公众使用&#xff0c;并且可以在其原始设计中进行修改或使用。开源数据库的流行示例包括 MySQL&#xff0c;PostgreSQL和MongoDB。 image 开源数据库用户托管数据库部署的方式有 内部部署、…
阅读更多...
mysql查看以及建立索引

mysql查看以及建立索引

现在mysql中有一张表journal_update_logs&#xff0c;数据量比较大&#xff0c;有3000多万条数据&#xff0c;现在查询比较慢&#xff0c;需要建立索引。 第一步&#xff0c;查看该表的索引&#xff1a; SHOW INDEX FROM journal_update_logs; 每张表都会有原始的主键索引PRIM…
阅读更多...
傅立叶之美：深入研究傅里叶分析背后的原理和数学

傅立叶之美：深入研究傅里叶分析背后的原理和数学

一、说明 T傅里叶级数及其伴随的推导是数学在现实世界中最迷人的应用之一。我一直主张通过理解数学来理解我们周围的世界。从使用线性代数设计神经网络&#xff0c;从混沌理论理解太阳系&#xff0c;到弦理论理解宇宙的基本组成部分&#xff0c;数学无处不在。 当然&#xff0c…
阅读更多...
叶顺舟:手机SoC音频趋势洞察与端侧AI技术探讨 | 演讲嘉宾公布

叶顺舟:手机SoC音频趋势洞察与端侧AI技术探讨 | 演讲嘉宾公布

后续将陆续揭秘更多演讲嘉宾&#xff01; 请持续关注&#xff01; 2024中国国际音频产业大会(GAS)将于2024年3.27 - 28日在上海张江科学会堂举办。大会将以“音无界&#xff0c;未来&#xff08;Audio&#xff0c; Future&#xff09;”为主题。大会由中国电子音响行业协会、上…
阅读更多...
报告合集 |2023年，5份必读的“数字孪生”行业报告合集（文末下载）

报告合集 |2023年，5份必读的“数字孪生”行业报告合集（文末下载）

数字孪生正在快速改变多个行业的面貌。它通过创建物理世界对象的虚拟复制&#xff0c;使得数据分析和系统优化能够在数字空间中实现&#xff0c;正在制造业、城市规划、医疗保健等国家支柱行业展现出巨大的变革力量&#xff0c;为行业的智能决策和预测提供了强大的支撑。 作为…
阅读更多...
mysql重构

mysql重构

力扣题目链接 列转行 SELECT product_id, store1 store, store1 price FROM products WHERE store1 IS NOT NULL UNION SELECT product_id, store2 store, store2 price FROM products WHERE store2 IS NOT NULL UNION SELECT product_id, store3 store, store3 price FROM p…
阅读更多...
基于大数据与时间序列预测的的书籍数据分析（内含spark+hive+mysql+kettle+echart+tensorflow）

基于大数据与时间序列预测的的书籍数据分析（内含spark+hive+mysql+kettle+echart+tensorflow）

目录 一&#xff0c;绪论 1、项目背景&#xff1a; 2、目标&#xff1a; 3、用户群体&#xff1a; 二&#xff0e;相关开发技术介绍 &#xff08;一&#xff09;后端相关技术 1.sparkSQL简介 2.kettle简介 3.tensorflow简介 &#xff08;二&#xff09;前端相关技术 1.HTML简介…
阅读更多...
【Python】新手入门学习：详细介绍依赖倒置原则（DIP）及其作用、代码示例

【Python】新手入门学习：详细介绍依赖倒置原则（DIP）及其作用、代码示例

【Python】新手入门学习&#xff1a;详细介绍依赖倒置原则&#xff08;DIP&#xff09;及其作用、代码示例 &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;Matplotlib之旅&#xff1a;零基础精通数据可视化、Python基础【高质量合集】、Py…
阅读更多...
MySQL索引原理及慢查询优化

MySQL索引原理及慢查询优化

背景 MySQL凭借着出色的性能、低廉的成本、丰富的资源&#xff0c;已经成为绝大多数互联网公司的首选关系型数据库。虽然性能出色&#xff0c;但所谓“好马配好鞍”&#xff0c;如何能够更好的使用它&#xff0c;已经成为开发工程师的必修课&#xff0c;我们经常会从职位描述上…
阅读更多...
【话题】2024年AI辅助研发趋势，有那些应用领域

【话题】2024年AI辅助研发趋势，有那些应用领域

大家好&#xff0c;我是全栈小5&#xff0c;欢迎阅读文章&#xff01; 此篇是【话题达人】系列文章&#xff0c;这一次的话题是《2024年AI辅助研发趋势》 目录 背景概念实践医药领域汽车设计领域展望未来文章推荐 背景 随着人工智能技术的持续发展与突破&#xff0c;2024年AI辅…
阅读更多...
使用CryptoJs对开发中的参数进行加密

使用CryptoJs对开发中的参数进行加密

场景描述 在开发程序中&#xff0c;我们无时无刻不在接受第三方的一些token&#xff0c;比如我们申请了地图软件的一些定位、导航功能&#xff0c;第三方会给予我们appid还有app secret作为访问他们服务的凭证&#xff0c;大部分时候我们会将求这些登陆凭证放在env文件中&…
阅读更多...
uniapp发行H5获取当前页面query

uniapp发行H5获取当前页面query

阅读uni的文档大致可得通过 onLoad与 onShow()的形参都能获取页面传递的参数&#xff0c;例如在开发时鼠标移动到方法上可以看到此方法的简短介绍 实际这里说的是打开当前页面的参数&#xff0c;在小程序端的时候测试并无问题&#xff0c;但是发行到H5时首页加载会造成参数获取…
阅读更多...
怎样基于“用户”思维让内容营销更有效

怎样基于“用户”思维让内容营销更有效

当下互联网流量见顶&#xff0c;内容已经成为互联网竞争新的制高点&#xff0c;可以说在数字化驱动的新时代下&#xff0c;“内容为王”仍然是真理。然后信息泛滥的时代下&#xff0c;如何让内容营销脱颖而出呢&#xff1f;媒介盒子认为“用户思维”是关键&#xff0c;今天就和…
阅读更多...
C/C++中strcpy，strcat，strstr以及strncpy，strncat，strncmp的使用

C/C++中strcpy，strcat，strstr以及strncpy，strncat，strncmp的使用

1、首先我们来介绍strcpy的使用从这个函数的名字来看它应该是属于字符串的拷贝&#xff0c;string copy。 那么这个函数是怎么用的呢&#xff1f;下面我么来介绍她的基本结构。 char * strcpy ( char * destination, const char * source );由上述可知它需要两部分 一个是目标字…
阅读更多...
操作系统——进程

操作系统——进程

1.什么是进程 概念&#xff1a; 进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动&#xff0c;是系统进行资源分配和调度的一个独立单位。 进程是程序的依次执行 进程是一个程序及其数据在处理机上顺序执行时所发生的活动 进程是程序在一个数据集合上运行的过…
阅读更多...
[剪藏] - 由哇哈哈和农夫山泉所想到的

[剪藏] - 由哇哈哈和农夫山泉所想到的

哇哈哈和农夫山泉的缠斗最近冒出来一个有趣的点&#xff1a;营销大于内容的胜利。 具体来说是这样的&#xff1a;农夫山泉很多年前做广告&#xff0c;说纯净水没有矿物质&#xff0c;长期喝是不利于人体健康的。农夫还做了个营销的对比实验&#xff0c;大概是用矿泉水养水仙花&…
阅读更多...
CMDB在IT管理中的重要性

CMDB在IT管理中的重要性

Configuration Management Database&#xff08;CMDB&#xff09;即配置管理数据库&#xff0c;在当前企业的IT运维管理中扮演着重要的角色。CMDB是一个包含了企业所有设备、软件和服务配置信息的中心数据库&#xff0c;通过有效地管理这些配置数据&#xff0c;能够为企业提供全…
阅读更多...
AIX7.2下安装mysql5.1.73数据库

AIX7.2下安装mysql5.1.73数据库

首先需要现在AIX版本的mysql安装包以及相关的依赖包 依赖关系deps文件下载地址&#xff1a; Index of /download/rpmdb/deplists/aix72 对应的rpm包下载地址&#xff1a; Index of /download/everything/RPMS 我们需要下载的mysql安装包主要有 mysql-5.1.73-1.ppc mysql…
阅读更多...
WanAndroid(鸿蒙版)开发的第五篇

WanAndroid(鸿蒙版)开发的第五篇

前言 DevEco Studio版本&#xff1a;4.0.0.600 WanAndroid的API链接&#xff1a;玩Android 开放API-玩Android - wanandroid.com 其他篇文章参考&#xff1a; 1、WanAndroid(鸿蒙版)开发的第一篇 2、WanAndroid(鸿蒙版)开发的第二篇 3、WanAndroid(鸿蒙版)开发的第三篇 …
阅读更多...
最新文章

Copyright @ 2022~2023