c语言进制转换器（十进制转二进制）

在C语言中，编写一个进制转换器来将十进制数转换为二进制数是一个常见的编程练习。以下是一个简单的C语言程序示例，展示了如何实现十进制到二进制的转换：

#include <stdio.h>

void decimalToBinary(int n) {
    int binaryNum[32]; // 用于存储二进制位的数组
    int i = 0;

    // 处理0的特殊情况
    if (n == 0) {
        printf("二进制表示: 0\n");
        return;
    }

    // 处理负数的情况
    if (n < 0) {
        printf("负数的二进制表示为补码形式。\n");
        n = -n;
    }

    // 将十进制数转换为二进制数
    while (n > 0) {
        binaryNum[i] = n % 2;
        n = n / 2;
        i++;
    }

    // 打印二进制数
    printf("二进制表示: ");
    for (int j = i - 1; j >= 0; j--) {
        printf("%d", binaryNum[j]);
    }
    printf("\n");

相关问题

c语言通过栈实现进制转换器 实现10进制、2进制、8进制和16进制的相互转换。

好的，以下是通过栈实现进制转换器的示例代码，使用 C 语言实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_STACK_SIZE 100

typedef struct {
    int top;
    char items[MAX_STACK_SIZE];
} Stack;

void init_stack(Stack *stack) {
    stack->top = -1;
}

int is_empty(Stack *stack) {
    return stack->top == -1;
}

int is_full(Stack *stack) {
    return stack->top == MAX_STACK_SIZE - 1;
}

void push(Stack *stack, char item) {
    if (is_full(stack)) {
        printf("Stack is full\n");
        exit(EXIT_FAILURE);
    }
    stack->items[++stack->top] = item;
}

char pop(Stack *stack) {
    if (is_empty(stack)) {
        printf("Stack is empty\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[stack->top--];
}

char peek(Stack *stack) {
    if (is_empty(stack)) {
        printf("Stack is empty\n");
        exit(EXIT_FAILURE);
    }
    return stack->items[stack->top];
}

int size(Stack *stack) {
    return stack->top + 1;
}

void decimal_to_binary(int decimal_num) {
    Stack stack;
    init_stack(&stack);

    while (decimal_num > 0) {
        int remainder = decimal_num % 2;
        push(&stack, remainder + '0');
        decimal_num = decimal_num / 2;
    }

    printf("Binary: ");
    while (!is_empty(&stack)) {
        printf("%c", pop(&stack));
    }
    printf("\n");
}

void decimal_to_octal(int decimal_num) {
    Stack stack;
    init_stack(&stack);

    while (decimal_num > 0) {
        int remainder = decimal_num % 8;
        push(&stack, remainder + '0');
        decimal_num = decimal_num / 8;
    }

    printf("Octal: ");
    while (!is_empty(&stack)) {
        printf("%c", pop(&stack));
    }
    printf("\n");
}

void decimal_to_hexadecimal(int decimal_num) {
    Stack stack;
    init_stack(&stack);

    while (decimal_num > 0) {
        int remainder = decimal_num % 16;
        if (remainder < 10) {
            push(&stack, remainder + '0');
        } else {
            push(&stack, remainder - 10 + 'A');
        }
        decimal_num = decimal_num / 16;
    }

    printf("Hexadecimal: ");
    while (!is_empty(&stack)) {
        printf("%c", pop(&stack));
    }
    printf("\n");
}

void binary_to_decimal(char *binary_string) {
    int decimal_num = 0;
    int power = 0;

    for (int i = strlen(binary_string) - 1; i >= 0; i--) {
        int digit = binary_string[i] - '0';
        decimal_num += digit * (1 << power);
        power++;
    }

    printf("Decimal: %d\n", decimal_num);
}

void octal_to_decimal(char *octal_string) {
    int decimal_num = 0;
    int power = 0;

    for (int i = strlen(octal_string) - 1; i >= 0; i--) {
        int digit = octal_string[i] - '0';
        decimal_num += digit * (1 << (power * 3));
        power++;
    }

    printf("Decimal: %d\n", decimal_num);
}

void hexadecimal_to_decimal(char *hexadecimal_string) {
    int decimal_num = 0;
    int power = 0;

    for (int i = strlen(hexadecimal_string) - 1; i >= 0; i--) {
        char c = hexadecimal_string[i];
        int digit;
        if (c >= '0' && c <= '9') {
            digit = c - '0';
        } else if (c >= 'A' && c <= 'F') {
            digit = c - 'A' + 10;
        } else if (c >= 'a' && c <= 'f') {
            digit = c - 'a' + 10;
        } else {
            printf("Invalid hexadecimal string\n");
            exit(EXIT_FAILURE);
        }
        decimal_num += digit * (1 << (power * 4));
        power++;
    }

    printf("Decimal: %d\n", decimal_num);
}

int main() {
    int decimal_num = 123;

    decimal_to_binary(decimal_num);
    decimal_to_octal(decimal_num);
    decimal_to_hexadecimal(decimal_num);

    char *binary_string = "1111011";
    char *octal_string = "173";
    char *hexadecimal_string = "7B";

    binary_to_decimal(binary_string);
    octal_to_decimal(octal_string);
    hexadecimal_to_decimal(hexadecimal_string);

    return 0;
}

以上是一个基本的栈实现进制转换器的示例代码，可以实现十进制、二进制、八进制和十六进制之间的相互转换。其中，我们定义了一个 `Stack` 结构体来实现栈的基本操作，然后分别实现了将十进制转换为二进制、八进制和十六进制的函数 `decimal_to_binary`、`decimal_to_octal` 和 `decimal_to_hexadecimal`，以及将二进制、八进制和十六进制转换为十进制的函数 `binary_to_decimal`、`octal_to_decimal` 和 `hexadecimal_to_decimal`。

c语言数字进制转换器 要求：任意输入一个十进制整数及需要转换的数字进制(g 二进制八进制)，并最终揄出所转换进制的最终数宇(提升：可考虑复杂情形，如负数、小数情形的转换) 如输入10,2 输出的结果是1010

以下是C语言数字进制转换器的代码，支持任意进制转换，包括负数和小数的转换：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

char digitToChar(int digit)
{
    if (digit < 10)
        return digit + '0';
    else
        return digit - 10 + 'A';
}

int charToDigit(char ch)
{
    if (ch >= '0' && ch <= '9')
        return ch - '0';
    else if (ch >= 'a' && ch <= 'z')
        return ch - 'a' + 10;
    else if (ch >= 'A' && ch <= 'Z')
        return ch - 'A' + 10;
    else
        return -1;
}

void reverse(char *str, int len)
{
    for (int i = 0; i < len / 2; i++)
    {
        char temp = str[i];
        str[i] = str[len - i - 1];
        str[len - i - 1] = temp;
    }
}

void intToBase(char *str, int base, int num)
{
    int len = 0;
    while (num)
    {
        int rem = num % base;
        str[len++] = digitToChar(rem);
        num /= base;
    }
    if (len == 0)
        str[len++] = '0';
    reverse(str, len);
    str[len] = '\0';
}

void floatToBase(char *str, int base, double num)
{
    int int_part = (int)num;
    double frac_part = num - int_part;
    int len = 0;
    intToBase(str, base, int_part);
    len = strlen(str);
    if (frac_part > 0)
    {
        str[len++] = '.';
        for (int i = 0; i < 8; i++)
        {
            frac_part *= base;
            int digit = (int)frac_part;
            frac_part -= digit;
            str[len++] = digitToChar(digit);
        }
    }
    str[len] = '\0';
}

void baseToInt(int *num, int base, char *str)
{
    *num = 0;
    int len = strlen(str);
    for (int i = 0; i < len; i++)
    {
        int digit = charToDigit(str[i]);
        if (digit >= base)
        {
            printf("Error: invalid digit '%c' in base %d\n", str[i], base);
            *num = 0;
            return;
        }
        *num = *num * base + digit;
    }
}

void baseToFloat(double *num, int base, char *str)
{
    *num = 0;
    int len = strlen(str);
    int dot_pos = -1;
    for (int i = 0; i < len; i++)
    {
        if (str[i] == '.')
        {
            dot_pos = i;
            break;
        }
    }
    if (dot_pos == -1)
    {
        baseToInt((int*)num, base, str);
    }
    else
    {
        char int_part[100];
        strncpy(int_part, str, dot_pos);
        int_part[dot_pos] = '\0';
        int int_num;
        baseToInt(&int_num, base, int_part);
        *num = int_num;
        double frac_part = 0;
        double frac_base = 1.0 / base;
        for (int i = dot_pos + 1; i < len; i++)
        {
            int digit = charToDigit(str[i]);
            if (digit >= base)
            {
                printf("Error: invalid digit '%c' in base %d\n", str[i], base);
                *num = 0;
                return;
            }
            frac_part += digit * frac_base;
            frac_base /= base;
        }
        *num += frac_part;
    }
}

int main()
{
    int base, int_num;
    double float_num;
    char str[100];
    printf("请输入数字的进制（2-36）：");
    scanf("%d", &base);
    printf("请输入需要转换的数字：");
    scanf("%s", str);
    if (str[0] == '-')
    {
        baseToFloat(&float_num, base, str + 1);
        printf("转换后的结果为：%lf\n", -float_num);
    }
    else if (str[0] == '0' && str[1] == 'x')
    {
        baseToInt(&int_num, 16, str + 2);
        intToBase(str, base, int_num);
        printf("转换后的结果为：%s\n", str);
    }
    else
    {
        baseToFloat(&float_num, base, str);
        printf("转换后的结果为：%lf\n", float_num);
    }
    return 0;
}

在程序中，我们先定义了一些辅助函数，包括将数字转换成字符、将字符转换成数字、字符串翻转、整数转换为任意进制字符串、浮点数转换为任意进制字符串、任意进制字符串转换为整数和任意进制字符串转换为浮点数。

然后，在main函数中，我们先获取需要转换的数字的进制和字符串表示，然后根据字符串的第一个字符判断是否为负数或十六进制表示。如果字符串以负号开头，则先将其转换为浮点数，然后取负数并输出。如果字符串以"0x"开头，则将其视为十六进制数，先将其转换为整数，然后再将其转换为任意进制字符串并输出。否则，将字符串转换为浮点数，并输出。

在整数转换为任意进制字符串和任意进制字符串转换为整数的函数中，我们通过不断除以进制数并取余数的方式来将整数转换为任意进制字符串，或者将任意进制字符串转换为整数。

在浮点数转换为任意进制字符串和任意进制字符串转换为浮点数的函数中，我们先将整数部分转换为任意进制字符串，然后再将小数部分乘以进制数不断取整的方式转换为任意进制字符串。

需要注意的是，在任意进制字符串转换为整数和浮点数的过程中，需要判断字符串中是否包含无效的数字，如果包含则输出错误信息。