【无标题】

原创 已于 2024-10-26 01:27:27 修改 · 575 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#算法
于 2024-10-25 01:13:37 首次发布

c语言sizeof char,sizeof

256版

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

#define PAGE_SIZE (2 * 1024 * 1024)  // 2MB 大页

/*
  功能: 根据输入的内存大小和热页比例进行内存的分配和冷热页模拟
  参数:
    mem_size: 传入内存大小，必须是 2 的倍数，单位 MB
    hot_page_ratio: 热页百分比，0 到 100 的整数
*/
int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <mem_size_MB> <hot_page_ratio>\n", argv[0]);
        return 1;
    }

    // 解析和校验输入参数
    size_t mem_size_MB = atoi(argv[1]);
    int hot_page_ratio = atoi(argv[2]);

    if (mem_size_MB <= 0 || mem_size_MB % 2 != 0) {
        fprintf(stderr, "Error: mem_size_MB must be a positive multiple of 2.\n");
        return 1;
    }

    if (hot_page_ratio < 0 || hot_page_ratio > 100) {
        fprintf(stderr, "Error: hot_page_ratio must be an integer between 0 and 100.\n");
        return 1;
    }

    // 将 mem_size_MB 转换为字节，并确保是大页大小的倍数
    size_t size = mem_size_MB * 1024 * 1024;  // 转换为字节
    size_t total_pages = size / PAGE_SIZE;  // 计算总页数
    size_t hot_pages = total_pages * hot_page_ratio / 100;  // 计算热页数
    size_t cold_pages = total_pages - hot_pages;  // 计算冷页数

    printf("Total pages: %zu, Hot pages: %zu, Cold pages: %zu\n", total_pages, hot_pages, cold_pages);

    // 分配大页内存
    char *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    printf("Memory allocated using huge pages.\n");

    size_t cold_page_access_round = 100;  // 每100轮热页循环后访问冷页一次
    size_t round = 1;

    // 初始化申请到的内存--赋值
    for (size_t i = 0; i < hot_pages; i++) {
        for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
             mem[i * PAGE_SIZE + (j * 2048)] = (i + j * 2048) % 256;  // 每隔2048字节，写一个，一个2M页，要写2^21/2^11 = 1024次
         }
    }
    for (size_t i = hot_pages; i < total_pages; i++) {
         mem[i * PAGE_SIZE] = i % 256;  //给2M大页标记序号
    }
    printf("The allocated memory has been initialized!\n");
    
    // 无限循环，模拟持续的冷热页访问
    while (1) {
        // 模拟热页访问
        for (size_t i = 0; i < hot_pages; i++) {
            for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
                // mem[i * PAGE_SIZE + (j * 2048)] = i % 256;
                if (mem[i * PAGE_SIZE + (j * 2048)] != (i + j * 2048) % 256) {
                    printf("Hot pages accessed error!\n");
                }
            }
        }
        printf("Hot pages accessed frequently and successfully.\n");

        // 模拟冷页访问
        if (round % cold_page_access_round == 0) {
            for (size_t i = hot_pages; i < total_pages; i++) {
                // mem[i * PAGE_SIZE] = i % 256;
                if (mem[i * PAGE_SIZE] != i % 256) {
                    printf("Cold pages accessed error!\n");
                }
            }
            printf("Cold pages accessed occasionally and successfully.\n");
            round = 0;
        }

        round++;
    }

    // 虽然程序无限循环，仍可以在退出前释放内存
    // munmap(mem, size);

    return 0;
}

int *版

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

#define PAGE_SIZE (2 * 1024 * 1024)  // 2MB 大页

/*
  功能: 根据输入的内存大小和热页比例进行内存的分配和冷热页模拟
  参数:
    mem_size: 传入内存大小，必须是 2 的倍数，单位 MB
    hot_page_ratio: 热页百分比，0 到 100 的整数
*/
int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <mem_size_MB> <hot_page_ratio>\n", argv[0]);
        return 1;
    }

    // 解析和校验输入参数
    size_t mem_size_MB = atoi(argv[1]);
    int hot_page_ratio = atoi(argv[2]);

    if (mem_size_MB <= 0 || mem_size_MB % 2 != 0) {
        fprintf(stderr, "Error: mem_size_MB must be a positive multiple of 2.\n");
        return 1;
    }

    if (hot_page_ratio < 0 || hot_page_ratio > 100) {
        fprintf(stderr, "Error: hot_page_ratio must be an integer between 0 and 100.\n");
        return 1;
    }

    // 将 mem_size_MB 转换为字节，并确保是大页大小的倍数
    size_t size = mem_size_MB * 1024 * 1024;  // 转换为字节
    size_t total_pages = size / PAGE_SIZE;  // 计算总页数
    size_t hot_pages = total_pages * hot_page_ratio / 100;  // 计算热页数
    size_t cold_pages = total_pages - hot_pages;  // 计算冷页数

    printf("Total pages: %zu, Hot pages: %zu, Cold pages: %zu\n", total_pages, hot_pages, cold_pages);

    // 分配大页内存
    int *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    printf("Memory allocated using huge pages.\n");

    size_t cold_page_access_round = 100;  // 每100轮热页循环后访问冷页一次
    size_t round = 1;

    // 初始化申请到的内存--赋值
    for (size_t i = 0; i < hot_pages; i++) {
        for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
             mem[i * PAGE_SIZE / sizeof(int) + (j * 2048 / sizeof(int))] = i + j * 2048;  // 4个字节为一个下标
         }
    }
    for (size_t i = hot_pages; i < total_pages; i++) {
         mem[i * PAGE_SIZE / sizeof(int)] = i;  //给2M大页标记序号
    }
    printf("The allocated memory has been initialized!\n");
    
    // 无限循环，模拟持续的冷热页访问
    while (1) {
        // 模拟热页访问
        for (size_t i = 0; i < hot_pages; i++) {
            for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
                // mem[i * PAGE_SIZE + (j * 2048)] = i % 256;
                if (mem[i * PAGE_SIZE / sizeof(int) + (j * 2048 / sizeof(int))] != i + j * 2048) {
                    printf("Hot pages accessed error!\n");
                }
            }
        }
        printf("Hot pages accessed frequently and successfully.\n");

        // 模拟冷页访问
        if (round % cold_page_access_round == 0) {
            for (size_t i = hot_pages; i < total_pages; i++) {
                // mem[i * PAGE_SIZE] = i % 256;
                if (mem[i * PAGE_SIZE / sizeof(int)] != i) {
                    printf("Cold pages accessed error!\n");
                }
            }
            printf("Cold pages accessed occasionally and successfully.\n");
            round = 0;
        }

        round++;
    }

    // 虽然程序无限循环，仍可以在退出前释放内存
    // munmap(mem, size);

    return 0;
}

int 改进

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

#define PAGE_SIZE (2 * 1024 * 1024)  // 2MB 大页

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <mem_size_MB> <hot_page_ratio>\n", argv[0]);
        return 1;
    }

    size_t mem_size_MB = atoi(argv[1]);
    int hot_page_ratio = atoi(argv[2]);

    if (mem_size_MB <= 0 || mem_size_MB % 2 != 0) {
        fprintf(stderr, "Error: mem_size_MB must be a positive multiple of 2.\n");
        return 1;
    }

    if (hot_page_ratio < 0 || hot_page_ratio > 100) {
        fprintf(stderr, "Error: hot_page_ratio must be an integer between 0 and 100.\n");
        return 1;
    }

    size_t size = mem_size_MB * 1024 * 1024;  
    size_t total_pages = size / PAGE_SIZE;  
    size_t hot_pages = total_pages * hot_page_ratio / 100;  
    size_t cold_pages = total_pages - hot_pages;  

    printf("Total pages: %zu, Hot pages: %zu, Cold pages: %zu\n", total_pages, hot_pages, cold_pages);

    int *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    printf("Memory allocated using huge pages.\n");

    size_t cold_page_access_round = 100;  
    size_t round = 1;

    // 预先计算除法
    size_t page_size_in_ints = PAGE_SIZE / sizeof(int);
    size_t offset_2048_in_ints = 2048 / sizeof(int);

    // 初始化申请到的内存
    for (size_t i = 0; i < hot_pages; i++) {
        for (size_t j = 0; j < page_size_in_ints; j++) {
            if (j * offset_2048_in_ints < page_size_in_ints) {
                mem[i * page_size_in_ints + j * offset_2048_in_ints] = i + j * 2048;
            }
        }
    }
    for (size_t i = hot_pages; i < total_pages; i++) {
        mem[i * page_size_in_ints] = i;  
    }
    printf("The allocated memory has been initialized!\n");
    
    // 无限循环，模拟冷热页访问
    while (1) {
        for (size_t i = 0; i < hot_pages; i++) {
            for (size_t j = 0; j < page_size_in_ints; j++) {
                if (mem[i * page_size_in_ints + j * offset_2048_in_ints] != i + j * 2048) {
                    printf("Hot pages accessed error at page %zu, index %zu!\n", i, j);
                }
            }
        }
        printf("Hot pages accessed frequently and successfully.\n");

        if (round % cold_page_access_round == 0) {
            for (size_t i = hot_pages; i < total_pages; i++) {
                if (mem[i * page_size_in_ints] != i) {
                    printf("Cold pages accessed error at page %zu!\n", i);
                }
            }
            printf("Cold pages accessed occasionally and successfully.\n");
            round = 0;
        }

        round++;
    }

    munmap(mem, size);
    return 0;
}

添加信号处理函数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>
#include <signal.h>

#define PAGE_SIZE (2 * 1024 * 1024)  // 2MB 大页

// 信号处理函数
void handle_sigint(int sig) {
    printf("\nCaught signal %d, cleaning up and exiting...\n", sig);
    if (mem != MAP_FAILED && mem != NULL) {
        munmap(mem, size);  // 释放 mmap 分配的内存
        printf("Memory successfully unmapped.\n");
    }
    exit(0);  // 退出程序
}

/*
  功能: 根据输入的内存大小和热页比例进行内存的分配和冷热页模拟
  参数:
    mem_size: 传入内存大小，必须是 2 的倍数，单位 MB
    hot_page_ratio: 热页百分比，0 到 100 的整数
*/
int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <mem_size_MB> <hot_page_ratio>\n", argv[0]);
        return 1;
    }

    // 解析和校验输入参数
    size_t mem_size_MB = atoi(argv[1]);
    int hot_page_ratio = atoi(argv[2]);

    if (mem_size_MB <= 0 || mem_size_MB % 2 != 0) {
        fprintf(stderr, "Error: mem_size_MB must be a positive multiple of 2.\n");
        return 1;
    }

    if (hot_page_ratio < 0 || hot_page_ratio > 100) {
        fprintf(stderr, "Error: hot_page_ratio must be an integer between 0 and 100.\n");
        return 1;
    }

    // 将 mem_size_MB 转换为字节，并确保是大页大小的倍数
    size_t size = mem_size_MB * 1024 * 1024;  // 转换为字节
    size_t total_pages = size / PAGE_SIZE;  // 计算总页数
    size_t hot_pages = total_pages * hot_page_ratio / 100;  // 计算热页数
    size_t cold_pages = total_pages - hot_pages;  // 计算冷页数

    printf("Total pages: %zu, Hot pages: %zu, Cold pages: %zu\n", total_pages, hot_pages, cold_pages);

    signal(SIGINT, handle_sigint); // 捕捉 Ctrl+C
    signal(SIGTERM, handle_sigint); // 捕捉 kill

    // 分配大页内存
    char *mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    printf("Memory allocated using huge pages.\n");

    size_t cold_page_access_round = 100;  // 每100轮热页循环后访问冷页一次
    size_t round = 1;

    // 无限循环，模拟持续的冷热页访问
    while (1) {
        // 模拟热页访问
        for (size_t i = 0; i < hot_pages; i++) {
            for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
                mem[i * PAGE_SIZE + (j * 2048)] = i % 256;
            }
        }
        printf("Hot pages accessed frequently.\n");

        // 模拟冷页访问
        if (round % cold_page_access_round == 0) {
            for (size_t i = hot_pages; i < total_pages; i++) {
                mem[i * PAGE_SIZE] = i % 256;
            }
            printf("Cold pages accessed occasionally.\n");
            round = 0;
        }

        round++;
    }
    
    return 0;
}

内存地址及大小作为全局变量

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>
#include <signal.h>

#define PAGE_SIZE (2 * 1024 * 1024)  // 2MB 大页

char *mem;
size_t size;
/*
  功能: 根据输入的内存大小和热页比例进行内存的分配和冷热页模拟
  参数:
    mem_size: 传入内存大小，必须是 2 的倍数，单位 MB
    hot_page_ratio: 热页百分比，0 到 100 的整数
*/

// 信号处理函数
void handle_sigint(int sig) {
    printf("\nCaught signal %d, cleaning up and exiting...\n", sig);
    if (mem != MAP_FAILED && mem != NULL) {
        munmap(mem, size);  // 释放 mmap 分配的内存
        printf("Memory successfully unmapped.\n");
    }
    exit(0);  // 退出程序
}

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <mem_size_MB> <hot_page_ratio>\n", argv[0]);
        return 1;
    }

    // 解析和校验输入参数
    size_t mem_size_MB = atoi(argv[1]);
    int hot_page_ratio = atoi(argv[2]);

    if (mem_size_MB <= 0 || mem_size_MB % 2 != 0) {
        fprintf(stderr, "Error: mem_size_MB must be a positive multiple of 2.\n");
        return 1;
    }

    if (hot_page_ratio < 0 || hot_page_ratio > 100) {
        fprintf(stderr, "Error: hot_page_ratio must be an integer between 0 and 100.\n");
        return 1;
    }

    // 将 mem_size_MB 转换为字节，并确保是大页大小的倍数
    size = mem_size_MB * 1024 * 1024;  // 转换为字节
    size_t total_pages = size / PAGE_SIZE;  // 计算总页数
    size_t hot_pages = total_pages * hot_page_ratio / 100;  // 计算热页数
    size_t cold_pages = total_pages - hot_pages;  // 计算冷页数

    printf("Total pages: %zu, Hot pages: %zu, Cold pages: %zu\n", total_pages, hot_pages, cold_pages);

    signal(SIGINT, handle_sigint); // 捕捉 Ctrl+C
    signal(SIGTERM, handle_sigint); // 捕捉 kill

    // 分配大页内存
    mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
    if (mem == MAP_FAILED) {
        perror("mmap failed");
        return 1;
    }

    printf("Memory allocated using huge pages.\n");

    size_t cold_page_access_round = 100;  // 每100轮热页循环后访问冷页一次
    size_t round = 1;

    // 无限循环，模拟持续的冷热页访问
    while (1) {
        // 模拟热页访问
        for (size_t i = 0; i < hot_pages; i++) {
            for (size_t j = 0; j < 1024; j++) {  // 多次访问每个大页
                mem[i * PAGE_SIZE + (j * 2048)] = i % 256;
            }
        }
        printf("Hot pages accessed frequently.\n");

        // 模拟冷页访问
        if (round % cold_page_access_round == 0) {
            for (size_t i = hot_pages; i < total_pages; i++) {
                mem[i * PAGE_SIZE] = i % 256;
            }
            printf("Cold pages accessed occasionally.\n");
            round = 0;
        }

        round++;
    }
    
    return 0;
}

这段代码使用mmap函数进行内存映射操作，主要功能是分配一块特定大小的内存区域。以下是对各个参数的解释：

  1. NULL：表示让内核选择合适的地址来映射内存。通常情况下，内核会选择一个合适的地址，这样可以提高可移植性。
  2. size：这是要分配的内存大小。在你的代码中，size是根据用户输入的内存大小（以字节为单位）计算得到的。
  3. PROT_READ | PROT_WRITE：指定了对映射内存的访问权限。这里表示映射的内存区域可读可写。
    • PROT_READ表示允许读取内存区域。
    • PROT_WRITE表示允许写入内存区域。
  4. MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB：这是一组标志，用于控制内存映射的行为。
    • MAP_PRIVATE表示创建一个私有的、写时复制的内存映射。对这个映射区域的修改不会影响到原始文件（因为这里没有映射文件，是匿名映射），也不会被其他进程看到。
    • MAP_ANONYMOUS表示创建一个匿名映射，即不与任何文件关联。通常用于分配内存而不是映射文件。
    • MAP_HUGETLB表示使用大页内存（HugeTLB）进行映射。大页内存可以提高内存访问性能，但不是所有系统都支持，并且可能需要特定的配置。
  5. -1：在这个上下文中，这是文件描述符参数。因为是匿名映射，所以使用-1表示不与任何文件关联。
  6. 0：这是文件偏移量参数。对于匿名映射，通常设置为0。

综上所述，这段代码的作用是分配一块特定大小的、可读可写的、私有的匿名大页内存区域，并将该内存区域的起始地址赋值给指针mem。如果分配成功，mem将指向这块新分配的内存区域；如果分配失败，mem将被设置为MAP_FAILED。

信号处理函数

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

// 信号处理函数
void handle_signal(int signal) {
    if (signal == SIGINT) {
        printf("Caught SIGINT (Ctrl+C)\n");
    } else if (signal == SIGTERM) {
        printf("Caught SIGTERM (kill)\n");
        exit(0);  // 退出程序
    } else if (signal == SIGHUP) {
        printf("Caught SIGHUP (Terminal closed or session ended)\n");
    } else {
        printf("Caught signal %d\n", signal);
    }
}

int main() {
    // 捕获 SIGINT, SIGTERM, SIGHUP 信号
    signal(SIGINT, handle_signal);   // Ctrl+C 产生 SIGINT
    signal(SIGTERM, handle_signal);  // kill 命令默认发送 SIGTERM
    signal(SIGHUP, handle_signal);   // SIGHUP 通常在终端关闭时触发

    printf("Program started. PID: %d\n", getpid());

    // 无限循环，等待信号
    while (1) {
        printf("Running... (Press Ctrl+C to stop or use kill)\n");
        sleep(2);  // 睡眠2秒，模拟程序运行
    }

    return 0;
}

在这段 C 语言代码中，signal(SIGINT, handle_signal);是用来设置信号处理函数的。

以下是对这一用法的详细解释：

  1. signal函数的作用：

    • signal是 C 语言标准库中的一个函数，用于设置特定信号的处理方式。它接受两个参数，一个是要处理的信号编号，另一个是信号处理函数的指针。
    • 在你的代码中，signal(SIGINT, handle_signal);表示当程序接收到SIGINT信号（通常由用户在终端按下Ctrl + C产生）时，调用handle_signal函数来处理这个信号。

  2. 参数说明：

    • SIGINT：这是一个预定义的信号常量，表示中断信号。当用户在终端按下Ctrl + C时，操作系统会向正在运行的程序发送这个信号，以请求程序终止。
    • handle_signal：这是一个用户定义的函数指针，指向信号处理函数。信号处理函数的原型通常是void func(int sig);，其中sig是接收到的信号编号。在你的代码中，handle_signal函数根据接收到的不同信号打印不同的消息。

  3. 信号处理流程：

    • 当程序运行时，系统会将SIGINT信号与handle_signal函数关联起来。
    • 如果在程序运行过程中，用户按下Ctrl + C，操作系统会向程序发送SIGINT信号。
    • 程序接收到SIGINT信号后，会中断当前正在执行的代码流程，并跳转到handle_signal函数执行。在handle_signal函数中，根据接收到的信号编号进行相应的处理，在这个例子中是打印一条消息说明捕获到了SIGINT信号。
    • 信号处理函数执行完毕后，程序可以根据需要决定是否继续执行或者终止。

总的来说，signal(SIGINT, handle_signal);的作用是让程序能够捕获和处理特定的信号，从而实现对用户操作（如中断程序）或系统事件（如终端关闭）的响应。

#include <stdlib.h>  // 需要使用rand()函数

// 在冷页访问部分，添加一个概率判断
for (size_t i = HOT_PAGES; i < TOTAL_PAGES; i++) {
    if (rand() % 10 == 0) {  // 10%的概率访问冷页
        mem[i * PAGE_SIZE] = i % 256;
    }
}

int * char *

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

int main() {
    // 使用 malloc 分配内存
    size_t char_array_size = 5;  // char 数组大小
    size_t int_array_size = 5;   // int 数组大小

    // 分配 char 数组
    char *char_array = (char *)malloc(char_array_size * sizeof(char));
    if (char_array == NULL) {
        perror("Failed to allocate memory for char_array");
        return 1;
    }

    // 分配 int 数组
    int *int_array = (int *)malloc(int_array_size * sizeof(int));
    if (int_array == NULL) {
        perror("Failed to allocate memory for int_array");
        free(char_array); // 释放已分配的内存
        return 1;
    }

    // 初始化和打印 char 数组
    for (size_t i = 0; i < char_array_size; i++) {
        char_array[i] = 'A' + i; // 存储字符 A, B, C, D, E
    }

    printf("Char array: ");
    for (size_t i = 0; i < char_array_size; i++) {
        printf("%c ", char_array[i]);
    }
    printf("\n");

    // 初始化和打印 int 数组
    for (size_t i = 0; i < int_array_size; i++) {
        int_array[i] = (i + 1) * 10; // 存储 10, 20, 30, 40, 50
    }

    printf("Int array: ");
    for (size_t i = 0; i < int_array_size; i++) {
        printf("%d ", int_array[i]);
    }
    printf("\n");

    // 释放内存
    free(char_array);
    free(int_array);

    return 0;
}

mmap

#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>

#define SIZE 5 * 1024 * 1024  // 分配 5MB 的内存

int main() {
    // 使用 mmap 分配内存
    char *char_mem = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (char_mem == MAP_FAILED) {
        perror("Failed to allocate memory for char_mem");
        return 1;
    }

    int *int_mem = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (int_mem == MAP_FAILED) {
        perror("Failed to allocate memory for int_mem");
        munmap(char_mem, SIZE); // 释放 char_mem
        return 1;
    }

    // 初始化 char 数组
    for (size_t i = 0; i < 10; i++) {
        // char_mem[i] = 'A' + i; // 存储字符 A, B, C, D, E, F, G, H, I, J
        char_mem[i] = i;
    }

    printf("Char array: ");
    for (size_t i = 0; i < 10; i++) {
        printf("%c ", char_mem[i]);
    }
    printf("\n");

    // 初始化 int 数组
    for (size_t i = 0; i < 10; i++) {
        int_mem[i] = (i + 1) * 10; // 存储 10, 20, 30, 40, 50, 60, 70, 80, 90, 100
    }

    printf("Int array: ");
    for (size_t i = 0; i < 10; i++) {
        printf("%d ", int_mem[i]);
    }
    printf("\n");

    // 释放内存
    munmap(char_mem, SIZE);
    munmap(int_mem, SIZE);

    return 0;
}
Mr_Tang4
关注
Qt-无标题窗口
学而思
05-21 9082
        今天学习了下无标题窗口，于是来记录下我的学习过程首先建立一个Qt Widgets Application继承QWidget类创建完后直接运行就得到了如下效果那么，既然是无标题窗口就要去掉窗口栏啊，于是加上setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);去掉标题栏，但是这样整个窗口就不能移动...
Java的System.out.println()深入解析理解
热门推荐
代码与诗
02-10 3万+
在Java程序(特别是控制台)中常用System.out.println()语句来输出信息，从开始学习Java就知道用它来输出Hello World，没有深究其实现原理，现在查阅文档、源代码后记录一下。 首先查阅文档和源码可知System是java.lang包里的一个final类，而每个Java程序是默认import java.lang.*的，因此即使程序中没有手动导入，也可访问到System类。 main()方法是static修饰的，根据Java语法，它只能调用static方法和变量，那么查看System
【Java】System.out.println
Ankie_的博客
04-08 1万+
System.out.println() System.out.println是一个Java语句，一般情况下是将传递的参数，打印到控制台 System是Java.lang包中的一个final类，该类提供的设施包括标准输入、标准输出和错误输出流、访问外部定义的属性和环境变量，一种加载文件和库的方法，以及用于加速复制数组等一部分的使用方法。 out是System类的静态成员字段，类型为PrintSt...
Java笔记——System.out.println()详解
爱吃糖葫芦的博客
06-01 1万+
语句：System.out.println();System是一个类，继承自根类Objectout是类PrintStream类实例化的一个对象，且是System类的静态成员变量println()是类PrintStream的成员方法，被对象out调用...
面试题
hnzgemail的博客
10-05 4589
来源于： http://blog.sina.com.cn/s/blog_8a767bef0100z844.html 这是一篇东软的笔试题，希望对打算面东软的各位仁人志士有所帮助。 1、下列变量定义错误的是　Ｄ int a; double b=4.5; boolean b=true; float f=9.8; (9.8f) 2、6+5%3+2的值是 D 3%5=3...
java章节性质习题及答案
zhangMY12138的博客
09-12 4739
第一章Java简介 4 1.1 Java发展历史 4 1.2 Java虚拟机 4 1.3 Java特点 5 1.4 Java搭建开发环境 6 1.5 编写第一个java程序 6 1.6 章节复习与训练 6 第二章变量、数据类型 7 2.1数据类型 7 2.2变量及赋值 7 2.3 标识符 8 2.4 关键字和保留字 9 2.5 类型转换 9 ...
Delphi无标题窗体增强功能实现：让无标题窗体更具交互性
gitblog_06708的博客
04-12 868
Delphi无标题窗体增强功能实现：让无标题窗体更具交互性 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在软件开发领域，Delphi 语言因其高效的执行速度和清晰的语法结构，一直受到开发者的喜爱。然而，在使用无标题窗体（borderstyle=bsnone）时，开发者常常面临一个问题：用户无法通过常规方式来移动或调整窗体大小。本项目正是为了解决这一难题而诞生，它提供...
无标题栏窗口拖动的实现
ArduousBonze的专栏
05-15 3906
普通的Windows应用程序窗口都具有统一的窗口风格，它们一般都包括：用户区和非用户区两部分。非用户区包括标题条、窗口边框、最大化按钮、最小化按钮、关闭按钮和系统默认的快捷键及鼠标支持等。利用鼠标的左键通过拖动窗口的标题条可以在屏幕上任意移动整个窗口，当光标停止在窗口边框上时可以改变窗口的大小。在一些比较经典的软件中，有一类特殊的无标题条的窗口。这种窗口不需要改变窗口的大小，但必须具有窗口客户区域
无标题窗口的拖动
lianxiao1314的专栏
10-06 861
普通的Windows应用程序窗口都具有统一的窗口风格，它们一般都包括：用户区和非用户区两部分。非用户区包括标题条、窗口边框、最大化按钮、最小化按钮、关闭按钮和系统默认的快捷键及鼠标支持等。利用鼠标的左键通过拖动窗口的标题条可以在屏幕上任意移动整个窗口，当光标停止在窗口边框上时可以改变窗口的大小。在一些比较经典的软件中，有一类特殊的无标题条的窗口。这种窗口不需要改变窗口的大小，但必须具有窗口客户区域
C#拖动无标题栏窗体
Windows Mobile 开发历险
12-25 1868
很长时间没有写博客了，今天又解决并测试通过了一个Delphi很简单的问题——无标题栏窗体的拖动 。其实是个很简单的问题，但是还是想写下来，一方面加深自己的记忆，一方面与朋友们分享！DeviceAnywhere在Ioicn发布了，反响似乎一般，我想是因为.net FrameWork环境的问题吧，希望Microsoft再出sp的时候把.net FrameWorkx.x集成到操作系统里吧，这样大家都方便
算法与数据结构之Floyd算法
weixin_73953650的博客
06-20 538
超详细的Floyd算法教程，一看就懂！
医用超声图像模拟系统算法：线密度详解
alxraves的博客
06-23 597
在超声成像中，线密度（Line Density）是指单位扫描角度或单位扫描宽度内超声扫描线的数量。简单来说，它描述了超声探头在扫描区域内发射和接收声波线的密集程度。核心概念扫描线：超声探头发射的每一条声波束，对应图像中的一条垂直线（A-mode）或图像重建的一个数据采集通道（B-mode）。线间距：相邻两条扫描线中心之间的距离，是线密度的倒数。单位：通常表示为线/度（对于扇形扫描）或线/厘米（对于线性扫描）。更高的线密度意味着更密集的采样，理论上能获得更丰富的图像细节和更好的横向分辨率。
CodeQUEEN 2026 -qual- (AtCoder Beginner Contest 462)题解
Timmylyx0518的博客
06-20 273
第六次 AK，记录一下。
算法日记 | 二分查找
在读大学生
06-23 192
本文介绍了二分查找算法的核心思想与实战应用，通过三道经典题目由浅入深地讲解： 基础入门：通过洛谷P1833模拟二分查找过程，展示如何通过中间值比较收缩区间，时间复杂度O(log n)。关键是用变量维护查找区间，注意大数溢出问题。 STL实战：在P1678高考志愿题中，利用lower_bound快速定位最接近分数线的学校，强调预处理排序和边界处理（如估分超出所有学校范围的情况）。
数据结构基础复习——排序算法的关键代码片段
2301_80025611的博客
06-22 360
针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空或。
linux内核内存二次机会算法&refualt算法
Network, Linux Kernel
06-23 240
linux 内核传统LRU的二次机会算法实现细节
【leetcode】983.最低票价js
最新发布
2402_83244812的博客
06-23 999
本文介绍了两种动态规划方法解决旅行购票问题。第一种方法基于自然日定义dp数组，dp[i]表示从第i天到最后一天覆盖所有旅行日的最小花费，分当天是否旅行两种情况处理。第二种方法基于旅行日索引定义dp数组，dp[i]表示处理前i个旅行日的最小花费，通过三种购票方式（1天/7天/30天票）寻找最优解。两种方法都通过状态转移方程和边界条件实现，代码示例展示了具体实现逻辑。
【STL】算法
呆瓜的博客
06-22 313
本文介绍了C++标准库算法的术语规范与基本要求。主要内容包括：1) 标准区间表示法如[A,B)及其遍历规则；2) 等值判断二元谓词的三项强制要求；3) 排序/堆算法中严格弱序的定义及合法谓词示例；4) 升序序列和大顶堆的具体判定标准；5) 算法头文件<algorithm>和<numeric>的功能划分。特别强调所有比较函数必须满足不修改参数、结果一致性和严格弱序等核心规范。
现代CAD几何内核中的求交算法——从曲线求交到曲面求交的原理与实现
m0_53082780的博客
06-21 229
无论是模型布尔运算、特征建模、曲面修剪、装配分析，还是数控加工中的刀具路径规划，其底层都离不开各种形式的几何求交。然而在工业级CAD内核中，由于大量采用NURBS曲线与曲面表示复杂几何对象，传统解析求解方法已经难以适用，取而代之的是基于参数空间、数值迭代以及拓扑重建的一整套工程化算法体系。本文从CAD几何内核的角度出发，系统介绍曲线求交、曲线曲面求交以及曲面曲面求交的数学本质和工程实现流程，并结合OpenCASCADE等主流CAD内核的实现思想，帮助读者建立完整的几何求交知识框架。
[LC优选算法#7] 分治:快排&归并 | 库存管理 III | 排序数组 | 交易逆序对的总数
C++开发
06-22 232
本文介绍了两种经典的分治排序算法——快速排序和归并排序，并结合LeetCode题目展示了它们的应用。 快速排序部分： 通过库存管理III问题，展示了快速选择算法解决TopK问题的思路，时间复杂度O(N)。 使用随机选key和数组三块分区的方法实现快速排序变种。 归并排序部分： 以排序数组题目为例，展示了标准归并排序的实现，时间复杂度O(NlogN)。 重点分析了交易逆序对问题，提出利用归并排序过程中计算逆序对数量： 通过升序/降序版本归并排序统计逆序对巧妙利用已排序子数组的性质优化计算。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值