进制转换在C/C++/Java/Kotlin中的应用(详细版)（下）

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = 12; // 十进制数12，二进制数1100
    int c = a & b; // 按位与运算，结果为8，二进制数1000
    printf("%d\n", c); // 输出8
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = 12; // 十进制数12，二进制数1100
    int c = a | b; // 按位或运算，结果为14，二进制数1110
    printf("%d\n", c); // 输出14
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = 12; // 十进制数12，二进制数1100
    int c = a ^ b; // 按位异或运算，结果为6，二进制数0110
    printf("%d\n", c); // 输出6
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = ~a; // 按位取反运算，结果为-11，二进制数11111111111111111111111111110101（补码表示）
    printf("%d\n", b); // 输出-11
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = a >> 2; // 右移2位，结果为2，二进制数0010
    printf("%d\n", b); // 输出2
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 10; // 十进制数10，二进制数1010
    int b = a << 2; // 左移2位，结果为40，二进制数101000
    printf("%d\n", b); // 输出40
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
// 将二进制字符串转换为长整型
long binToLong(const char *binStr) {
    return strtol(binStr, NULL, 2);
}
// 将十六进制字符串转换为长整型
long hexToLong(const char *hexStr) {
    return strtol(hexStr, NULL, 16);
}
// 设置高n位为1
long setHighNBits(long num, int totalBits, int n) {
    return num | ((1 << n) - 1) << (totalBits - n);
}
// 清除高n位
long clearHighNBits(long num, int totalBits, int n) {
    return num & ~(((1 << n) - 1) << (totalBits - n));
}
// 设置低n位为1
long setLowNBits(long num, int n) {
    return num | (1 << n) - 1;
}
// 清除低n位
long clearLowNBits(long num, int n) {
    return num & ~((1 << n) - 1);
}
int main() {
    char *s1 = "1010"; 
    char *s2 = "1011";
    char *s3 = "FFFF"; 
    long n1 = binToLong(s1);
    long n2 = binToLong(s2);
    long n3 = n1 & n2;
    long n4 = n1 | n2;
    long n5 = n1 ^ n2;
    long n6 = hexToLong(s3);
  printf("二进制 1010 = %ld\n", n1);  // 10
  printf("二进制 1011 = %ld\n", n2);  // 11
  printf("1010 & 1011 = %ld  (与操作)\n", n3);  // 10
  printf("1010 | 1011 = %ld  (或操作)\n", n4);  // 11
  printf("1010 ^ 1011 = %ld  (异或操作)\n", n5);  // 1
  printf("1011 << 2 = %ld  (左移2位)\n", n2 << 2);  // 44
  printf("1011 >> 2 = %ld  (右移2位)\n", n2 >> 2);  // 2
  printf("65,535 & ~(1 << 3) (清除第3位) = %ld\n", (n6 & ~(1 << 3)));  // 65527
  printf("65527 | (1 << 3) (设置第3位) = %ld\n", (65527 | (1 << 3)));  // 65535
  printf("65527 ^ (1 << 3) (切换第3位) = %ld\n", (65527 ^ (1 << 3)));  // 65535
  printf("65535 ^ (1 << 3) (切换第3位) = %ld\n", (65535 ^ (1 << 3)));  // 65527
  printf("(65535 & (1 << 3)) != 0 (检查第3位) = %d\n", ((65535 & (1 << 3)) != 0));  // 1
  printf("(65527 & (1 << 3)) != 0 (检查第3位) = %d\n", ((65527 & (1 << 3)) != 0));  // 0
  // 高级操作
  printf("设置16383的最高2位为1 = %ld\n", setHighNBits(16383, 16, 2));  // 65535
  printf("清除65535的最高2位 = %ld\n", clearHighNBits(65535, 16, 2));  // 16383
  printf("设置65532的最低2位为1 = %ld\n", setLowNBits(65532, 2));  // 65535
  printf("清除65535的最低2位 = %ld\n", clearLowNBits(65535, 2));  // 65532
    return 0;
}

#include <stdio.h>
int main()
{
    int a = 0xABC; // 十六进制数ABC
    int b = 0b101010111100; // 二进制数101010111100
    int c = 0123; // 八进制数123
    int d = 0b001010011; // 二进制数001010011
    // 将十六进制数转换为二进制数
    printf("0x%X = ", a); // 输出0xABC =
    for (int i = 12; i > 0; i -= 4) { // 每次右移4位，取最低4位
        int x = (a >> (i - 4)) & 0xF; // 取最低4位的十六进制数字
        printf("%04b", x); // 输出对应的四位二进制数
    }
    printf("\n"); // 输出换行符
    // 将二进制数转换为十六进制数
    printf("0b%b = ", b); // 输出0b101010111100 =
    for (int i = 12; i > 0; i -= 4) { // 每次右移4位，取最低4位
        int x = (b >> (i - 4)) & 0xF; // 取最低4位的二进制数
        printf("%X", x); // 输出对应的十六进制数字
    }
    printf("\n"); // 输出换行符
    // 将八进制数转换为二进制数
    printf("0%o = ", c); // 输出0123 =
    for (int i = 9; i > 0; i -= 3) { // 每次右移3位，取最低3位
        int x = (c >> (i - 3)) & 0x7; // 取最低3位的八进制数字
        printf("%03b", x); // 输出对应的三位二进制数
    }
    printf("\n"); // 输出换行符
    // 将二进制数转换为八进制数
    printf("0b%b = ", d); // 输出0b001010011 =
    for (int i = 9; i > 0; i -= 3) { // 每次右移3位，取最低3位
        int x = (d >> (i - 3)) & 0x7; // 取最低3位的二进制数
        printf("%o", x); // 输出对应的八进制数字
    }
    printf("\n"); // 输出换行符
    return 0;
}

0xABC = 101010111100
0b101010111100 = ABC
0123 = 001010011
0b001010011 = 123

#include <stdio.h>
// 假设我们有一个8位的寄存器，用于控制8个LED灯的亮灭
// 我们使用一个字节（8位）来模拟这个寄存器
typedef unsigned char Register;
// LED控制函数
void turnOnLED(Register *reg, int ledNum) {
    *reg |= (1 << ledNum); // 设置指定位为1，亮起LED灯
}
void turnOffLED(Register *reg, int ledNum) {
    *reg &= ~(1 << ledNum); // 清除指定位，熄灭LED灯
}
void toggleLED(Register *reg, int ledNum) {
    *reg ^= (1 << ledNum); // 切换指定位，如果LED灯亮则熄灭，如果熄灭则亮起
}
int isLEDOn(Register reg, int ledNum) {
    return (reg & (1 << ledNum)) != 0; // 检查指定位是否为1
}
int main() {
    Register LEDRegister = 0; // 初始状态，所有LED灯都熄灭
    turnOnLED(&LEDRegister, 2); // 亮起第2个LED灯
    printf("LED 2状态: %s\n", isLEDOn(LEDRegister, 2) ? "亮" : "灭");//LED 2状态: 亮
    toggleLED(&LEDRegister, 2); // 切换第2个LED灯的状态
    printf("LED 2状态: %s\n", isLEDOn(LEDRegister, 2) ? "亮" : "灭");//LED 2状态: 灭
    turnOffLED(&LEDRegister, 2); // 熄灭第2个LED灯
    printf("LED 2状态: %s\n", isLEDOn(LEDRegister, 2) ? "亮" : "灭");//LED 2状态: 灭
    return 0;
}

#include <stdio.h>
#include <stdint.h>
// 假设我们有一个32位的can_id(扩展帧ID)，其中高3位用于标志位，低29位用于ID
typedef uint32_t CAN_ID;
// CAN帧结构体
typedef struct {
    CAN_ID can_id;
    // 其他字段，如数据、DLC等
} CAN_Frame;
// 清除标志位
CAN_ID cleanCANID(CAN_ID id) {
    return id & 0x1FFFFFFF; // 清除高3位
}
// 检查是否为扩展帧
int isExtendedFrame(CAN_ID id) {
    return (id & 0x80000000) != 0; // 检查最高位
}
int main() {
    CAN_Frame frame;
    frame.can_id = 0x98121001; // 假设这是一个扩展帧的ID
    printf("原始CAN ID: 0x%X\n", frame.can_id);//原始CAN ID: 0x98121001
    printf("清除标志位后的CAN ID: 0x%X\n", cleanCANID(frame.can_id));//清除标志位后的CAN ID: 0x18121001
    printf("是否为扩展帧: %s\n", isExtendedFrame(frame.can_id) ? "是" : "否");//是否为扩展帧: 是
    return 0;
}