【C语言】浅谈代码运行效率及内存优化

news2024/12/24 0:23:26

【C语言】浅谈代码运行效率及内存优化

C语言作为一种高效率的编译语言 常用来写单片机等讲究时序性的设备
而只有代码优化得好 才能提高运行效率
当然这里的代码优化 并不是编译器优化 而是人为的代码习惯

文章目录

  • 代码效率
    • 条件判断
    • if else语句 抛弃边缘状态
    • 中断函数
      • 串口解析中断
  • 内存优化
    • 数据定义
    • 结构体
  • 附录：压缩字符串、大小端格式转换
    • 压缩字符串
      • 浮点数
      • 压缩Packed-ASCII字符串
    • 大小端转换
      • 什么是大端和小端
      • 数据传输中的大小端
      • 总结
      • 大小端转换函数

代码效率

条件判断

对于多级判断的函数 其效率排名如下：
switch>while>if else
所以 如果条件允许 则尽量采用switch来进行判断（除非只有0 1两种选择 可以直接用if else）
另外 用于braek的判断条件尽量放在while中 而不是if break

if else语句 抛弃边缘状态

if else可以用来判断比较复杂的情况 但为了提高效率 可以抛弃边缘状态来去掉else
所谓边缘状态也就是不常发生的状态

比如：
代码if(y>4 || y==0)后没有else 而正常情况下运行的代码放在if之后

uint32_t I2C_Read_y(I2C_HandleTypeDef *hi2c,uint16_t DevAddress,uint16_t add,uint16_t add_length,uint8_t y,bool prologue_flag)
{
	DevAddress=(DevAddress<<1)&0xFF;
	uint8_t pData[y];
	memset(pData,0,sizeof(pData));
	uint32_t dat=0;
	uint16_t MemAddSize=0;
	
	if(y>4 || y==0)
	{
		return 0;
	}
	
	if(prologue_flag)
	{
		switch(add_length)
		{
			case 1:MemAddSize=I2C_MEMADD_SIZE_8BIT;break;
			case 2:MemAddSize=I2C_MEMADD_SIZE_16BIT;break;
			default:MemAddSize=I2C_MEMADD_SIZE_8BIT;break;
		}
		HAL_I2C_Mem_Read(hi2c,DevAddress,add,MemAddSize,pData,y,0xFFFF);
	}	
	else
	{
		HAL_I2C_Master_Receive(hi2c,DevAddress,pData,y,0xFFFF);
	}
	
	for(uint8_t i=0;i<y;i++)
	{
		dat|=pData[i]<<(8*(y-1-i));
	}
	
	return dat;
}

同样的 多种状态判断时 也可以把比较容易发生的放在前面 则就不会一直判断else if
比如：

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{  
	if (htim == &htim4)
	{
		HART_Timer_Flag++;
		if(HART_Timer_Flag>=10)
		{
			HART_RxFlag=0;
			HART_Timer_Flag=10;
			HAL_TIM_Base_Stop_IT(&htim4);
		}
	}	
	else if (htim == &htim5)
	{
		GUI_Timer_Flag++;
		if(GUI_Timer_Flag>=10)
		{
			GUI_RxFlag=0;
			GUI_Status=0;
			GUI_Timer_Flag=10;
			HAL_TIM_Base_Stop_IT(&htim5);
		}
	}
	else if (htim == &htim2)
	{

	}	
	else if (htim == &htim3)
	{
		TIM3_CH2_Overflow++;
	}
}

中断函数

在中断函数中 不要调用任何阻塞、等待、延时、循环函数
中断函数的目的就是在完成某个任务时 触发中断 然后执行一部分代码后 跳出中断继续执行
所以需要尽可能的快
可以类比成一个线程 但运行此线程时 主线程会被打断

串口解析中断

在串口中断中 如果用了解析函数 则应采用状态机的方式进行 而真正的解析部分则放在主函数内完成
比如：

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
	if(huart==&huart2)
  {		
		switch(GUI_Status)
		{
			case 0:
			{
				if(GUI_RxBit==GUI_START0)
				{
					GUI_Status=1;					
				}
				GUI_RxFlag=0;
				break;
			}
			case 1:
			{
				if(GUI_RxBit==GUI_START1 && GUI_RxFlag==1)
				{
					GUI_Status=2;
				}
				else
				{
					GUI_Status=0;
					GUI_RxFlag=0;
				}
				break;
			}
			case 2:
			{
				if(GUI_RxFlag==3)
				{
					GUI_Data_Len=(GUI_RxBuffer[2]<<8)|GUI_RxBit;
					GUI_Status=3;
					if(!GUI_Data_Len)
					{
						GUI_Status=0;
						GUI_RxFlag=0;
					}
				}
				break;
			}
			case 3:
			{
				if(GUI_RxFlag==(GUI_Data_Len+9))
				{
					if(GUI_RxBit==GUI_STOP1 && GUI_RxBuffer[GUI_Data_Len+8]==GUI_STOP0)
					{
						GUI_Status=4;
					}
					else
					{
						GUI_Status=0;
						GUI_RxFlag=0;
					}
				}
				break;
			}
			default:break;
		}		
		
		GUI_RxBuffer[GUI_RxFlag]=GUI_RxBit;
		GUI_RxFlag++;
		GUI_RxBit=0;
		GUI_Timer_Flag=0;
		HAL_TIM_Base_Start_IT(&htim5);
		HAL_UART_Receive_IT(&huart2,&GUI_RxBit,1);
  }

内存优化

数据定义

数据定义则是用多大空间的数据 就定义多大（当然 内存对齐的数据除外）
在C语言基本库#include <stdint.h>中 将各种定义重新命令 比较方便直接阅读变量大小

typedef   signed          char int8_t;
typedef   signed short     int int16_t;
typedef   signed           int int32_t;
typedef   signed       __INT64 int64_t;

    /* exact-width unsigned integer types */
typedef unsigned          char uint8_t;
typedef unsigned short     int uint16_t;
typedef unsigned           int uint32_t;
typedef unsigned       __INT64 uint64_t;

    /* 7.18.1.2 */

    /* smallest type of at least n bits */
    /* minimum-width signed integer types */
typedef   signed          char int_least8_t;
typedef   signed short     int int_least16_t;
typedef   signed           int int_least32_t;
typedef   signed       __INT64 int_least64_t;

    /* minimum-width unsigned integer types */
typedef unsigned          char uint_least8_t;
typedef unsigned short     int uint_least16_t;
typedef unsigned           int uint_least32_t;
typedef unsigned       __INT64 uint_least64_t;

    /* 7.18.1.3 */

    /* fastest minimum-width signed integer types */
typedef   signed           int int_fast8_t;
typedef   signed           int int_fast16_t;
typedef   signed           int int_fast32_t;
typedef   signed       __INT64 int_fast64_t;

    /* fastest minimum-width unsigned integer types */
typedef unsigned           int uint_fast8_t;
typedef unsigned           int uint_fast16_t;
typedef unsigned           int uint_fast32_t;
typedef unsigned       __INT64 uint_fast64_t;

结构体

在结构体定义时 通常会由于编译器优化 浪费掉一些空间
比如：

typedef struct 
{
	float Damping_Time;		//阻尼时间
	uint8_t Unit_Code;		//主单位变量
	float Range;		//量程
	float Blind;					//盲区范围
	float Fixed_Current_Mode;		//固定电流模式	
	uint8_t HART_Mode;			//HART模式（HART地址）	
	uint8_t Current_Mode[3];		//电流模式 GUI_Current_Mode 三个字节分别控制是否输出电流、4-20mA还是20-4mA、报警模式
}GUI_Unique_Value_Struct;

该结构体中 有float类型 也有uint8类型 如果你打印过每个变量的地址 不难发现 Damping_Time为地址0 Unit_Code为地址4 Range为地址8
这是由于编译器优化后 将每个变量尽量按相同的间距排列 但这样无疑会浪费空间
所以：
采用#pragma pack(1)语句告诉编译器这里要按1B对齐（就是两个变量之间的间隔最小为1） 可以减少空间浪费

#pragma pack(1)
typedef struct 
{
	float Damping_Time;		//阻尼时间
	uint8_t Unit_Code;		//主单位变量
	float Range;		//量程
	float Blind;					//盲区范围
	float Fixed_Current_Mode;		//固定电流模式	
	uint8_t HART_Mode;			//HART模式（HART地址）	
	uint8_t Current_Mode[3];		//电流模式 GUI_Current_Mode 三个字节分别控制是否输出电流、4-20mA还是20-4mA、报警模式
}GUI_Unique_Value_Struct;
#pragma pack()

最后在结尾也要加上#pragma pack() 告诉编译器这里取消了对齐

如果用memcpy等函数 则一定要对齐以后才能复制 不然可能会出现数据错误的问题

附录：压缩字符串、大小端格式转换

压缩字符串

首先HART数据格式如下：
在这里插入图片描述
在这里插入图片描述
重点就是浮点数和字符串类型
Latin-1就不说了 基本用不到

浮点数

浮点数里面 如 0x40 80 00 00表示4.0f

在HART协议里面 浮点数是按大端格式发送的 就是高位先发送 低位后发送

发送出来的数组为：40,80,00,00

但在C语言对浮点数的存储中 是按小端格式来存储的 也就是40在高位 00在低位
浮点数：4.0f
地址0x1000对应00
地址0x1001对应00
地址0x1002对应80
地址0x1003对应40

若直接使用memcpy函数 则需要进行大小端转换 否则会存储为：
地址0x1000对应40
地址0x1001对应80
地址0x1002对应00
地址0x1003对应00

大小端转换：

void swap32(void * p)
{
   uint32_t *ptr=p;
   uint32_t x = *ptr;
   x = (x << 16) | (x >> 16);
   x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);

   *ptr=x;
}

压缩Packed-ASCII字符串

本质上是将原本的ASCII的最高2位去掉 然后拼接起来 比如空格(0x20)
四个空格拼接后就成了
1000 0010 0000 1000 0010 0000
十六进制：82 08 20
对了一下表 0x20之前的识别不了
也就是只能识别0x20-0x5F的ASCII表
在这里插入图片描述

压缩/解压函数后面再写：

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_ASCII_to_Pack(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
   if(str_len%4)
   {
      return 0;
   }
	 
   uint8_t i=0;
   memset(buf,0,str_len/4*3);	  
   for(i=0;i<str_len;i++)
   {
      if(str[i]==0x00)
      {
         str[i]=0x20;
      }
   }

   for(i=0;i<str_len/4;i++)
   {
      buf[3*i]=(str[4*i]<<2)|((str[4*i+1]>>4)&0x03);
      buf[3*i+1]=(str[4*i+1]<<4)|((str[4*i+2]>>2)&0x0F);
      buf[3*i+2]=(str[4*i+2]<<6)|(str[4*i+3]&0x3F);
   }

   return 1;
}

//传入的字符串和数字必须提前声明 且字符串大小至少为str_len 数组大小至少为str_len%4*3 str_len必须为4的倍数
uint8_t Trans_Pack_to_ASCII(uint8_t * str,uint8_t * buf,const uint8_t str_len)
{
   if(str_len%4)
   {
      return 0;
   }

   uint8_t i=0;

   memset(str,0,str_len);

   for(i=0;i<str_len/4;i++)
   {
      str[4*i]=(buf[3*i]>>2)&0x3F;
      str[4*i+1]=((buf[3*i]<<4)&0x30)|(buf[3*i+1]>>4);
      str[4*i+2]=((buf[3*i+1]<<2)&0x3C)|(buf[3*i+2]>>6);
      str[4*i+3]=buf[3*i+2]&0x3F;
   }

   return 1;
}

大小端转换

在串口等数据解析中 难免遇到大小端格式问题

什么是大端和小端

所谓的大端模式，就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

所谓的小端模式，就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

简单来说：大端——高尾端，小端——低尾端

举个例子，比如数字 0x12 34 56 78在内存中的表示形式为：

1)大端模式：

低地址 -----------------> 高地址

0x12 | 0x34 | 0x56 | 0x78

2)小端模式：

低地址 ------------------> 高地址

0x78 | 0x56 | 0x34 | 0x12

可见，大端模式和字符串的存储模式类似。

数据传输中的大小端

比如地址位、起止位一般都是大端格式
如：
起始位：0x520A
则发送的buf应为{0x52,0x0A}

而数据位一般是小端格式（单字节无大小端之分）
如：
一个16位的数据发送出来为{0x52,0x0A}
则对应的uint16_t类型数为： 0x0A52

而对于浮点数4.0f 转为32位应是：
40 80 00 00

以大端存储来说 发送出来的buf就是依次发送 40 80 00 00

以小端存储来说 则发送 00 00 80 40

由于memcpy等函数 是按字节地址进行复制 其复制的格式为小端格式 所以当数据为小端存储时 不用进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x00,0x00,0x80,0x40};
   memcpy(&dat,buf,4);
   float f=0.0f;
   f=*((float*)&dat); //地址强转
   printf("%f",f);

或更优解：

   uint8_t buf[]={0x00,0x00,0x80,0x40};   
   float f=0.0f;
   memcpy(&f,buf,4);

而对于大端存储的数据（如HART协议数据 全为大端格式） 其复制的格式仍然为小端格式 所以当数据为小端存储时 要进行大小端转换
如：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};
   memcpy(&dat,buf,4);
   float f=0.0f;
   swap32(&dat); //大小端转换
   f=*((float*)&dat); //地址强转
   printf("%f",f);

或：

uint8_t buf[]={0x40,0x80,0x00,0x00};
   memcpy(&dat,buf,4);
   float f=0.0f;
   swap32(&f); //大小端转换
   printf("%f",f);

或更优解：

uint32_t dat=0;
uint8_t buf[]={0x40,0x80,0x00,0x00};
   float f=0.0f;
   dat=(buf[0]<<24)|(buf[0]<<16)|(buf[0]<<8)|(buf[0]<<0)
   f=*((float*)&dat);

总结

固 若数据为小端格式 则可以直接用memcpy函数进行转换 否则通过移位的方式再进行地址强转

对于多位数据 比如同时传两个浮点数 则可以定义结构体之后进行memcpy复制（数据为小端格式）

对于小端数据 直接用memcpy写入即可 若是浮点数 也不用再进行强转

对于大端数据 如果不嫌麻烦 或想使代码更加简洁（但执行效率会降低） 也可以先用memcpy写入结构体之后再调用大小端转换函数 但这里需要注意的是 结构体必须全为无符号整型 浮点型只能在大小端转换写入之后再次强转 若结构体内采用浮点型 则需要强转两次

所以对于大端数据 推荐通过移位的方式来进行赋值 然后再进行个别数的强转 再往通用结构体进行写入

多个不同变量大小的结构体 要主要字节对齐的问题
可以用#pragma pack(1) 使其对齐为1
但会影响效率

大小端转换函数

直接通过对地址的操作来实现 传入的变量为32位的变量
中间变量ptr是传入变量的地址

void swap16(void * p)
{
   uint16_t *ptr=p;
   uint16_t x = *ptr;
   x = (x << 8) | (x >> 8);

   *ptr=x;
}

void swap32(void * p)
{
   uint32_t *ptr=p;
   uint32_t x = *ptr;
   x = (x << 16) | (x >> 16);
   x = ((x & 0x00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF);

   *ptr=x;
}

void swap64(void * p)
{
   uint64_t *ptr=p;
   uint64_t x = *ptr;
   x = (x << 32) | (x >> 32);
   x = ((x & 0x0000FFFF0000FFFF) << 16) | ((x >> 16) & 0x0000FFFF0000FFFF);
   x = ((x & 0x00FF00FF00FF00FF) << 8) | ((x >> 8) & 0x00FF00FF00FF00FF);

   *ptr=x;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

算法基础学习|排序

算法基础学习|排序

快速排序 模板 void quick_sort(int q[], int l, int r) {if (l > r) return;int i l - 1, j r 1, x q[l r >> 1];while (i < j){do i ; while (q[i] < x);do j -- ; while (q[j] > x);if (i < j) swap(q[i], q[j]);}quick_sort(q, l, j)&#xf…
阅读更多...
希尔排序（C++实现）

希尔排序（C++实现）

文章目录 前言1. 基础概念2. 动图演示3. 代码实现4. 排序过程5. 效率分析6. 总结 前言 上篇文章讲了直接插入排序算法。 首先&#xff0c;在待排序的数组中&#xff0c;元素本身就是有序的情况下&#xff0c;就不需要移动任何元素&#xff0c;所以直接插入排序最好情况时间复…
阅读更多...
Javascript 事件的动态绑定

Javascript 事件的动态绑定

动态绑定事件&#xff0c;是指在代码执行过程中&#xff0c;通过Javascript代码来绑定事件。这种技术可以大大增强网页的交互性和用户体验。上一期介绍的是通过事件监听器 EventListener 去实现元素颜色的变化。这一期将通过动态绑定方法去实现&#xff0c;对象.事件 匿名函数…
阅读更多...
POST注入 | 盲注 | 宽字节注入

POST注入 | 盲注 | 宽字节注入

魔术引号&#xff1a;
阅读更多...
哈希/散列--哈希表[思想到结构]

哈希/散列--哈希表[思想到结构]

文章目录 1.何为哈希?1.1百度搜索1.2自身理解1.3哈希方法/散列方法1.4哈希冲突/哈希碰撞1.5如何解决?哈希函数的设计 2.闭散列和开散列2.1闭散列/开放定址法2.2开散列/链地址法/开链法1.概念2.容量问题 3.代码实现[配备详细注释]3.1闭散列3.2开散列 1.何为哈希? 1.1百度搜索…
阅读更多...
【工具】idea 设置自动渲染注释

【工具】idea 设置自动渲染注释

前言 需求&#xff1a;自动渲染文档注释&#xff0c;看源码更加舒服。 已知 crtl alt Q 可以 设置 尝试搜索 render&#xff0c;发现有启用 “渲染文档注释” 的地方 坐标 &#xff1a; Settings -> Editor-> Appearance
阅读更多...
CSS3与HTML5

CSS3与HTML5

box-sizing content-box&#xff1a;默认&#xff0c;宽高包不含边框和内边距 border-box&#xff1a;也叫怪异盒子&#xff0c;宽高包含边框和内边距 动画&#xff1a;移动translate&#xff0c;旋转、transform等等 走马灯&#xff1a;利用动画实现animation&#xff1a;from…
阅读更多...
分布式锁：jvm本地加锁解决商品超卖的方案

分布式锁：jvm本地加锁解决商品超卖的方案

一 分布式锁 1.1 分布式锁的作用 在多线程高并发场景下&#xff0c;为了保证资源的线程安全问题&#xff0c;jdk为我们提供了synchronized关键字和ReentrantLock可重入锁&#xff0c;但是它们只能保证一个工程内的线程安全。在分布式集群、微服务、云原生横行的当下&#xff…
阅读更多...
python二次开发CATIA：根据已知数据点创建曲线

python二次开发CATIA：根据已知数据点创建曲线

已知数据点存于Coords.txt文件如下&#xff1a; 8.67155477658819,20.4471021292557,0 41.2016126836927,20.4471021292557,0 15.9568941320569,-2.93388599177698,0 42.2181532110364,-6.15301746150354,0 43.0652906622083,-26.4843096139083,0 -31.6617679595947,-131.1513…
阅读更多...
Java基本数据类型和变量

Java基本数据类型和变量

目录 一、基本数据类型 1.1 整型 1.1.1 byte 1.1.2 short 1.1.3 int 1.1.4 long 1.2 浮点型 1.2.1 float 1.2.2 double 1.3 字符型 1.4 布尔型 二、变量 2.1 变量的概念 2.2 语法格式 2.3 整型变量 2.3.1 整型变量 2.3.2 长整型变量 2.3.3 短整型变量 2.3.…
阅读更多...
【Unity2022】Unity实现在两个物体之间连出一条线

【Unity2022】Unity实现在两个物体之间连出一条线

文章目录 Line Renderer组件添加Line Renderer组件重要属性Positions&#xff08;位置&#xff09;Width &#xff08;宽度&#xff09;Material&#xff08;材质&#xff09;其他属性 使用脚本绘制直线绳子运行结果其他文章 Line Renderer组件 我们可以使用LineRenderer组件来…
阅读更多...
【GO 编程语言】面向对象

【GO 编程语言】面向对象

指针与结构体 文章目录 指针与结构体一、OOP 思想二、继承三、方法 一、OOP 思想 Go语言不是面向对象的语言&#xff0c;这里只是通过一些方法来模拟面向对象&#xff0c;从而更好的来理解面向对象思想 面向过程的思维模式 1.面向过程的思维模式是简单的线性思维&#xff0c;…
阅读更多...
苹果电脑壁纸软件Irvue for mac激活

苹果电脑壁纸软件Irvue for mac激活

Irvue是一款Mac上的壁纸软件&#xff0c;里面包含了数千张来精彩照片&#xff0c;方便用户将喜欢的照片设置为壁纸。以下是Irvue软件的一些主要特点和功能&#xff1a; 丰富的壁纸资源&#xff1a;Irvue提供了数千张来自Unsplash的高分辨率照片&#xff0c;涵盖了风景、建筑、…
阅读更多...
【前段基础入门之】=＞元素定位布局

【前段基础入门之】=＞元素定位布局

导语&#xff1a; CSS 元素定位&#xff0c;是目前 CSS 页面布局的一种主要方式。 文章目录 相对定位开启相对定位相对定位的参考点相对定位的特点 绝对定位开启绝对定位绝对定位的参考点绝对定位的特点 固定定位开启固定定位固定定位的参考点固定位的特点 粘性定位开启粘性定位…
阅读更多...
详解C语言—编译与链接

详解C语言—编译与链接

目录 1、程序的翻译环境 2、C语言程序的编译链接 3、程序执行的过程&#xff1a; 1、程序的翻译环境 在ANSI C标准的任何一种实现中&#xff0c;存在两个不同的环境。 第1种是翻译环境&#xff0c;在这个环境中源代码被转换为可执行的机器指令。 第2种是执行环境&#xff0…
阅读更多...
基于SSM的电动车上牌管理系统（有报告）。Javaee项目。

基于SSM的电动车上牌管理系统（有报告）。Javaee项目。

演示视频&#xff1a; 基于SSM的电动车上牌管理系统&#xff08;有报告&#xff09;。Javaee项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通过Spring SpringM…
阅读更多...
【3】c++设计模式——＞UML表示类之间的关联关系

【3】c++设计模式——＞UML表示类之间的关联关系

关联关系 关联&#xff08;Assocition&#xff09;关系是类与类之间最常见的一种关系&#xff0c;它是一种结构化的关系&#xff0c;表示一个对象与另一个对象之间有联系&#xff0c;如汽车和轮胎、师傅和徒弟、班级和学生等。在UML类图中&#xff0c;用&#xff08;带接头或不…
阅读更多...
JVM篇---第一篇

JVM篇---第一篇

系列文章目录 文章目录 系列文章目录一、知识点汇总二、知识点详解：三、说说类加载与卸载一、知识点汇总 JVM是Java运行基础,面试时一定会遇到JVM的有关问题,内容相对集中,但对只是深度要求较高. 其中内存模型,类加载机制,GC是重点方面.性能调优部分更偏向应用,重点突出实践…
阅读更多...
专业图标制作软件 Image2icon 最新中文 for mac

专业图标制作软件 Image2icon 最新中文 for mac

Image2Icon是一款用于Mac操作系统的图标转换工具。它允许用户将常见的图像文件&#xff08;如PNG、JPEG、GIF等&#xff09;转换为图标文件&#xff08;.ico格式&#xff09;&#xff0c;以便在Mac上用作应用程序、文件夹或驱动器的自定义图标。 以下是Image2Icon的一些主要功…
阅读更多...
基于vc6+sdk51开发简易文字识别转语音的程序

基于vc6+sdk51开发简易文字识别转语音的程序

系统&#xff1a;window7 软件&#xff1a;vc6.0 目的&#xff1a;简易文字转语音真人发声 利用2023国庆小长假&#xff0c;研究如何将文言转语音&#xff0c;之前在网上查询相关知识&#xff0c;大致了解微信语音转换&#xff0c;翻译官之类软件的原理&#xff0c;但要加入神…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023