string奇怪引用计数器

最新推荐文章于 2025-05-20 11:16:01 发布
最新推荐文章于 2025-05-20 11:16:01 发布
阅读量328 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： iOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaoyuqiang30/article/details/50082681
探讨在Objective-C中使用initWithFormat初始化字符串时，字符串的retainCount在不同情况下出现的异常现象，揭示其背后的原因。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

<pre name="code" class="objc">NSString *s = [[NSString alloc] initWithFormat:@"%@_%@124_", @"dd", @"ff"];
NSLog(@"s:%ld",[s retainCount]); // 结果-1



NSString *s = [[NSString alloc] initWithFormat:@"%@_%@124_fffff", @"dd", @"ff"];
NSLog(@"s:%ld",[s retainCount]); // 结果1


按理说 initWithFormat的字符串的retainCount是1，需要手动release的。可是当字符串短的时候仍为-1！！！！！！太奇怪了！！！



                

        

    

    
  



    



                



	

		

			

				
					
java-计数器

				
			

			

				

					阿里Darker
				

				

					06-07
					
					854
					
				

			

		

		

			
				
第一种，最直观的计数器 
每次循环都去检查Map中是否包含Key，如果包含则将原值+1再保存，如果不存在，则直接保存1.这种方式是最简单直接的一种方式，但是并不是最有效的方式，其低效的原因： 
1、如果已经存在某个key(a)，containsKey()和get()方法会扫描Map两次2、由于Integer是不可变对象，因此每次循环，都会创建一个新的对象放到Map中。public void naiv

			
		

	



                

            
              



	

		

			

				
					
6、Perl编程：哈希锁定、类型转换、包与引用详解

					
最新发布

				
			

			

				

					gin88的博客
				

				

					07-07
					
					8
					
				

			

		

		

			
				
本文深入解析了Perl编程中的关键概念，包括哈希锁定、类型转换、包与引用的使用方法。通过详细示例代码和实战案例，如用户管理系统的构建，帮助开发者更好地理解如何高效、安全地编写Perl代码。无论是初学者还是经验丰富的开发者，都能从中获得实用的编程技巧和最佳实践。

			
		

	



              


  
              

                


	

		

			

				
					
奇怪的计算器

				
			

			

				

					weixin_30376083的博客
				

				

					11-12
					
					256
					
				

			

		

		

			
				
奇怪的计算器

计科专业的小明最近得到一个任务，去修理一台奇怪的计算器，这个计算器输出的结果是颠倒的，比如123它输出321，遇到小数点的时候，整数和小数部分分别是颠倒的，比如123.456显示成321.654，请编写一个程序，将输出的结果修正。
输入
首先输入一个整数N，然后输入N行，每一行是一个计算器的输出。
输出
依次输出每个值正确的值
输入示范
...

			
		

	





	

		

			

				
					
【String】引用计数实现String

				
			

			

				

					ruan875417的专栏
				

				

					11-29
					
					792
					
				

			

		

		

			
				
String.h
#ifndef STRING_H
#define STRING_H
#define _CRT_SECURE_NO_WARNINGS
#include
//String
class String{
public:
	String(const char* str = NULL);//constructor
	String(const String& rhs);//copy cons

			
		

	



		

			
		



	

		

			

				
					
C++ String的引用计数、写时复制 的实现 《More Effective C++》

				
			

			

				

					qq_44664843的博客
				

				

					06-10
					
					618
					
				

			

		

		

			
				
文章目录1.引用计数2.写时复制
1.引用计数
c++引用计数的可以节省内存，而且同时可以降低构建对象和析构的开销，所谓引用计数简单说来就是对各对象共享一份实体的数据，但是我们需要实现对该数据的引用的对象的记录，这样最后一个对象引用结束后能够安全的删除数据。
用字符串举例，假设我们想要实现字符串的拷贝或者赋值，那么我们想要呈现的客户的是各自独立的字符串。如下：

但是，对于计算机的内部实现而言，这样的方式显然出现了冗余存储的现象，那么我们期待计算机内部是这样实现的。

这样所有的用户拥有的字符串都是同一个，

			
		

	





	

		

			

				
					
String类之引用计数和写时拷贝

				
			

			

				

					qq_39412582的博客
				

				

					08-14
					
					327
					
				

			

		

		

			
				
string 类写到这里已经是升级版了，大家能看懂多少算多少，在面试的时候尽量不要给面试官说你懂这个，万一把自己搞糊涂了，岂不是得不偿失。 
好了 ，废话到此结束，正文开始。

引用计数

我们知道，在浅拷贝当中，由于多个对象共用同一块空间，最后释放内存的时候导致同一块内存多次释放而出现问题，那么问题来了，能否保证当多个对象共同使用同一块空间时，该空间只释放一次？ 
答案当然是可以的了。 
引用计...

			
		

	





	

		

			

				
					
jvm内存模型、调优、四种引用状态、内存泄漏、内存溢出

				
			

			

				

					qq_42674061的博客
				

				

					03-03
					
					466
					
				

			

		

		

			
				
1、jvm内存模型
Java中通过多线程机制使得多个任务同时执行处理，所有的线程共享JVM内存区域main memory，而每个线程又单独的有自己的工作内存，当线程与内存区域进行交互时，数据从主存拷贝到工作内存，进而交由线程处理
根据JVM规范，JVM 内存共分为虚拟机栈，堆，方法区，程序计数器，本地方法栈五个部分。

1.1、 程序计数器
程序计数器（Program Counter Register）是一块较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里（仅是概念模型，

			
		

	





	

		

			

				
					
17、Python 动态类型机制全解析

				
			

			

				

					bean的博客
				

				

					05-20
					
					3
					
				

			

		

		

			
				
本文深入解析了 Python 的动态类型机制，详细介绍了变量与对象的引用关系、类型关联、垃圾回收原理以及共享引用的影响。同时探讨了动态类型在函数参数传递、模块导入和循环变量中的实际应用，并分析了其优缺点。最后提供了动态类型编程的最佳实践建议，帮助开发者更好地理解和使用 Python 的动态类型特性。

			
		

	





	

		

			

				
					
Java 字节码技术：不积细流，无以成江河

				
			

			

				

					KimmKing的技术博客
				

				

					09-22
					
					725
					
				

			

		

		

			
				
Java 中的字节码，英文名为 bytecode, 是 Java 代码编译后的中间代码格式。JVM 需要读取并解析字节码才能执行相应的任务。
从技术人员的角度看，Java 字节码是 JVM 的指令集。JVM 加载字节码格式的 class 文件，校验之后通过 JIT 编译器转换为本地机器代码执行。 简单说字节码就是我们编写的 Java 应用程序大厦的每一块砖，如果没有字节码的支撑，大家编写的代码也就...

			
		

	





	

		

			

				
					
【Java多线程】并发编程不得不知的重要概念(持续更新)

				
			

			

				

					墩墩分墩
				

				

					07-24
					
					933
					
				

			

		

		

			
				
1. 串行：一个线程执行到底，相当于单线程。
2. 并发：多个线程交替执行，抢占cpu的时间片，但是速度很快，在外人看来就像是多个线程同时执行。
3. 并行：多个线程在不同的cpu中同时执行。

			
		

	





	

		

			

				
					
String浅拷贝---引用计数

				
			

			

				

					wanglelelihuanhuan的专栏
				

				

					04-16
					
					762
					
				

			

		

		

			
				
当类里面有指针对象时，进行简单赋值的浅拷贝，两个对象指向同一块内存，存在崩溃的问题！为了解决这个问题，我们可以采用引用计数。
在引用计数中，每一个对象负责维护对象所有引用的计数值。当一个新的引用指向对象时，引用计数器就递增，当去掉一个引用时，引用计数就递减。当引用计数到零时，该对象就将释放占有的资源。
#include
#include
#include
using namespace std

			
		

	





	

		

			

				
					
奇怪的计数器

				
			

			

				

					iQUEEN的专栏
				

				

					02-09
					
					822
					
				

			

		

		

			
				
申请了ygie计数器，可是为什么在csdn里面附带一个gougou的计数器给我呢？

			
		

	





	

		

			

				
					
string类的写时拷贝与引用计数

				
			

			

				

					Ego_Bai的博客
				

				

					10-17
					
					511
					
				

			

		

		

			
				
由于浅拷贝使多个对象共用一块内存地址，调用析构函数时导致一块内存被多次释放，导致程序奔溃。实现string类的时候通常显示的定义拷贝构造函数和运算符重载函数。由于释放内存空间，开辟内存空间时花费时间，因此，在我们不需要写，只是读的时候就可以不用新开辟内存空间，就用浅拷贝的方式创建对象，当我们需要写的时候才去新开辟内存空间。这种方法就是写时拷贝。在构造函数中开辟新的空间时多开辟4个字节的空间，用来存放

			
		

	





	

		

			

				
					
c++ string类实现(实现了引用计数)

				
			

			

				

					qq_18226379的专栏
				

				

					12-27
					
					847
					
				

			

		

		

			
				
为了实现引用技术，想必大家都考虑过如下几种方法
1. 使用非静态成员变量（int类型）计数器, 此方法导致每个类都拥有一个独立的计数器， 而在对象进行拷贝时， 新对象可能需要对原有计数器进行引用并修改其值，这就导致了计数器之间缺乏共通性
2.使用静态成员计数器， 此方法虽然解决了对象直接的共通性， 但导致的结果是我们在定义两个不同的对象,如String("1111")和 String("222

			
		

	





	

		

			

				
					
C++ 简易string类实现（二）-引用计数

				
			

			

				

					HappyKocola的博客
				

				

					05-16
					
					990
					
				

			

		

		

			
				
引用计数（reference count），允许多个等值对象共享一个实值，此技术的发展有两个动机.第一，简化heap object的簿记工作，在程序执行过程中，对象的拥有权可以会转移，记录对象的拥有权不是一件简单的事情，其次，在对象没有使用者时，需要自动销毁自己，避免内存泄露；第二，如果多个对象拥有相同的值，那么将那个值存储多次往往是件愚蠢的事情，最好的做法是，让所有等值对象共享一份实值就好，这么做

			
		

	





	

		

			

				
					
基于引用计数的String类实现

				
			

			

				

					王学门徒
				

				

					05-13
					
					315
					
				

			

		

		

			
				
class String
{
public:
	//构造函数
	String(const char *str = "")
	{
		m_data = new char[strlen(str)+1];
		strcpy(m_data, str);
	}
	//拷贝构造函数
	String(const String &s)
	{
		m_data = new char[strlen(s.m_data)+1];
		strcpy(m_data, s.m_data);
	}
	//赋值函数
	String&

			
		

	





	

		

			

				
					
c++ STL  string的引用计数

				
			

			

				

					
				

				

					09-06
					
					245
					
				

			

		

		

			
				
STL string的引用计数,多个通过拷贝构造和复制操作具有相同值的string共享一块内存,由引用计数该参数保存共享内存的string个数,  通过写时拷贝防止修改共享内存的值. 
但是,如果强制转换可能会引起共享内存被修改,例如 
std::string str1 = "共享内存";...

			
		

	





	

		

			

				
					
引用计数型String类的简单实现

				
			

			

				

					weixin_33713707的博客
				

				

					12-14
					
					166
					
				

			

		

		

			
				
利用”引用计数”和”写时复制”这两个特点来实现一个字符串类,为了更好地隐藏类的实现,避免出现下述情况:当对于内联函数定义的改动,对于对象成员大小的改动等导致程序的重新编译,我们可以的代码结构如下:
   我们在程序中维护两个不同的头文件,在提供给用户使用的那个公共头文件中,只是告诉用户我们定义了String_ref这个类,并且在String对象中用...

			
		

	





	

		

			

				
					
c++ string之引用计数的学习使用

				
			

			

				

					a499957739的博客
				

				

					03-31
					
					1489
					
				

			

		

		

			
				
之前做数据结构课设的时候写了一个string类，当时是为了达到工作量的要求，没怎么深入了解string类，稀里糊涂就写了出来，今天拿出来看了下发现写的好懒，于是今天修改了一下，拿出来凉一凉。。。
头文件如下：
#ifndef STRING_H
#define STRING_H

#include 
/*
分配在堆中的每一块内存都同时分配一个引用计数每次释放内存时检查引用计数，
若当前是指向内存

			
		

	





	

		

			

				
					
/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2025 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "can.h"
#include "gpio.h"
#include "string.h"
#include "stm32f4xx_hal.h"
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
typedef struct 
    {   
        uint8_t data[16]; // 直接使用 16 字节的数组填充构成 16字节的结构体
    }CAN_struct;//储存发送或接收的16字节数据
typedef union
    {
	    float a;
	    uint8_t megt[16];//megt 无符号字符数组成员名，在共用体里和float类型成员共享内存，实现浮点数与字节数组的转换（硬件不能直接解析，逐字节发送再转换成float；必须把float拆成字节数组填入，接收方再按协议还原）
    }Unionfloat;
typedef union//16字节结构体与字节数组转换，让数据适配硬件通信，存储，协议，（与上述float类似）
    {
        CAN_struct DATAStruct;//共用体成员名
        uint8_t send[16];
    }Union_struct;
	

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
CAN_RxHeaderTypeDef Rxhader;     //Rxhader：存储接收到的 CAN 消息的头部信息（说明书身份卡）（告诉系统谁发的，发给谁，ID,标准帧，扩展帧，DLC，远程帧标记，反馈错误状态，时间戳）
uint8_t RxData[8];               //RxData：用于存储接收到的 CAN 数据
float receivedFloat;             //receivedFloat：用于存储接收到的浮点数
uint8_t rxframer=0;              //rxframer：用于标记是否接收到完整的16字节数据。防止数据丢包错位，数据越界，解析乱码//rxframer为0（未收全）为1（收全）【后面先判断是否为1，再决定是否解析数据】
uint8_t structBuffer[16]={0};    //structBuffer：用于存储接收到的16字节结构体数据。数组所有元素初始化为0，不会被旧数据干扰
uint8_t buffer[8];               //buffer：用于临时存储接收到的8字节数据。防止没处理完数据就丢了
Unionfloat receiveunionfloat;    //receiveunionfloat：用于将接收到的字节数组转换为浮点数。
Union_struct receiveunionstruct; //receiveunionstruct：用于将接收到的字节数组转换为16字节结构体。
CAN_struct receiveStruct;        //receiveStruct：用于存储接收到的16字节结构体数据。
CAN_struct h;                    //h：用于存储要发送的16字节结构体数据。

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
void MyCAN_Transmit_struct(CAN_struct* shuatment);
void MyCAN_Transmit_Float(float data);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void MyCAN_Transmit_Float(float data)     //发送浮点数data
{
	Unionfloat transmitUnionfloat;        //共用体定义变量transmitUnionfloat
	transmitUnionfloat.a=data;            //data赋值给联合体成员a，transmitUnionfloat.megt就会存储对应浮点数的字节形式，实现浮点数到字节数组的转换
	uint32_t TxMailbox;                   //存储CAN发送邮箱编号，HAL_CAN_AddTxHeaderTypeDef会用到，告知数据放到哪个发送邮箱
	uint32_t TimeOut=0;                   //初始化超时计数器为0
	CAN_TxHeaderTypeDef TxMessage;        //CAN_TxHeaderTypeDef类型结构体，用来配置CAN发送报文的头部信息（ID，数据长度，帧类型）
	 //配置CAN发送头部信息
	TxMessage.StdId = 0x555;
	TxMessage.ExtId = 0x0000;
	TxMessage.IDE = CAN_ID_STD;
	TxMessage.RTR = CAN_RTR_DATA;         //浮点型用数据帧
	TxMessage.DLC = 4;                    //浮点数转4字节数据
	TxMessage.TransmitGlobalTime = DISABLE;//关闭全局时间戳功能，发送报文时不附加全局时间信息
	//把配置好的报文（TxMessage）和要发送的数据（transmitUnionfloat.megt浮点数转字节数组）放到hcan1对应的CAN外设发送邮箱（TxMailbox），函数返回HAL_StatusTypeDef类型状态
	HAL_StatusTypeDef state=HAL_CAN_AddTxMessage(&hcan1, &TxMessage,transmitUnionfloat.megt , &TxMailbox);//状态（发送邮箱）
	while(state!= HAL_OK)           //state!= HAL_OK放入邮箱失败，进入循环重新尝试/检测超时       //HAL_OK成功放入邮箱等待发送
	{
		TimeOut++;
		if (TimeOut > 100000)       //计数器超过100000，认为发送失败，跳出循环
		{
			break;
		}
	}
	
}
//发送16字节结构体数据
void MyCAN_Transmit_struct(CAN_struct* shuatment)     //参数是CAN_struct类型指针shuatment，接收要发送的结构体数据，发送出去
{
	uint32_t TimeOut=0;
	uint32_t TxMailbox;
	Union_struct tx_struct;          //Union_struct类型变量定义tx_struct   //sizeof(CAN_struct)确保拷贝长度整个结构体大小，数据从入参到共用体变量的转移
    memcpy(&tx_struct.DATAStruct, shuatment, sizeof(CAN_struct));//调用memcpy函数（string.h里的内存拷贝函数），把shuatment指针指向CAN_struct结构体内容，拷贝到tx_struct的DATAstruct成员里
	CAN_TxHeaderTypeDef TxMessage;   //CAN发送头部配置
	TxMessage.StdId = 0x666;
	TxMessage.ExtId = 0x0000;
	TxMessage.IDE = CAN_ID_STD;
	TxMessage.RTR = CAN_RTR_DATA;    //结构体数据帧
	TxMessage.DLC = 8;               //一次发送八字节
	TxMessage.TransmitGlobalTime = DISABLE;
	//第一次发送报文
	
	HAL_StatusTypeDef status =HAL_CAN_AddTxMessage(&hcan1, &TxMessage, tx_struct.send, &TxMailbox);
	while(status!= HAL_OK)
	{
		TimeOut++;
		if (TimeOut > 100000)
		{
			break;
		}
		
	}
	TxMessage.StdId = 0x777;         //第二次发送报文（补发或分段发）
	HAL_CAN_AddTxMessage(&hcan1, &TxMessage, &tx_struct.send[8], &TxMailbox);//发送后续8个字节
	while(status!= HAL_OK)
	{
		TimeOut++;
		if (TimeOut > 100000)
		{
			break;
		}
		
	}
}

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_CAN1_Init();
  /* USER CODE BEGIN 2 */
    for(int i=0;i<16;i++)//初始化一个16字节结构体数据 h
    {
    //	CAN_struct h;
        h.data[i]=i;
    }
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
   MyCAN_Transmit_Float(3.14f);  //发送浮点数 
   MyCAN_Transmit_struct(&h);   //发送结构体数据

  while (1)
  {
    /* USER CODE END WHILE */
    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
  */
  __HAL_RCC_PWR_CLK_ENABLE();
  __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 16;
  RCC_OscInitStruct.PLL.PLLN = 192;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = 4;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV4;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */
uint8_t count=0;
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan1)    //CAN 接收FIFO0消息挂起回调函数，处理接收到的数据
{
	count++;     //每收到一条CAN消息就自增1，统计接收报文的次数
     
	Unionfloat floatBuff;
	if(HAL_CAN_GetRxMessage(hcan1,CAN_RX_FIFO0,&Rxhader,buffer)==HAL_OK)   //buffer收到的实际字节数据存在这里
    {
        if(Rxhader.StdId==0x555)     //准备转成float数据
        {
            memcpy(floatBuff.megt,buffer,sizeof(floatBuff.megt));
            receivedFloat = floatBuff.a;   //存储接收到的浮点数
		}
	
        if(Rxhader.StdId==0x666)
        {
            memcpy(structBuffer,buffer,8);    //buffer里的八字节数据拷贝到structBuffer
            rxframer=1;      //接收到分片等待拼接，下一步处理拼接逻辑
        }
        
        if((Rxhader.StdId==0x777)&&rxframer==1)   //两个同时满足
        {
            memcpy(&structBuffer[8],buffer,8);    //拷到前8个字节后面
            memcpy(receiveunionstruct.send,structBuffer,16);  //16字节数据拷到send数组成员里
            receiveStruct=receiveunionstruct.DATAStruct;  //存储接收到的结构体
            rxframer=0;       //分片处理完毕等待下一次
        }
    }
}

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */


				
			

			

				

					06-08
				

			

		

		

			
				
<think>嗯，用户这次问的是STM32的CAN通信中传输浮点数和结构体的代码示例。看来用户正在开发嵌入式系统，需要处理复杂数据类型传输，可能是工业控制或车载系统这类应用场景。从用户引用的两篇站内资料来看，用户似乎熟悉CoIDE开发环境和STM32Cube库，而且提到USB音频项目收尾，说明至少是中阶开发者。但奇怪的是用户引用内容和当前问题关联度不高，可能是误粘贴了？不过可以确认用户偏好Cube库而非标准库，这个细节很重要。用户核心诉求其实是三个技术点打包在一起：一是浮点数传输（涉及字节序和精度处理），二是结构体打包（内存对齐问题），三是CAN总线实现（需要配置硬件外设）。最关键的痛点应该是如何避免内存对齐导致的乱码问题，这个在嵌入式开发中很常见。我记得NXP和ST的参考手册里都有类似案例。需要特别注意三点：1）必须用__packed属性取消结构体填充，否则4字节对齐会破坏数据；2）浮点数要转成uint32_t传输，防止编译器优化差异；3）HAL库的CAN发送函数对数据格式很敏感。示例代码应该突出Cube库特性，比如用HAL_CAN_AddTxMessage这个关键API。用户大概率用的F4系列，所以用0x123作为标准ID很安全。调试建议要强调逻辑分析仪的使用，毕竟CAN调试最头疼的就是物理层错误。用户可能没明说的深层需求：1）是否支持大端小端转换；2）如何验证数据完整性。这两个点要在注意事项里点明。另外主动生成后续问题很必要，因为结构体对齐问题坑特别多，用户大概率会遇到。</think>
以下是基于STM32Cube库的CAN通信浮点数及结构体数据传输实现示例，重点解决数据打包、对齐和传输可靠性问题：

**核心代码示例**
```c
// 1. 定义带__packed属性的结构体（避免内存对齐问题）
typedef __packed struct {
  float   sensorValue;   // 浮点数
  uint8_t sensorID;      // 1字节ID
  uint16_t timestamp;    // 2字节时间戳
} SensorData;

// 2. 数据传输函数
HAL_StatusTypeDef CAN_SendStruct(CAN_HandleTypeDef *hcan, SensorData *data) {
  CAN_TxHeaderTypeDef txHeader;
  uint8_t canData[8];  // CAN每帧最多8字节
  
  // 结构体转字节数组（关键步骤）
  memcpy(canData, data, sizeof(SensorData)); 

  txHeader.StdId = 0x123;           // CAN标准ID
  txHeader.RTR = CAN_RTR_DATA;       // 数据帧
  txHeader.IDE = CAN_ID_STD;         // 标准ID
  txHeader.DLC = sizeof(SensorData); // 数据长度=3+4=7字节
  txHeader.TransmitGlobalTime = DISABLE;

  // 发送数据（HAL库函数）
  uint32_t mailbox;
  return HAL_CAN_AddTxMessage(hcan, &txHeader, canData, &mailbox);
}

// 3. 接收解析（中断回调）
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan) {
  CAN_RxHeaderTypeDef rxHeader;
  uint8_t rxData[8];
  
  if(HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &rxHeader, rxData) == HAL_OK) {
    if(rxHeader.StdId == 0x123) {
      SensorData receivedData;
      memcpy(&receivedData, rxData, sizeof(SensorData)); // 字节数组转结构体
      
      // 使用接收到的浮点数数据
      printf("Sensor %d Value: %.2f\n", 
             receivedData.sensorID, 
             receivedData.sensorValue);
    }
  }
}
```

**关键实现细节**：
1. `__packed`关键字禁用结构体填充（GCC/ARMCC编译器）
   ```c
   typedef __packed struct { ... } // 保证sizeof(SensorData)=7字节
   ```
2. 浮点数处理方案：
   ```c
   // 替代方案：联合体转换（避免直接内存拷贝）
   typedef union {
     float value;
     uint8_t bytes[4];
   } FloatConverter;
   ```
3. 数据传输验证方法：
   ```c
   // 发送前计算CRC校验
   uint8_t crc = CalculateCRC((uint8_t*)data, sizeof(SensorData));
   canData[7] = crc;  // DLC设置为8启用最后一字节校验
   ```

**硬件配置步骤**：
1. CubeMX设置：
   - 启用CAN模块（波特率建议125K/500K）
   - 配置收发GPIO（PA11-CAN_RX, PA12-CAN_TX）
   - 启用CAN中断（NVIC Settings）

**调试建议**：
1. 物理层检查：
   ```c
   // 在CAN初始化后添加诊断
   if(HAL_CAN_Init(&hcan) != HAL_OK) Error_Handler();
   // 检查CAN是否进入正常模式
   HAL_CAN_GetState(&hcan) == CAN_STATE_ERROR_ACTIVE
   ```
2. 使用逻辑分析仪监测：
   - 确认CAN波形是否符合ISO 11898-2标准
   - 检查仲裁域（ID）和数据域对齐情况

> **注意事项**  
> 1. STM32不同系列需替换`__packed`为`__attribute__((packed))`(GCC)  
> 2. 若结构体大小>8字节需实现分包传输协议  
> 3. H7系列需启用DCache一致性处理（SCB_CleanDCache_by_Addr）[^2]

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值