在此代码中将8位或16位值存储到16位对齐缓冲区可以吗？

Question

我想保存8位指针指向16位对齐缓冲区的一些值(8或16位)。

extern volatile INT16U NvM_Zone[128] __attribute((nodp, addr(NVRAM1_PAGE1_FIRST_ADDRESS)));

Std_ReturnType NvM_WriteBlock(NvM_BlockIdType BlockId, INT8U *NvM_SrcPtr) {
    Std_ReturnType Res = E_OK;
    NvM_ConfigType *nvm_config = &NvMConfig;
    NvM_StatusType nvm_status = nvm_config->nvm_module_status;
    if ((nvm_status == NVM_COMPLETED)) {
        nvm_status = NVM_IN_PROGRESS;
        nvm_config->nvm_data_info = &g_NvmDataList[0];
        INT8U i = nvm_config->nvm_data_info[BlockId].data_start_addr;
        INT8U size = nvm_config->nvm_data_info[BlockId].data_size_in_byte;
        if (size == 2) {
            INT16U *src = (INT16U*)NvM_SrcPtr;
            INT16U *dst = &NvM_Zone[i];
            *dst = *src;
        } else {
            INT8U *src  = NvM_SrcPtr;
            INT16U *dst = &NvM_Zone[i];
            *dst = (INT16U)(*src);
        }       
        NVRAM_SavePage(0);      // NVRAM_content : 0 ~ 63
        NVRAM_SavePage(1);      // NVRAM_content : 64 ~ 127     
        //NVRAM_SavePage(NVRAM2_PAGE1);
        nvm_config->nvm_flash_cntr_in_rt++;
        nvm_status = NVM_COMPLETED;
        Res = E_OK;
    } else {
        Res = E_NOT_OK;
    }
    nvm_config->nvm_module_status = nvm_status;
    return Res;
}

1. 16位值-保存在8位指针中参数化时抛出的16位值可以吗(对齐冲突)？最终目的地是一个16位缓冲区，它将被抛回16位对齐.还好吗？
2. 8位值-据我所知，下面的代码应该没问题。但是在编码方面有更好的建议吗？

编辑1.

传递的NvM_SrcPtr指针参数如下所示。

INT8U Byte = 0x00U;
INT16U Word = 0x0000U;
NvM_WriteBlock(SPECIAL_MODE_TYPE_VAL, &Byte);
NvM_WriteBlock(SPECIAL_MODE_TYPE_VAL, (INT8U*)&Word);

Answer 1

#include <stdio.h>
#include <stdlib.h>
int main(){

    int i;



    unsigned __int8 GX=7;
    printf("Value:%d\n",GX);
    printf("%d\n",&GX);
    for(i=0;i<8;i++){
        printf("Bin:%d\n",GX&0b1<<i);
    }
    /*Pass INT8U to INT16U */
    unsigned __int16 *DDC;
    DDC=(unsigned __int16*)&GX;

    printf("Value:%d\n",*DDC);
    printf("%d\n",DDC);
    /*Clearly Address is same but printf may be diff*/
    for(i=0;i<8;i++){
        printf("Bin:%d\n",(*DDC)&0b1<<i);
    }
    for(i=8;i<16;i++){
        printf("Bin2:%d\n",(*DDC)&0b1<<i);
    }
    /*First 8 bit same*/
    /*other 8 bit not sure because another 8bit give by address is not legal because not alloc*/
    /*you can trans 8bit to 16bit using address if you dont fix another 8bit*/

    /*if you want cover another value please make another 8bit stay original value*/
    /*like below*/
    unsigned __int16 NewValue=80;
    *DDC=(*DDC)&(0xff00|NewValue);


    /*By the way in multithreading case dont use this method because memory use will be too complex*/





    return 0;
}

Answer 2

一般规则是，只有在正确的类型下才能取消引用指针。可以将指针转换为其他类型，但如果要取消引用，则需要将其转换回原始类型。

这些指针转换是实现定义的。这意味着不同的指针在某些系统上可能有不同的表示，您应该阅读关于这些指针在系统上如何工作的编译器手册。在典型的现代系统中，指针通常使用相同的表示形式，指针转换只起作用。

不过，你的可能是特例。您可以看到，字符类型指针是C标准中的一个特殊例外:它们保证具有可转换为其他指针类型的表示形式，而且即使它们是从其他指针类型派生出来的，也始终可以取消引用。因此，如果INT8U是unsigned char (这很可能)，则指针转换是可以的。

没有转换的8位很好：

INT8U Byte = 0x00U;
INT8U *NvM_SrcPtr = &Byte;         // ok - matching type
INT8U *src = NvM_SrcPtr;           // ok - matching type
*dst = (INT16U)(*src);             // ok - dereference with original type

有转换的16位很可能是很好的：

INT16U Word = 0x0000U;
INT8U *NvM_SrcPtr = &Word;         // impl.def or special case
INT16U *src = (INT16U*)NvM_SrcPtr; // impl.def or special case
*dst = *src;                       // ok - dereference with original type

16位-> 8位最有可能很好：

INT16U Word = 0x0000U;
INT8U *NvM_SrcPtr = &Word;         // impl.def or special case
INT8U *src = NvM_SrcPtr;           // ok - matching type
*dst = (INT16U)(*src);             // ok if INT8U is unsigned char

8位-> 16位是而不是很好：

INT8U Byte = 0x00U;
INT8U *NvM_SrcPtr = &Byte;         // ok - matching type
INT16U *src = (INT16U*)NvM_SrcPtr; // impl.def 
*dst = *src;                       // invalid - derefence with invalid type

至于指针对齐，这是您需要处理的事情。如果将指针转换为其他类型，然后将其错对齐，并将其转换回来，则可能存在未定义的行为。