位运算

最新推荐文章于 2024-02-15 17:56:07 发布
最新推荐文章于 2024-02-15 17:56:07 发布
阅读量161 收藏 1
点赞数
_t的意思到底表示什么？具体的官方答案没有找到，不过我觉得有个答案比较接近。它就是一个结构的标注，可以理解为type/typedef的缩写，表示它是通过typedef定义的，而不是其它数据类型。

uint8_t，uint16_t，uint32_t等都不是什么新的数据类型，它们只是使用typedef给类型起的别名，新瓶装老酒的把戏。不过，不要小看了typedef，它对于你代码的维护会有很好的作用。比如C中没有bool，于是在一个软件中，一些程序员使用int，一些程序员使用short，会比较混乱，最好就是用一个typedef来定义，如：
typedef char bool;

一般来说，一个C的工程中一定要做一些这方面的工作，因为你会涉及到跨平台，不同的平台会有不同的字长，所以利用预编译和typedef可以让你最有效的维护你的代码。为了用户的方便，C99标准的C语言硬件为我们定义了这些类型，我们放心使用就可以了。

 

以下内容转载自http://apps.hi.baidu.com/share/detail/32935657

[cpp] view plain copy

    按照posix标准，一般整型对应的*_t类型为：  
    1字节     uint8_t  
    2字节     uint16_t  
    4字节     uint32_t  
    8字节     uint64_t  


stdint.h文件如下：

[cpp] view plain copy

    /* Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. 
    This file is part of the GNU C Library. 
     
    The GNU C Library is free software; you can redistribute it and/or 
    modify it under the terms of the GNU Lesser General Public 
    License as published by the Free Software Foundation; either 
    version 2.1 of the License, or (at your option) any later version. 
     
    The GNU C Library is distributed in the hope that it will be useful, 
    but WITHOUT ANY WARRANTY; without even the implied warranty of 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
    Lesser General Public License for more details. 
     
    You should have received a copy of the GNU Lesser General Public 
    License along with the GNU C Library; if not, write to the Free 
    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 
    02111-1307 USA. */  
      
    /* 
    * ISO C99: 7.18 Integer types <stdint.h> 
    */  
      
    #ifndef _STDINT_H  
    #define _STDINT_H   1  
      
    #include <features.h>  
    #include <bits/wchar.h>  
    #include <bits/wordsize.h>  
      
    /* Exact integral types. */  
      
    /* Signed. */  
      
    /* There is some amount of overlap with <sys/types.h> as known by inet code */  
    #ifndef __int8_t_defined  
    # define __int8_t_defined  
    typedef signed char     int8_t;  
    typedef short int       int16_t;  
    typedef int         int32_t;  
    # if __WORDSIZE == 64  
    typedef long int        int64_t;  
    # else  
    __extension__  
    typedef long long int       int64_t;  
    # endif  
    #endif  
      
    /* Unsigned. */  
    typedef unsigned char       uint8_t;  
    typedef unsigned short int uint16_t;  
    #ifndef __uint32_t_defined  
    typedef unsigned int        uint32_t;  
    # define __uint32_t_defined  
    #endif  
    #if __WORDSIZE == 64  
    typedef unsigned long int   uint64_t;  
    #else  
    __extension__  
    typedef unsigned long long int uint64_t;  
    #endif  
      
      
    /* Small types. */  
      
    /* Signed. */  
    typedef signed char     int_least8_t;  
    typedef short int       int_least16_t;  
    typedef int         int_least32_t;  
    #if __WORDSIZE == 64  
    typedef long int        int_least64_t;  
    #else  
    __extension__  
    typedef long long int       int_least64_t;  
    #endif  
      
    /* Unsigned. */  
    typedef unsigned char       uint_least8_t;  
    typedef unsigned short int uint_least16_t;  
    typedef unsigned int        uint_least32_t;  
    #if __WORDSIZE == 64  
    typedef unsigned long int   uint_least64_t;  
    #else  
    __extension__  
    typedef unsigned long long int uint_least64_t;  
    #endif  
      
      
    /* Fast types. */  
      
    /* Signed. */  
    typedef signed char     int_fast8_t;  
    #if __WORDSIZE == 64  
    typedef long int        int_fast16_t;  
    typedef long int        int_fast32_t;  
    typedef long int        int_fast64_t;  
    #else  
    typedef int         int_fast16_t;  
    typedef int         int_fast32_t;  
    __extension__  
    typedef long long int       int_fast64_t;  
    #endif  
      
    /* Unsigned. */  
    typedef unsigned char       uint_fast8_t;  
    #if __WORDSIZE == 64  
    typedef unsigned long int   uint_fast16_t;  
    typedef unsigned long int   uint_fast32_t;  
    typedef unsigned long int   uint_fast64_t;  
    #else  
    typedef unsigned int        uint_fast16_t;  
    typedef unsigned int        uint_fast32_t;  
    __extension__  
    typedef unsigned long long int uint_fast64_t;  
    #endif  
      
      
    /* Types for `void *' pointers. */  
    #if __WORDSIZE == 64  
    # ifndef __intptr_t_defined  
    typedef long int        intptr_t;  
    # define __intptr_t_defined  
    # endif  
    typedef unsigned long int   uintptr_t;  
    #else  
    # ifndef __intptr_t_defined  
    typedef int         intptr_t;  
    # define __intptr_t_defined  
    # endif  
    typedef unsigned int        uintptr_t;  
    #endif  
      
      
    /* Largest integral types. */  
    #if __WORDSIZE == 64  
    typedef long int        intmax_t;  
    typedef unsigned long int   uintmax_t;  
    #else  
    __extension__  
    typedef long long int       intmax_t;  
    __extension__  
    typedef unsigned long long int uintmax_t;  
    #endif  
      
      
    /* The ISO C99 standard specifies that in C++ implementations these 
    macros should only be defined if explicitly requested. */  
    #if !defined __cplusplus || defined __STDC_LIMIT_MACROS  
      
    # if __WORDSIZE == 64  
    # define __INT64_C(c) c ## L  
    # define __UINT64_C(c) c ## UL  
    # else  
    # define __INT64_C(c) c ## LL  
    # define __UINT64_C(c) c ## ULL  
    # endif  
      
    /* Limits of integral types. */  
      
    /* Minimum of signed integral types. */  
    # define INT8_MIN       (-128)  
    # define INT16_MIN      (-32767-1)  
    # define INT32_MIN      (-2147483647-1)  
    # define INT64_MIN      (-__INT64_C(9223372036854775807)-1)  
    /* Maximum of signed integral types. */  
    # define INT8_MAX       (127)  
    # define INT16_MAX      (32767)  
    # define INT32_MAX      (2147483647)  
    # define INT64_MAX      (__INT64_C(9223372036854775807))  
      
    /* Maximum of unsigned integral types. */  
    # define UINT8_MAX      (255)  
    # define UINT16_MAX     (65535)  
    # define UINT32_MAX     (4294967295U)  
    # define UINT64_MAX     (__UINT64_C(18446744073709551615))  
      
      
    /* Minimum of signed integral types having a minimum size. */  
    # define INT_LEAST8_MIN     (-128)  
    # define INT_LEAST16_MIN    (-32767-1)  
    # define INT_LEAST32_MIN    (-2147483647-1)  
    # define INT_LEAST64_MIN    (-__INT64_C(9223372036854775807)-1)  
    /* Maximum of signed integral types having a minimum size. */  
    # define INT_LEAST8_MAX     (127)  
    # define INT_LEAST16_MAX    (32767)  
    # define INT_LEAST32_MAX    (2147483647)  
    # define INT_LEAST64_MAX    (__INT64_C(9223372036854775807))  
      
    /* Maximum of unsigned integral types having a minimum size. */  
    # define UINT_LEAST8_MAX    (255)  
    # define UINT_LEAST16_MAX   (65535)  
    # define UINT_LEAST32_MAX   (4294967295U)  
    # define UINT_LEAST64_MAX   (__UINT64_C(18446744073709551615))  
      
      
    /* Minimum of fast signed integral types having a minimum size. */  
    # define INT_FAST8_MIN      (-128)  
    # if __WORDSIZE == 64  
    # define INT_FAST16_MIN    (-9223372036854775807L-1)  
    # define INT_FAST32_MIN    (-9223372036854775807L-1)  
    # else  
    # define INT_FAST16_MIN    (-2147483647-1)  
    # define INT_FAST32_MIN    (-2147483647-1)  
    # endif  
    # define INT_FAST64_MIN     (-__INT64_C(9223372036854775807)-1)  
    /* Maximum of fast signed integral types having a minimum size. */  
    # define INT_FAST8_MAX      (127)  
    # if __WORDSIZE == 64  
    # define INT_FAST16_MAX    (9223372036854775807L)  
    # define INT_FAST32_MAX    (9223372036854775807L)  
    # else  
    # define INT_FAST16_MAX    (2147483647)  
    # define INT_FAST32_MAX    (2147483647)  
    # endif  
    # define INT_FAST64_MAX     (__INT64_C(9223372036854775807))  
      
    /* Maximum of fast unsigned integral types having a minimum size. */  
    # define UINT_FAST8_MAX     (255)  
    # if __WORDSIZE == 64  
    # define UINT_FAST16_MAX   (18446744073709551615UL)  
    # define UINT_FAST32_MAX   (18446744073709551615UL)  
    # else  
    # define UINT_FAST16_MAX   (4294967295U)  
    # define UINT_FAST32_MAX   (4294967295U)  
    # endif  
    # define UINT_FAST64_MAX    (__UINT64_C(18446744073709551615))  
      
      
    /* Values to test for integral types holding `void *' pointer. */  
    # if __WORDSIZE == 64  
    # define INTPTR_MIN        (-9223372036854775807L-1)  
    # define INTPTR_MAX        (9223372036854775807L)  
    # define UINTPTR_MAX       (18446744073709551615UL)  
    # else  
    # define INTPTR_MIN        (-2147483647-1)  
    # define INTPTR_MAX        (2147483647)  
    # define UINTPTR_MAX       (4294967295U)  
    # endif  
      
      
    /* Minimum for largest signed integral type. */  
    # define INTMAX_MIN     (-__INT64_C(9223372036854775807)-1)  
    /* Maximum for largest signed integral type. */  
    # define INTMAX_MAX     (__INT64_C(9223372036854775807))  
      
    /* Maximum for largest unsigned integral type. */  
    # define UINTMAX_MAX        (__UINT64_C(18446744073709551615))  
      
      
    /* Limits of other integer types. */  
      
    /* Limits of `ptrdiff_t' type. */  
    # if __WORDSIZE == 64  
    # define PTRDIFF_MIN       (-9223372036854775807L-1)  
    # define PTRDIFF_MAX       (9223372036854775807L)  
    # else  
    # define PTRDIFF_MIN       (-2147483647-1)  
    # define PTRDIFF_MAX       (2147483647)  
    # endif  
      
    /* Limits of `sig_atomic_t'. */  
    # define SIG_ATOMIC_MIN     (-2147483647-1)  
    # define SIG_ATOMIC_MAX     (2147483647)  
      
    /* Limit of `size_t' type. */  
    # if __WORDSIZE == 64  
    # define SIZE_MAX      (18446744073709551615UL)  
    # else  
    # define SIZE_MAX      (4294967295U)  
    # endif  
      
    /* Limits of `wchar_t'. */  
    # ifndef WCHAR_MIN  
    /* These constants might also be defined in <wchar.h>. */  
    # define WCHAR_MIN     __WCHAR_MIN  
    # define WCHAR_MAX     __WCHAR_MAX  
    # endif  
      
    /* Limits of `wint_t'. */  
    # define WINT_MIN       (0u)  
    # define WINT_MAX       (4294967295u)  
      
    #endif /* C++ && limit macros */  
      
      
    /* The ISO C99 standard specifies that in C++ implementations these 
    should only be defined if explicitly requested. */  
    #if !defined __cplusplus || defined __STDC_CONSTANT_MACROS  
      
    /* Signed. */  
    # define INT8_C(c) c  
    # define INT16_C(c) c  
    # define INT32_C(c) c  
    # if __WORDSIZE == 64  
    # define INT64_C(c)    c ## L  
    # else  
    # define INT64_C(c)    c ## LL  
    # endif  
      
    /* Unsigned. */  
    # define UINT8_C(c) c ## U  
    # define UINT16_C(c)    c ## U  
    # define UINT32_C(c)    c ## U  
    # if __WORDSIZE == 64  
    # define UINT64_C(c)   c ## UL  
    # else  
    # define UINT64_C(c)   c ## ULL  
    # endif  
      
    /* Maximal type. */  
    # if __WORDSIZE == 64  
    # define INTMAX_C(c)   c ## L  
    # define UINTMAX_C(c) c ## UL  
    # else  
    # define INTMAX_C(c)   c ## LL  
    # define UINTMAX_C(c) c ## ULL  
    # endif  
      
    #endif /* C++ && constant macros */  
      
    #endif /* stdint.h */




假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：

运算符描述实例
&如果同时存在于两个操作数中，二进制 AND 运算符复制一位到结果中。(A & B) 将得到 12，即为 0000 1100
|如果存在于任一操作数中，二进制 OR 运算符复制一位到结果中。(A | B) 将得到 61，即为 0011 1101
^如果存在于其中一个操作数中但不同时存在于两个操作数中，二进制异或运算符复制一位到结果中。(A ^ B) 将得到 49，即为 0011 0001
~二进制补码运算符是一元运算符，具有"翻转"位效果，即0变成1，1变成0。(~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。
<<二进制左移运算符。左操作数的值向左移动右操作数指定的位数。A << 2 将得到 240，即为 1111 0000
>>二进制右移运算符。左操作数的值向右移动右操作数指定的位数。A >> 2 将得到 15，即为 0000 1111

大东bigeast
关注
位运算的理解
lemmon_tree的博客
06-26 278
看到一个二进制数，先要知道它是有符号数还是无符号数。 寄存器，mov 寄存器，值。 负数在计算机中是以补码的形式存储的。 一、位运算 计算机可以用来存储所有的整数。 2*8最高效的计算方式 最高效的计算方式是位运算。 与运算（and） 1011 and 0001 运算结果为：0001 同时为1则结果为1，其余情况结果为0。 与运算电路图： 或运算（or） 只有有一个为1则结果为1，其余结果为0。 或运算电路图： 异或运算（xor ^） 不一样则为1。 下图为异或电路图。 1011 x
位运算 详解 技巧
YueLing's Blog
01-28 1149
关于位运算的技巧和举例
位运算的简单理解
qq_38932871的博客
12-30 430
一、简介   程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。比如，and运算本来是一个逻辑运算符，但整数与整数之间也可以进行and运算。举个例子，6的二进制是110，11的二进制是1011，那么6 and 11的结果就是2，它是二进制对应位进行逻辑运算的结果（0表示False，1表示True，空位都当0处理）。 二、运算规则 1、运算符 ...
[位操作]一些位操作的技巧
weixin_30687051的博客
10-04 306
一些关于位操作的技巧. WIKI Bit manipulation is the act of algorithmically manipulating bits or other pieces of data shorter than a word. Computer programming tasks that require bit manipulation include low-le...
190
yeyueyouhun的博客
11-06 198
颠倒给定的 32 位无符号整数的二进制位。 示例 1： 输入: 00000010100101000001111010011100 输出: 00111001011110000010100101000000 解释: 输入的二进制串 000000101001010000011110...
用位运算不用算术运算实现整数的加减乘除运算
12-22
位运算在计算机科学中是一种非常基础且高效的运算方式，它主要涉及到对数字的二进制表示进行操作。本文将探讨如何仅使用位运算而非传统的算术运算符来实现整数的加减乘除运算。 首先，我们来看加法。加法可以被分解...
JS通过位运算实现权限加解密
10-18
在JavaScript中，位运算是一种底层操作，通常用于处理二进制数据。在权限加解密的场景中，位运算能够高效地实现权限的设置、检查和组合，尤其适用于多权限系统。下面我们将深入探讨如何利用位运算来实现权限管理。 ...
c语言中用位运算实现加法技巧介绍
09-05
在C语言中，位运算是一种高效的操作方式，尤其在处理底层数据和算法优化时非常有用。本文主要讨论如何使用位运算来实现加法操作，这是一个基础但重要的概念，尤其是在理解计算机内部运算机制时。 首先，我们要知道...
位运算实现十进制转换为二进制
09-03
位运算在计算机科学中扮演着重要的角色，它们是计算机硬件和软件进行低级别操作的基础。在本主题中，我们将深入探讨如何使用位运算将十进制数转换为二进制数。位运算主要包括与（&）、或（|）、非（~）、异或（^）...
C语言uint8_t的解释
BJTUYBYUAN的博客
09-19 4万+
一、C语言基本数据类型回顾 在C语言中有6种基本数据类型：short、int、long、float、double、char 1、数值类型 1）整型：short、int、long 2）浮点型：float、double 2、字符类型：char 二、typedef回顾 typedef用来定义关键字或标识符的别名，例如： typedef double wages; typedef wages salary; 三、uint8_t\uint_16_t\uint32_t\uint64_t 1、这些类型的来源：这些数据类型
uint8_t
weixin_40700884的博客
03-10 1万+
什么是*_t https://blog.csdn.net/qq_19784349/article/details/82927169 以下内容引用自上边链接： *_t是typedef定义的表示标志，是结构的一种标注。即我们所看到的 uint8_t、uint16_t、uint32_t都不是新的数据类型，而是通过typedef给类型起得别名。 很明显的看出：uint8_t是用1个字节表示的；uint...
关于C或C++，数组的强制类型转换，uint8_t与char的区别，uint8_t*与char*的兼容性问题以及一些指针的常见问题
weixin_44860466的博客
11-18 1万+
C/C++，数组的强制类型转换，数组与指针之间的联系和区别，uint8_t与char的区别，uint8_t*与char*的兼容性，stm32中LCD屏幕小注意点
uint8_t / uint16_t / uint32_t /uint64_t 是什么数据类型 - 大总结，看完全明白了
热门推荐
kiddy19850221的专栏
08-02 37万+
uint8_t / uint16_t / uint32_t /uint64_t  是什么数据类型 在nesc的代码中，你会看到很多你不认识的数据类型，比如uint8_t等。咋一看，好像是个新的数据类型，不过C语言（nesc是C的扩展）里面好像没有这种数据类型啊！怎么
[c++]-uint8_t,uint16_t,uint32_t,uint64_t代表含义及其标准定义
ai_faker的博客
06-23 3万+
c++基础数据类型 首先来看一张c++基础数据类型的列表 下表显示了各种变量类型在内存中存储值时需要占用的内存，以及该类型的变量所能存储的最大值和最小值。 注意：不同系统会有所差异，一字节为 8 位。 注意：long int 8 个字节，int 都是 4 个字节，早期的 C 编译器定义了 long int 占用 4 个字节，int 占用 2 个字节，新版的 C/C++ 标准兼容了早期的这一设定。 详解：菜鸟教程-c++数据类型 总的来说c++的基础数据类型分为三类： 布尔型 整型（char型从本质上说，
C++ uint8_t
xihuanmadaima的博客
04-22 8071
问题：uint8_t是什么数据类型？ 解决：C++的主要数据类型，主要分为三类：布尔型，整型，浮点型。 按照posix标准，一般整型对应的*_t类型为： 1字节 uint8_t 2字节 uint16_t 4字节 uint32_t 8字节 uint64_t 而在基础数据类型中，int也是4个字节的，所以可以把uint32_t看作是int的别名。 uint8_t就是可表示范围更小的整型数据类型。 ...
c++基础之uint8_t
时光机 °的博客
10-02 9万+
C++的基础数据类型： 名称 字节长度 取值范围 bool 1 false,true char 1 -128~127 signed char 1 -128~127 unsigned char 1 0~255 short(signed short) 2 -215 ~ 215 - 1 unsigned short 2 0~216-1 int (signed in...
uint8_t图像数据类型介绍
AAAA202012的博客
04-09 1万+
0. C++基础类型介绍 名称 字节长度 取值范围 bool 1 false, true char 1 -128 ~ 127 signed char 1 -128 ~ 127 unsigned char 1 0 ~ 255 short(signed short) 2 -215 ~ 215- 1 unsigned short 2 0 ~ 216- 1 int(signed int) 4 -231 ~ 231- 1 unsigned int 4 0 ~ 232 - 1
int8_t、uint8_t、__INT 64等和size_t的阐述
最新发布
2301_79810148的博客
02-15 1424
阐述stdint.h和types.h头文件下的我们常见的类型别名
计算机系统位运算实践：位运算函数解析
"位运算在计算机科学中扮演着重要的角色，特别是在底层系统编程和硬件交互时。本资源提供了一些关于位运算的实例，包括bitAnd、getByte和logicalShift等函数的实现，旨在帮助理解如何使用位运算符进行高效计算。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值