收集C语言中8位机无符号整型跟两个无符号字符型互相转换的方法

只看该作者 · 2014-7-4 07:56

学生不才最近在做一小型操作系统，牵涉到地址链接计算，其中有16位地址需转换成两个8位地址分成两次发送。为计算方便并优化系统，现收集C语言中8位机无符号整型跟两个无符号字符型互相转换的方法。
方法一：
uint a;
uchar b,c;
//整型转字符型
b=a;//低8位
c=(a>>8);//高8位
//字符型转整型
a=c;
a<<=8;
a+=b;
方法二：
uint a;
uchar b,c;
//整型转字符型
b=a/256;//高位
c=a%256;//低位
//字符型转整型
a=b*256+c;

这是我自己想到的方法，请广大同仁朋友老师指教！如另有方法，不吝分享！

只看该作者 · 2014-7-4 09:10

typedef union {
uint a;
u8 b;
u8 c;
} data;

2万 · 2014-7-4 09:25

Leeone 发表于 2014-7-4 09:10
typedef union {
uint a;
u8 b;

赞！

只看该作者 · 2014-7-4 09:37

Leeone 发表于 2014-7-4 09:10
typedef union {
uint a;
u8 b;

不是很理解怎么用啊？谢谢了

只看该作者 · 2014-7-4 09:38

Leeone 发表于 2014-7-4 09:10
typedef union {
uint a;
u8 b;

这只是个链表结构，不具备转换功能，倒可以跟我上面的例子结合，构成一个转换函数。

2万 · 2014-7-4 09:42

把操作系统SHOW一下呗~

只看该作者 · 2014-7-4 09:43

寒舍发表于 2014-7-4 09:38
这只是个链表结构，不具备转换功能，倒可以跟我上面的例子结合，构成一个转换函数。 ...

你还想把它咋写成转换函数，写个看看

只看该作者 · 2014-7-4 10:07

Leeone 发表于 2014-7-4 09:43
你还想把它咋写成转换函数，写个看看

struct tran{
uint a;
uchar b,c;
}data;
data.a=data.b*256+data.c;

只看该作者 · 2014-7-4 10:11

寒舍发表于 2014-7-4 10:07
struct tran{
uint a;
uchar b,c;

是union 你把它搞成 struct 了，union也不是你那样用地

只看该作者 · 2014-7-4 10:21

原野之狼发表于 2014-7-4 09:42
把操作系统SHOW一下呗~

是套带有人机界面覆盖本公司大部分产品的半自动测试系统，说是小型系统，但也挺庞大的。程序体二十几K。尚未完工，还不适合展示。。

2万 · 2014-7-4 10:23

union直接取就是了，还转换啥呀。

只看该作者 · 2014-7-4 10:30

union，还有一种更简单的强制指针类型转换，这两种做法都比撸主的方法快得多，但是缺点是有大小端问题，移植的时候会出问题。撸主的方法虽然慢但是不存在大小端问题，但是可能会有int长度不同的问题。此事古难全。。。

只看该作者 · 2014-7-4 10:36

Leeone 发表于 2014-7-4 10:11
是union 你把它搞成 struct 了，union也不是你那样用地

哦，使用共用体！这想法真是别出一格！回头加分！

只看该作者 · 2014-7-4 20:19

Leeone 发表于 2014-7-4 09:10
typedef union {
uint a;
u8 b;

为区分高8位低8位，还可以优化下
typedef union{
uint a;
uchar b[2];
}

只看该作者 · 2014-7-4 20:55

http://blog.csdn.net/firefly_2002/article/details/7954458
这里有链接我看了懂了呢。。原来8位也可以扩展为16位。。但是要是整型数据有符号的呢？

只看该作者 · 2014-7-4 22:27

这也算个问题啊

只看该作者 · 2014-7-4 23:10

寒舍发表于 2014-7-4 20:19
为区分高8位低8位，还可以优化下
typedef union{
uint a;

数组也可以强制类型转换。总得来说大小端问题是要考虑的

只看该作者 · 2014-7-5 00:34

#define HIGH(a) *((unsigned char)(&a))

只看该作者 · 2014-7-5 07:09

这是鄙人使用多年的方法，见笑了。
/**
* __vat - 强制获取指定内存偏移数据
* @base - 内存地址基址
* @offset - 地址偏移
*/
#ifndef __vat
# define __vat(_base,_offset)       (((uint8*)(_base))[_offset])
#endif

/* 以大端格式读取16位数值 */
#define GET_BE_UINT16(pt)             ( ((uint16)__vat(pt,0) <<  8) \
                                    | ((uint8 )__vat(pt,1) <<  0) )

/* 以大端格式读取24位数值 */
#define GET_BE_UINT24(pt)             ( ((uint32)__vat(pt,0) << 16) \
                                    | ((uint16)__vat(pt,1) <<  8) \
                                    | ((uint8 )__vat(pt,2) <<  0) )

/* 以大端格式读取32位数值 */
#define GET_BE_UINT32(pt)             ( ((uint32)__vat(pt,0) << 24) \
                                    | ((uint32)__vat(pt,1) << 16) \
                                    | ((uint16)__vat(pt,2) <<  8) \
                                    | ((uint8 )__vat(pt,3) <<  0) )

/* 以大端格式读取64位数值 */
#define GET_BE_UINT64(pt)             ( ((uint64)__vat(pt,0) << 56) \
                                    | ((uint64)__vat(pt,1) << 48) \
                                    | ((uint64)__vat(pt,2) << 40) \
                                    | ((uint64)__vat(pt,3) << 32) \
                                    | ((uint32)__vat(pt,4) << 24) \
                                    | ((uint32)__vat(pt,5) << 16) \
                                    | ((uint16)__vat(pt,6) <<  8) \
                                    | ((uint8 )__vat(pt,7) <<  0) )

/* 以大端格式写16位数值    */
#define PUT_BE_UINT16(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint16)(val) >>  8); \
__vat(pt,1) = (uint8)((uint8 )(val) >>  0); \
}while(0)

/* 以大端格式写24位数值    */
#define PUT_BE_UINT24(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint32)(val) >> 16); \
__vat(pt,1) = (uint8)((uint16)(val) >>  8); \
__vat(pt,2) = (uint8)((uint8 )(val) >>  0); \
}while(0)

/* 以大端格式写32位数值    */
#define PUT_BE_UINT32(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint32)(val) >> 24); \
__vat(pt,1) = (uint8)((uint32)(val) >> 16); \
__vat(pt,2) = (uint8)((uint16)(val) >>  8); \
__vat(pt,3) = (uint8)((uint8 )(val) >>  0); \
}while(0)

/* 以大端格式写64位数值    */
#define PUT_BE_UINT64(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint64)(val) >> 56); \
__vat(pt,1) = (uint8)((uint64)(val) >> 48); \
__vat(pt,2) = (uint8)((uint64)(val) >> 40); \
__vat(pt,3) = (uint8)((uint64)(val) >> 32); \
__vat(pt,4) = (uint8)((uint32)(val) >> 24); \
__vat(pt,5) = (uint8)((uint32)(val) >> 16); \
__vat(pt,6) = (uint8)((uint16)(val) >>  8); \
__vat(pt,7) = (uint8)((uint8 )(val) >>  0); \
}while(0)

/* 以小端格式读取16位数值 */
#define GET_LE_UINT16(pt)             ( ((uint8 )__vat(pt,0) <<  0) \
                                    | ((uint16)__vat(pt,1) <<  8) )

/* 以小端格式读取24位数值 */
#define GET_LE_UINT24(pt)             ( ((uint8 )__vat(pt,0) <<  0) \
                                    | ((uint16)__vat(pt,1) <<  8) \
                                    | ((uint32)__vat(pt,2) << 16) )

/* 以小端格式读取32位数值 */
#define GET_LE_UINT32(pt)             ( ((uint8 )__vat(pt,0) <<  0) \
                                    | ((uint16)__vat(pt,1) <<  8) \
                                    | ((uint32)__vat(pt,2) << 16) \
                                    | ((uint32)__vat(pt,3) << 24) )

/* 以小端格式读取64位数值 */
#define GET_LE_UINT64(pt)             ( ((uint8 )__vat(pt,0) <<  0) \
                                    | ((uint16)__vat(pt,1) <<  8) \
                                    | ((uint32)__vat(pt,2) << 16) \
                                    | ((uint32)__vat(pt,3) << 24) \
                                    | ((uint64)__vat(pt,4) << 32) \
                                    | ((uint64)__vat(pt,5) << 40) \
                                    | ((uint64)__vat(pt,6) << 48) \
                                    | ((uint64)__vat(pt,7) << 56) )

/* 以小端格式写16位数值    */
#define PUT_LE_UINT16(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint8 )(val) >>  0); \
__vat(pt,1) = (uint8)((uint16)(val) >>  8); \
}while(0)

/* 以小端格式写24位数值    */
#define PUT_LE_UINT24(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint8 )(val) >>  0); \
__vat(pt,1) = (uint8)((uint16)(val) >>  8); \
__vat(pt,2) = (uint8)((uint32)(val) >> 16); \
}while(0)

/* 以小端格式写32位数值    */
#define PUT_LE_UINT32(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint8 )(val) >>  0); \
__vat(pt,1) = (uint8)((uint16)(val) >>  8); \
__vat(pt,2) = (uint8)((uint32)(val) >> 16); \
__vat(pt,3) = (uint8)((uint32)(val) >> 24); \
}while(0)

/* 以小端格式写64位数值    */
#define PUT_LE_UINT64(pt,val) \
do{ \
__vat(pt,0) = (uint8)((uint8 )(val) >>  0); \
__vat(pt,1) = (uint8)((uint16)(val) >>  8); \
__vat(pt,2) = (uint8)((uint32)(val) >> 16); \
__vat(pt,3) = (uint8)((uint32)(val) >> 24); \
__vat(pt,4) = (uint8)((uint64)(val) >> 32); \
__vat(pt,5) = (uint8)((uint64)(val) >> 40); \
__vat(pt,6) = (uint8)((uint64)(val) >> 48); \
__vat(pt,7) = (uint8)((uint64)(val) >> 56); \
}while(0)

只看该作者 · 2014-7-5 12:36

感觉你这不叫“做一小型操作系统”，是在用吧。

收集C语言中8位机无符号整型跟两个无符号字符型互相转换的方法

相关下载

相关帖子

技术高手奖章

常驻人口

七世轮回

技术奇才奖章

欢快之小溪

社区建设奖章

核心会员奖章

坚毅之洋流

十世金身

技术领袖奖章

以坛为家

涓涓之细流

技术导师奖章

突出贡献奖章

沉静之湖泊

技术新星奖章

无冕之王奖章

缘定三生

湍急之河流

精华达人奖章