C语言中的进制转换

基础概念

进制又称数制，是指用一组固定的符号和统一的规则来表示数值的方法，在C语言中，可以使用不同的前缀来表示不同的进制：

  • 二进制：以0b或0B为前缀（部分编译器可能不支持）
  • 八进制：以0为前缀
  • 十进制：无特殊前缀
  • 十六进制：以0x或0X为前缀

进制转换方法大约分为3种：

  • 二进制、八进制、十六进制转十进制：
    按照各进制的权值展开，然后相加即可得到十进制数。
  • 十进制转二进制、八进制、十六进制：
    采用除基取余法，即用十进制数除以目标进制的基数，然后取整数部分继续除，直到商为0为止，最后将所有余数从后往前排列，即可得到转换后的数。
  • 二进制、八进制、十六进制之间的转换：
    可以先转换为十进制，然后再转换为目标进制，也可以利用它们之间的关系直接转换，如二进制与八进制之间可以每三位二进制数对应一位八进制数进行转换。

在C语言代码编写中，可以使用标准库函数如printf和scanf来进行进制的输入和输出，比如使用%d格式符输出十进制数，%x或%X输出十六进制数（小写或大写），%o输出八进制数。对于二进制的输入和输出，C语言标准库并未提供直接的支持，但可以通过位运算等技巧实现。

进制位二进制八进制十进制十六进制
规则逢二进一逢八进一逢十进一逢十六进一
基数r=2r=8r=10r=16
数符0,10,1,2,3,…70,1,2,3,…90,1,2,3,…15
权 2 i 2^{i} 2i 8 i 8^{i} 8i 1 0 i 10^{i} 10i 1 6 i 16^{i} 16i
形式表示符BODH

常用的进制转换表：

二进制八进制十进制十六进制
0000000x0
0001110x1
0010220x2
0011330x3
0100440x4
0101550x5
0110660x6
0111770x7
10001080x8
10011190x9
101012100xA
101113110xB
110014120xC
110115130xD
111016140xE
111117150xF

二进制转换

二进制转换为八进制
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
  
void binaryToOctal(char *binary) {  
    int len = strlen(binary);  
    int extraZeros = len % 3; // 计算需要补充的0的个数，让他能被3整除  
    char octal[len / 3 + extraZeros + 1]; // 分配足够的空间来存储八进制数  
    int octalIndex = 0;  
    int binaryIndex = 0;  
      
    // 如果二进制数长度不是3的倍数，则前面补0  
    for (int i = 0; i < extraZeros; i++) {  
        printf("0");  
    }  
      
    while (binaryIndex < len) {  
        int value = 0;  
        for (int i = 0; i < 3 && binaryIndex < len; i++, binaryIndex++) {  
            value = value * 2 + (binary[binaryIndex] - '0');  
        }  
        octal[octalIndex++] = (value < 8) ? (value + '0') : '?'; // ?表示转换错误  
    }  
    octal[octalIndex] = '\0'; // 添加字符串结束符  
    printf("%s\n", octal);  
}  
  
int main() {  
    char binary[] = "1101001"; // 示例
    binaryToOctal(binary); // 调用函数进行转换  
    return 0;  
}

在这里插入图片描述

二进制转换为十进制

使用到了pow()函数，需要添加 -lm 选项来链接libm数学库

gcc test.c -o test -lm
./test

// test.c
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
  
void binaryToOctal(char *binary) {  
    int len = strlen(binary);  
    int extraZeros = len % 3; 
    char octal[len / 3 + extraZeros + 1]; 
    int octalIndex = 0;  
    int binaryIndex = 0;  
      
    for (int i = 0; i < extraZeros; i++) {  
        printf("0");  
    }  
    while (binaryIndex < len) {  
        int value = 0;  
        for (int i = 0; i < 3 && binaryIndex < len; i++, binaryIndex++) {  
            value = value * 2 + (binary[binaryIndex] - '0');  
        }  
        octal[octalIndex++] = (value < 8) ? (value + '0') : '?'; 
    }  
    octal[octalIndex] = '\0'; 
    printf("%s\n", octal);  
}  
  
int main() {  
    char binary[] = "1101001"; 
    binaryToOctal(binary); 
    return 0;  
}

在这里插入图片描述

二进制转换为十六进制
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
  
void binaryToHexadecimal(char *binary) {  
    int length = strlen(binary);  
    int decimal = 0;  
    for (int i = length - 1; i >= 0; i--) {  
        if (binary[i] == '1') {  
            decimal += pow(2, length - 1 - i);  
        }  
    }  
    if (decimal < 16) {  
        if (decimal >= 10) {  
            printf("%c", decimal - 10 + 'A');  
        } else {  
            printf("%d", decimal);  
        }  
    } else {  
        binaryToHexadecimal(binary); 
        int remainder = decimal % 16;  
        if (remainder >= 10) {  
            printf("%c", remainder - 10 + 'A');  
        } else {  
            printf("%d", remainder);  
        }  
    }  
}  
  
int main() {  
    char binary[65]; 
    printf("Enter a binary number: ");  
    scanf("%32s", binary);  
    printf("Hexadecimal representation: ");  
    binaryToHexadecimal(binary);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十进制转换

十进制转换为二进制
#include <stdio.h>  
  
void decimalToBinary(int n) {  
    if (n == 0) {  
        return;  
    }  
    decimalToBinary(n / 2);  
    printf("%d", n % 2);  
}  
  
int main() {  
    int decimal;  
    printf("Enter a decimal number: ");  
    scanf("%d", &decimal);  
    printf("Binary representation: ");  
    decimalToBinary(decimal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十进制转换为八进制
#include <stdio.h>  
  
void decimalToOctal(int n) {  
    if (n < 8) {  
        printf("%d", n);  
        return;  
    }  
    decimalToOctal(n / 8);  
    printf("%d", n % 8);  
}  
  
int main() {  
    int decimal;  
    printf("Enter a decimal number: ");  
    scanf("%d", &decimal);  
    printf("Octal representation: ");  
    decimalToOctal(decimal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十进制转换为十六进制
#include <stdio.h>  
  
void decimalToHexadecimal(int n) {  
    if (n < 16) {  
        if (n >= 10) {  
            printf("%c", n - 10 + 'A');  
        } else {  
            printf("%d", n);  
        }  
        return;  
    }  
    decimalToHexadecimal(n / 16);  
    decimalToHexadecimal(n % 16);  
}  
  
int main() {  
    int decimal;  
    printf("Enter a decimal number: ");  
    scanf("%d", &decimal);  
    printf("Hexadecimal representation: ");  
    decimalToHexadecimal(decimal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

八进制转换

八进制转换为二进制
#include <stdio.h>  
#include <string.h>  
  
void octalToBinary(char *octal) {  
    int length = strlen(octal);  
    for (int i = 0; i < length; i++) {  
        int digit = octal[i] - '0';  
        switch (digit) {  
            case 7: printf("111"); break;  
            case 6: printf("110"); break;  
            case 5: printf("101"); break;  
            case 4: printf("100"); break;  
            case 3: printf("011"); break;  
            case 2: printf("010"); break;  
            case 1: printf("001"); break;  
            case 0: printf("000"); break;  
        }  
    }  
}  
  
int main() {  
    char octal[33];
    printf("Enter an octal number: ");  
    scanf("%32s", octal);  
    printf("Binary representation: ");  
    octalToBinary(octal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

八进制转换为十进制
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
  
long long octalToDecimal(char *octal) {  
    int length = strlen(octal);  
    long long decimal = 0;  
    for (int i = 0; i < length; i++) {  
        int digit = octal[i] - '0';  
        decimal += digit * pow(8, length - 1 - i);  
    }  
    return decimal;  
}  
  
int main() {  
    char octal[33]; 
    printf("Enter an octal number: ");  
    scanf("%32s", octal);  
    long long decimal = octalToDecimal(octal);  
    printf("Decimal representation: %lld\n", decimal);  
    return 0;  
}

在这里插入图片描述

八进制转换为十六进制
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
  
long long octalToDecimal(char *octal) {  
    int length = strlen(octal);  
    long long decimal = 0;  
    for (int i = 0; i < length; i++) {  
        int digit = octal[i] - '0';  
        decimal += digit * pow(8, length - 1 - i);  
    }  
    return decimal;    
}  
  
void decimalToHexadecimal(long long decimal) {    
    if (decimal < 16) {    
        if (decimal >= 10) {     
            printf("%c", (int)(decimal - 10 + 'A'));    
        } else {    
            printf("%lld", decimal);    
        }    
    } else {    
        decimalToHexadecimal(decimal / 16);    
        decimalToHexadecimal(decimal % 16);    
    }    
}
int main() {  
    char octal[33]; 
    printf("Enter an octal number: ");  
    scanf("%32s", octal);  
    long long decimal = octalToDecimal(octal);  
    printf("Hexadecimal representation: ");  
    decimalToHexadecimal(decimal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十六进制转换

十六进制转换为二进制
#include <stdio.h>  
#include <string.h>  
#include <ctype.h>  

void hexadecimalToBinary(char hex) {  
    switch (toupper(hex)) {  
        case '0': printf("0000"); break;  
        case '1': printf("0001"); break;  
        case '2': printf("0010"); break;  
        case '3': printf("0011"); break;  
        case '4': printf("0100"); break;  
        case '5': printf("0101"); break;  
        case '6': printf("0110"); break;  
        case '7': printf("0111"); break;  
        case '8': printf("1000"); break;  
        case '9': printf("1001"); break;  
        case 'A': case 'a': printf("1010"); break;  
        case 'B': case 'b': printf("1011"); break;  
        case 'C': case 'c': printf("1100"); break;  
        case 'D': case 'd': printf("1101"); break;  
        case 'E': case 'e': printf("1110"); break;  
        case 'F': case 'f': printf("1111"); break;  
        default: printf("Invalid hexadecimal digit\n"); break;  
    }  
}  
  
int main() {  
    char hexadecimal[100];  
    printf("Enter a hexadecimal number: ");  
    scanf("%s", hexadecimal);  
    printf("Binary representation: ");  
    for (int i = 0; hexadecimal[i] != '\0'; i++) {  
        hexadecimalToBinary(hexadecimal[i]);  
    }  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十六进制转换为八进制
#include <stdio.h>  
#include <string.h>  
#include <ctype.h>  
  
int hexadecimalToOctalDigit(char hex) {  
    switch (toupper(hex)) {  
        case '0': return 0;  
        case '1': return 1;  
        case '2': return 2;  
        case '3': return 3;  
        case '4': return 4;  
        case '5': return 5;  
        case '6': return 6;  
        case '7': return 7;  
        case '8': return 10; 
        case '9': return 11;
        case 'A': case 'a': return 12;
        case 'B': case 'b': return 13;
        case 'C': case 'c': return 14; 
        case 'D': case 'd': return 15; 
        case 'E': case 'e': return 16; 
        case 'F': case 'f': return 17; 
        default: return -1; 
    }  
}  
  
void hexadecimalToOctal(const char *hexadecimal) {  
    int length = strlen(hexadecimal);  
    int value = 0;  
    int base = 1;  
    for (int i = length - 1; i >= 0; --i) {  
        int digit = hexadecimalToOctalDigit(hexadecimal[i]);  
        if (digit == -1) {  
            printf("Invalid hexadecimal input\n");  
            return;  
        }  
        value += digit * base;  
        base = base == 1 ? 8 : base * 16;  
        if (base == 128) { 
            printf("%o", value); 
            value = 0; 
            base = 1; 
        }  
    }  
    if (value > 0) { 
        printf("%o", value);  
    }  
}  
  
int main() {  
    char hexadecimal[100];  
    printf("Enter a hexadecimal number: ");  
    scanf("%s", hexadecimal);  
    printf("Octal representation: ");  
    hexadecimalToOctal(hexadecimal);  
    printf("\n");  
    return 0;  
}

在这里插入图片描述

十六进制转换为十进制
#include <stdio.h>  
#include <string.h>  
#include <math.h>  
#include <ctype.h>  
  
long long hexadecimalToDecimal(const char *hexadecimal) {  
    long long decimal = 0;  
    int length = strlen(hexadecimal);  
    for (int i = length - 1, power = 0; i >= 0; --i, ++power) {  
        int digit = 0;  
        char c = toupper(hexadecimal[i]);  
        if (c >= '0' && c <= '9') {  
            digit = c - '0';  
        } else if (c >= 'A' && c <= 'F') {  
            digit = 10 + (c - 'A');  
        } else {  
            printf("Invalid hexadecimal input\n");  
            return -1;  
        }  
        decimal += digit * pow(16, power);  
    }  
    return decimal;  
}  
  
int main() {  
    char hexadecimal[100];  
    printf("Enter a hexadecimal number: ");  
    scanf("%s", hexadecimal);  
    long long decimal = hexadecimalToDecimal(hexadecimal);  
    if (decimal != -1) {  
        printf("Decimal representation: %lld\n", decimal);  
    }  
    return 0;  
}

在这里插入图片描述

字符转换

#include <stdio.h>  
#include <string.h>  
#include <math.h>  
#include <ctype.h>  

 // 十进制
int charToDecimal(char c) {  
    return (int)c;  
}
// 二进制
void charToBinary(char c, char *binary) {  
    int decimal = (int)c;  
    int index = 0;  
    while (decimal > 0) {  
        binary[index++] = (decimal % 2) + '0';  
        decimal /= 2;  
    }  
    binary[index] = '\0'; 
    for (int i = 0; i < index / 2; i++) {  
        char temp = binary[i];  
        binary[i] = binary[index - i - 1];  
        binary[index - i - 1] = temp;  
    }  
}
// 八进制
void charToOctal(char c, char *octal) {  
    int decimal = (int)c;  
    int index = 0;  
    while (decimal > 0) {  
        octal[index++] = (decimal % 8) + '0';  
        decimal /= 8;  
    }  
    octal[index] = '\0'; 
    for (int i = 0; i < index / 2; i++) {  
        char temp = octal[i];  
        octal[i] = octal[index - i - 1];  
        octal[index - i - 1] = temp;  
    }  
}
// 十六进制
void charToHexadecimal(char c, char *hexadecimal) {  
    int decimal = (int)c;  
    int index = 0;  
    while (decimal > 0) {  
        int digit = decimal % 16;  
        if (digit < 10) {  
            hexadecimal[index++] = digit + '0';  
        } else {  
            hexadecimal[index++] = (digit - 10) + 'A';  
        }  
        decimal /= 16;  
    }  
    hexadecimal[index] = '\0'; 
  
    for (int i = 0; i < index / 2; i++) {  
        char temp = hexadecimal[i];  
        hexadecimal[i] = hexadecimal[index - i - 1];  
        hexadecimal[index - i - 1] = temp;  
    }  
}

int main() {  
    char inputChar;  
    printf("Enter a character: ");  
    scanf(" %c", &inputChar); // c前有一个空格，可以跳过任何空白字符  
  

    int decimal = charToDecimal(inputChar);  
    printf("Decimal(十进制): %d\n", decimal);  
  
    char binary[33]; // 32位表示一个字符的ASCII码的二进制形式  
    charToBinary(inputChar, binary);  
    printf("Binary(二进制): %s\n", binary);  

    char octal[12]; // 最多需要11位来表示一个字符的ASCII码的八进制形式  
    charToOctal(inputChar, octal);  
    printf("Octal(八进制): %s\n", octal);  
  
    char hexadecimal[9]; // 最多需要8位来表示一个字符的ASCII码的十六进制形式  
    charToHexadecimal(inputChar, hexadecimal);  
    printf("Hexadecimal(十六进制): %s\n", hexadecimal);  
  
    return 0;  
}

在这里插入图片描述

十六进制在内存操作上的应用

这里给分配一段动态内存，并使用十六进制值初始化这块内存区域，然后打印出内存中的内容

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
  
int main() {  
    // 动态分配一个包含16个字节的内存块  
    unsigned char *memoryBlock = (unsigned char *)malloc(16 * sizeof(unsigned char));  
    if (memoryBlock == NULL) {  
        printf("Memory allocation failed.\n");  
        return 1;  
    }  
  
    // 使用十六进制值初始化内存块  
    unsigned char initValues[] = {0xA1, 0xB2, 0xC3, 0xD4, 0xE5, 0xF6, 0x07, 0x18,  
                                  0x29, 0x3A, 0x4B, 0x5C, 0x6D, 0x7E, 0x8F, 0x90};  
      
    // 将初始化值复制到分配的内存块中  
    memcpy(memoryBlock, initValues, 16 * sizeof(unsigned char));  
  
    // 打印内存块中的内容，以十六进制形式展示  
    printf("Memory contents (in hexadecimal):\n");  
    for (int i = 0; i < 16; ++i) {  
        printf("%02X ", memoryBlock[i]);  
        if ((i + 1) % 8 == 0) {  
            printf("\n");  
        }  
    }  
    printf("\n");  
  
    free(memoryBlock);  
    return 0;  
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/736091.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Go日常分享 - error类型是指针类型吗？

Go日常分享 - error类型是指针类型吗？

背景 这个问题的产生来源于小泉在开发rpc接口时返回error遇到的问题&#xff0c;开发时想在defer里对err进行最终的统一处理赋值&#xff0c;发现外层接收一直都未生效。问题可以简化为成下面的小demo。 func returnError() error {var err errordefer func() {//err errors…
阅读更多...
物联网系统运维——数据库部署

物联网系统运维——数据库部署

一.MySQL 1.概要 MySQL是一种关联数据库管理系统&#xff0c;关联数据:而不是将所有数据放在一个大仓库内&#xff0c;这样就增加了速度并提高了灵活性库将数据保存在不同的表中。性能高、成本低、可靠性好&#xff0c;已经成为最流行的开源数据库。 二.MySQL安装与配置 1. …
阅读更多...
38.MessageToMessageCodec线程安全可被共享Handler

38.MessageToMessageCodec线程安全可被共享Handler

handler被注解@Sharable修饰的。 这样的handler，创建一个实例就够了。例如： ByteToMessageCodec的子类不能被@Sharable修饰 如果自定义类是MessageToMessageCodec的子类就是线程共享的，可以被@Sharable修饰的 package com.xkj.protocol;import com.xkj.message.Message; i…
阅读更多...
浙大宁波理工学院2024年成人高等继续教育招生简章

浙大宁波理工学院2024年成人高等继续教育招生简章

浙大宁波理工学院&#xff0c;这所承载着深厚学术底蕴和卓越教育理念的学府&#xff0c;正热烈开启2024年成人高等继续教育的招生之门。这里&#xff0c;是知识的殿堂&#xff0c;是智慧的摇篮&#xff0c;更是您实现个人梦想、追求更高境界的起点。 ​浙大宁波理工学院始终坚…
阅读更多...
[最全]设计模式实战（一）UML六大原则

[最全]设计模式实战（一）UML六大原则

UML类图 UML类图是学习设计模式的基础，学习设计模式，主要关注六种关系。即：继承、实现、组合、聚合、依赖和关联。 UML类图基本用法 继承关系用空心三角形+实线来表示。实现接口用空心三角形+虚线来表示。eg：大雁是最能飞的，它实现了飞翔接口。 关联关系用实线箭头来表示…
阅读更多...
基础算法---滑动窗口

基础算法---滑动窗口

文章目录 什么是滑动窗口1.长度最小的子数组2.无重复字符的最长子串3.最大连续1的个数4.将x减到0的最小操作数5.最小覆盖子串总结 什么是滑动窗口 滑动窗口&#xff08;Sliding Window&#xff09;是一种在计算机科学中用于解决各种子数组或子字符串问题的技术。滑动窗口技术通…
阅读更多...
在 Mac 上恢复已删除的文件夹

在 Mac 上恢复已删除的文件夹

“嗨&#xff0c;我刚刚运行了重复文件查找器应用程序 Gemini 来扫描我的 Mac 以清除重复文件。它找到了很多重复的文件和文件夹&#xff0c;只需单击一下&#xff0c;它就可以帮助我删除重复的文件/文件夹。但我认为它可能会删除一些有用的重复文件。我打开垃圾箱&#xff0c;…
阅读更多...
主数据驱动的数据治理：技术解析与实践探索

主数据驱动的数据治理：技术解析与实践探索

数字化转型行业小伙伴可以加入我的星球&#xff0c;初衷成为各位数字化转型参考库&#xff0c;星球内容每周更新 个人工作经验资料全部放在这里&#xff0c;包含数据治理、数据要素、数据质量、数据安全、元数据、主数据、企业架构、DCMM、DSMM、CDGA、CDGP等各种数据相关材料 …
阅读更多...
AOP应用之系统操作日志

AOP应用之系统操作日志

本文演示下如何使用AOP&#xff0c;去实现系统操作日志功能。 实现步骤 引入AOP包 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId><version>2.6.6</version></de…
阅读更多...
AI大眼萌探索 AI 新世界：Ollama 使用指南【1】

AI大眼萌探索 AI 新世界：Ollama 使用指南【1】

在人工智能的浪潮中&#xff0c;Ollama 的出现无疑为 Windows 用户带来了一场革命。这款工具平台以其开创性的功能&#xff0c;简化了 AI 模型的开发与应用&#xff0c;让每一位爱好者都能轻松驾驭 AI 的强大力量。大家好&#xff0c;我是AI大眼萌&#xff0c;今天我们将带大家…
阅读更多...
颠覆多跳事实验证！Causal Walk 前门调整技术引领去偏新纪元

颠覆多跳事实验证！Causal Walk 前门调整技术引领去偏新纪元

Causal Walk: Debiasing Multi-Hop Fact Verifcation with Front-Door Adjustment 论文地址： Causal Walk: Debiasing Multi-Hop Fact Verification with Front-Door Adjustment| Proceedings of the AAAI Conference on Artificial Intelligencehttps://ojs.aaai.org/index.p…
阅读更多...
基于Vue-cli脚手架搭建项目使用ElementUI组件

基于Vue-cli脚手架搭建项目使用ElementUI组件

项目结构 node_modules 项目依赖的外部组件文件放在此处,例如vue public index.html是对外提供的唯一的html文件 src assets 存放静态文件 例如图片 css js等文件 components 里面存放的是组件 App.vue是组件 main.js是项目配置文件 package.json存放的是项目依赖的…
阅读更多...
C# Onnx Yolov5 水果识别，人员识别，物品识别 人工智能

C# Onnx Yolov5 水果识别，人员识别，物品识别 人工智能

目录 先上效果 来电废话&#xff0c;但实用 网络成功案例实践易失败的原因 万物检测涉及技术 下载合集 关键代码 全部代码 实操vs2022安装关键 YOLO V5核心库编译 编写自己识别软件 更新相关依赖 标注字库文件 测试效果 名词解释YOLO 名词解释ONNX 源码 直播教…
阅读更多...
基于Java的火车订票管理系统【附源码】

基于Java的火车订票管理系统【附源码】

火车订票管理登录 摘要&#xff1a;随着我国铁路交通的不断发展&#xff0c;简单的窗口售票模式已经不能满足方便人们出行的目的。采用先进的网络技术开发出方便快捷的火车票订票系统是现代客运业务发展的必然需求。本次设计的火车票订票系统通过访问主页&#xff0c;可以实现…
阅读更多...
Linux PXE高效批量装机

Linux PXE高效批量装机

部署PXE远程安装服务 在大规模的 Linux 应用环境中&#xff0c;如 Web 群集、分布式计算等&#xff0c;服务器往往并不配备光驱设备&#xff0c;在这种情况下&#xff0c;如何为数十乃至上百台服务器裸机快速安装系统呢?传统的USB光驱、移动硬盘等安装方法显然已经难以满足需…
阅读更多...
VC++支持断点续下或续传的功能

VC++支持断点续下或续传的功能

VC使用多线程和Socket实现断点续下 一、断点续下的基本原理&#xff1a; 1.断点续传的理解可以分为两部分&#xff1a;一部分是断点&#xff0c;一部分是续传。断点的由来是在下载过程中&#xff0c;将一个下载文件分成了多个部分&#xff0c;同时进行多个部分一起的下载&…
阅读更多...
Python武器库开发-武器库篇之ThinkPHP 5.0.23-RCE 漏洞复现（六十四）

Python武器库开发-武器库篇之ThinkPHP 5.0.23-RCE 漏洞复现（六十四）

Python武器库开发-武器库篇之ThinkPHP 5.0.23-RCE 漏洞复现&#xff08;六十四&#xff09; 漏洞环境搭建 这里我们使用Kali虚拟机安装docker并搭建vulhub靶场来进行ThinkPHP漏洞环境的安装&#xff0c;我们进入 ThinkPHP漏洞环境&#xff0c;可以 cd ThinkPHP&#xff0c;然…
阅读更多...
每日一题——Python代码实现PAT乙级1048 数字加密（举一反三+思想解读+逐步优化）五千字好文

每日一题——Python代码实现PAT乙级1048 数字加密（举一反三+思想解读+逐步优化）五千字好文

一个认为一切根源都是“自己不够强”的INTJ 个人主页&#xff1a;用哲学编程-CSDN博客专栏&#xff1a;每日一题——举一反三Python编程学习Python内置函数 Python-3.12.0文档解读 目录 初次尝试 再次尝试 代码点评 代码结构 时间复杂度 空间复杂度 优化建议 我要更强…
阅读更多...
【Linux】IP协议、以太网帧格式

【Linux】IP协议、以太网帧格式

目录 网络层IP协议协议头格式网段划分分类划分法特殊的 IP 地址IP 地址的数量限制私有 IP 地址和公有 IP 地址路由路由表生成算法 数据链路层以太网以太网帧格式认识 MAC 地址ARP协议ARP数据报格式 ARP 协议的工作流程ARP欺骗 DNShosts 文件域名的层级关系域名服务器分类域名解…
阅读更多...
day3-xss漏洞（米斯特web渗透测试）

day3-xss漏洞（米斯特web渗透测试）

day3-xss漏洞&#xff08;米斯特web渗透测试&#xff09; XSSXss种类三种反射型1.反射型xss2.存储型xss3.DOM型xss XSS Xss有一部分是前端的有一部分不是前端的&#xff0c;我们来看一下&#xff0c;昨天的HTML注入修复方法应灵活使用。 HTML注入是注入一段HTML&#xff0c;那…
阅读更多...
最新文章

Copyright @ 2022~2023