将两个8位阵列组合为一个USHORT(16位），无环路

Combining two 8-Bit array to a USHORT (16 Bit) , without loop

本文关键字：USHORT 一个 16位 环路 组合 两个 8位 阵列      更新时间：2023-10-16

我需要将两个UCHAR（8位）数组组合成C中的USHORT（16位）值。但我必须在不使用"for"或任何循环的情况下完成此操作。

作为：

UCHAR A[1000], B[1000];
USHORT C[1000];

结果必须为：

C[0] = {A[0], B[0]};
C[1] = {A[1], B[1]};
...
C[1000]={A[1000], B[1000]};

uint8_t one = 0xBA;
uint8_t two = 0xBE;
uint16_t both = one << 8 | two;

更新：也许我没有理解你的问题。。。但是如果您想将uint8_t数组转换为uint16_t数组->检查大小并投射

uint8_t array[100];
uint16_t array_ptr_ushort* =(uint16_t*)&array[0];

请确保阵列的大小均匀。

更新2:

uint8_t array1[100];
uint8_t array2[100];
uint16_t combined[100];
memcpy(combined, array1, sizeof(array1))
memcpy((uint8_t*)combined + sizeof(array1), array2, sizeof(array2))

更新3:

如果没有某种循环，你不能将两个数组组合在一个连续数组中，即使你使用DMA，循环也会存在于底层硬件中。。。

更新4:

你可以递归地做。

#include "stdafx.h"
#include <cstdint>
#include <algorithm>
uint8_t arrayA[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
uint8_t arrayB[] = {0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1};
uint16_t array_combined[sizeof(arrayA)] = {};
static_assert(sizeof(arrayA) == sizeof(arrayB), "Arrays of different sizes");
uint16_t combine(const uint8_t *a, const uint8_t *b, uint16_t *put, uint32_t size)
{
    uint16_t value = (*a << 8) | *b;
    if(size)
        *put = combine(++a, ++b, ++put, --size);
    return value;
}
void combine_arrays(const uint8_t *a, const uint8_t *b, uint16_t *put, uint32_t size)
{
    *put = combine(a, b, put, size);
}
int _tmain(int argc, _TCHAR* argv[])
{
    combine_arrays(arrayA, arrayB, array_combined, sizeof(arrayA));
return 0;
}

更新5:来自C++的带有static_assert的C版本

#include <stdint.h>

uint8_t array1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
uint8_t array2[] = {0xA, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1};
uint16_t array_combined[sizeof(array1)] = {};
static_assert(sizeof(array1) == sizeof(array2), "Arrays of different sizes");
int _tmain(int argc, _TCHAR* argv[])
{
    int size = sizeof(array1);
    int count = 0;
    do
    {
        array_combined[count] = (array2[count] << 8) | array1[count];
    }while(count++ != size);
    return 0;
}

更新6:还有C++方法可以实现这一点。。。

ushortVal = ( ucharVal[0] << 8 ) | ucharVal[1];

对于单个元素，您只需将第一个字节向左移位8位，然后使用按位或添加第二个字节：

C[i] = (A[i] << 8) | B[i];

但对于阵列，您基本上希望将两个阵列"分散"到第三个阵列中，如下所示：

A[0] B[0]  |  A[1] B[1]  |  A[2] B[2]  |  ...  |  A[n-1] B[n-1]
   C[0]    |     C[1]    |     C[2]    |  ...  |     C[n-1]

这意味着，如果阵列C的第一个元素存储在地址0处，则来自阵列A的元素应该在地址0、16、32、48…处，并且来自阵列B的元素在地址8、24、…处。。。如果不使用任何循环，就无法完成IMHO

相关文章：