cmd /c "gcc main.c -o main.exe && main.exe"

gcc main.c -o main && ./main

cmd /c "g++ main.cpp -o main.exe && main.exe"

#ifndef HELPER_H
#define HELPER_H
 
#ifdef __cplusplus
extern "C" {  // 避免 C++ 名字修饰
#endif
 
int c_add(int a, int b);
int c_subtract(int a, int b);
 
#ifdef __cplusplus
}
#endif
 
#endif // HELPER_H

#include "helper.h"
#include <iostream>
 
// C 函数实现（被 C++ 调用）
int c_add(int a, int b) {
    return a + b;
}
 
int c_subtract(int a, int b) {
    return a - b;
}
 
// C++ 函数（准备被 C 调用）
extern "C" int cpp_multiply(int a, int b) {
    return a * b;
}
 
extern "C" void cpp_hello() {
    std::cout << "Hello from C++!" << std::endl;
}

#ifndef CPPFUNC_H
#define CPPFUNC_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
int cpp_multiply(int a, int b);
void cpp_hello();
 
#ifdef __cplusplus
}
#endif
 
#endif // CPPFUNC_H
 

#include <stdio.h>
#include "cppfunc.h"
#include "helper.h"
 
int main() {
    int a = 10, b = 5;
 
    // C 调用 C++ 函数
    int prod = cpp_multiply(a, b);
    printf("C calling C++ multiply: %d\n", prod);
 
    cpp_hello(); // 调用 C++ 输出
 
    // C++ 调用 C 函数
    int sum = c_add(a, b);
    int diff = c_subtract(a, b);
    printf("C++ calling C add: %d\n", sum);
    printf("C++ calling C subtract: %d\n", diff);
 
    return 0;
}

g++ -c helper.cpp       # 编译 C++ 文件
gcc -c main.c           # 编译 C 文件
g++ main.o helper.o -o interop_example   # 链接生成可执行文件
./interop_example

C calling C++ multiply: 50
Hello from C++!
C++ calling C add: 15
C++ calling C subtract: 5

#include <iostream>
#include "foo.h"
 
int main() {
    print_message("Hello from foo.cpp!");
    int result = add(3, 5);
    std::cout << "3 + 5 = " << result << std::endl;
    return 0;
}

#include "foo.h"
#include <iostream>
 
void print_message(const std::string& msg) {
    std::cout << "[Message] " << msg << std::endl;
}
 
int add(int a, int b) {
    return a + b;
}

#pragma once
#include <string>
 
void print_message(const std::string& msg);
int add(int a, int b);

# 1. 指定 CMake 最低版本
cmake_minimum_required(VERSION 3.10)
 
# 2. 定义项目名称和语言
project(MyProject VERSION 1.0 LANGUAGES CXX)
 
# 3. 指定 C++ 标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED True)
 
# 4. 查找 src 目录下所有 cpp 文件
file(GLOB SOURCES "src/*.cpp")
 
# 5. 添加可执行文件
add_executable(${PROJECT_NAME} ${SOURCES})
 
# 6. 添加 include 目录
target_include_directories(${PROJECT_NAME} PRIVATE include)
 
# 7. 设置编译选项
if(MSVC)
    # 所有配置都开启警告等级 4
    target_compile_options(${PROJECT_NAME} PRIVATE /W4)
 
    # 仅 Release 配置开启优化
    target_compile_options(${PROJECT_NAME} PRIVATE
        $<$<CONFIG:Release>:/O2>
    )
 
    # 仅 Debug 配置开启运行时检查
    target_compile_options(${PROJECT_NAME} PRIVATE
        $<$<CONFIG:Debug>:/RTC1>
    )
 
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    # GCC / Clang
    target_compile_options(${PROJECT_NAME} PRIVATE -Wall -Wextra)
    target_compile_options(${PROJECT_NAME} PRIVATE
        $<$<CONFIG:Release>:-O2>
    )
endif()
 

mkdir build
cd build
cmake -G "Visual Studio 17 2022" ..

cd Release
MyProject.exe

# ------------------------------
# Makefile for Windows + MinGW
# ------------------------------
 
# 编译器
CC = gcc
CXX = g++
 
# 编译选项
CFLAGS = -Wall -Iinclude
CXXFLAGS = -Wall -Iinclude
 
# 源文件目录
SRCDIR = src
 
# 所有源文件
C_SOURCES = $(wildcard $(SRCDIR)/*.c)
CPP_SOURCES = $(wildcard $(SRCDIR)/*.cpp)
 
# 对应的目标文件
C_OBJS = $(C_SOURCES:.c=.o)
CPP_OBJS = $(CPP_SOURCES:.cpp=.o)
 
# 最终可执行文件
TARGET = main.exe
 
# ------------------------------
# 默认目标
# ------------------------------
all: $(TARGET)
 
# ------------------------------
# 链接 C/C++ 对象文件
# ------------------------------
$(TARGET): $(C_OBJS) $(CPP_OBJS)
ifeq ($(CPP_OBJS),)
	$(CC) -o $@ $(C_OBJS)
else
	$(CXX) -o $@ $(C_OBJS) $(CPP_OBJS)
endif
 
# ------------------------------
# 编译 C 源文件
# ------------------------------
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@
 
# ------------------------------
# 编译 C++ 源文件
# ------------------------------
%.o: %.cpp
	$(CXX) $(CXXFLAGS) -c $< -o $@
 
# ------------------------------
# 清理
# ------------------------------
.PHONY: clean
clean:
	del /Q $(SRCDIR)\*.o $(TARGET)

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/include",
                "C:/MinGW/include",
                "C:/MinGW/lib/gcc/mingw32/6.3.0/include",
            ],
            "defines": [
                "UNICODE",
                "_DEBUG"
            ],
            "compilerPath": "C:/MinGW/bin/gcc.exe",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "gcc-x64"
        }
    ],
    "version": 4
}

import xml.etree.ElementTree as ET
import json
import os
 
# 配置部分
uvprojx_file = "${workspaceFolder}/Project/XXX.uvprojx"
workspace_folder = "${workspaceFolder}"  # VSCode 工作区变量
output_vscode_file = ".vscode/c_cpp_properties.json"
 
compiler_path = "arm-none-eabi-gcc"  # "C:/Keil_v5/ARM/ARMCC/bin/armcc.exe"
c_standard = "c11"
cpp_standard = "c++17"
 
# 解析 UVPROJX 文件
ws_abs_path = os.getcwd()
uvprojx_file_abs = uvprojx_file.replace("${workspaceFolder}", ws_abs_path)
 
tree = ET.parse(uvprojx_file_abs)
root = tree.getroot()
 
uvprojx_dir = os.path.dirname(uvprojx_file_abs)
include_paths = set()
defines = set()
 
for target in root.findall(".//Target"):
    # IncludePath
    for path in target.findall(".//IncludePath"):
        if path.text:
            for p in path.text.split(";"):
                if p.strip():
                    abs_path = os.path.normpath(os.path.join(uvprojx_dir, p.strip()))
                    rel_path = os.path.relpath(abs_path, start=ws_abs_path)
                    include_paths.add(os.path.join(workspace_folder, rel_path).replace("\\", "/"))
 
    # Define
    for define in target.findall(".//Define"):
        if define.text:
            for d in define.text.split(";"):
                if d.strip():
                    defines.add(d.strip())
 
# 拆分宏中逗号分隔的项
final_defines = []
for d in defines:
    for item in d.split(","):
        item = item.strip()
        if item:
            item = item.replace("\\\"", "\"")
            final_defines.append(item)
 
# 生成 VSCode 配置
vscode_config = {
    "configurations": [
        {
            "name": "Keil",
            "includePath": sorted(list(include_paths)),
            "defines": sorted(final_defines),
            "compilerPath": compiler_path,
            "cStandard": c_standard,
            "cppStandard": cpp_standard
        }
    ],
    "version": 4
}
 
os.makedirs(os.path.dirname(output_vscode_file), exist_ok=True)
with open(output_vscode_file, "w", encoding="utf-8") as f:
    json.dump(vscode_config, f, indent=4)
 
print(f"已生成 VSCode 配置: {output_vscode_file}")

#include <stdio.h>
#include <limits.h>
#include <float.h>
 
int main() {
    // Integer types
    printf("char: %zu bytes, range: %d to %d\n", sizeof(char), CHAR_MIN, CHAR_MAX);
    printf("unsigned char: %zu bytes, range: 0 to %u\n", sizeof(unsigned char), UCHAR_MAX);
 
    printf("short: %zu bytes, range: %d to %d\n", sizeof(short), SHRT_MIN, SHRT_MAX);
    printf("unsigned short: %zu bytes, range: 0 to %u\n", sizeof(unsigned short), USHRT_MAX);
 
    printf("int: %zu bytes, range: %d to %d\n", sizeof(int), INT_MIN, INT_MAX);
    printf("unsigned int: %zu bytes, range: 0 to %u\n", sizeof(unsigned int), UINT_MAX);
 
    printf("long: %zu bytes, range: %ld to %ld\n", sizeof(long), LONG_MIN, LONG_MAX);
    printf("unsigned long: %zu bytes, range: 0 to %lu\n", sizeof(unsigned long), ULONG_MAX);
 
    printf("long long: %zu bytes, range: %lld to %lld\n", sizeof(long long), LLONG_MIN, LLONG_MAX);
    printf("unsigned long long: %zu bytes, range: 0 to %llu\n", sizeof(unsigned long long), ULLONG_MAX);
 
    // Floating point types
    printf("float: %zu bytes, range: %e to %e\n", sizeof(float), FLT_MIN, FLT_MAX);
    printf("double: %zu bytes, range: %e to %e\n", sizeof(double), DBL_MIN, DBL_MAX);
    printf("long double: %zu bytes, range: %Le to %Le\n", sizeof(long double), LDBL_MIN, LDBL_MAX);
 
    // Boolean type
    printf("bool/_Bool: %zu bytes\n", sizeof(_Bool));
 
    // Pointer size
    printf("int*: %zu bytes\n", sizeof(int*));
 
    return 0;
}

int a;   // 这是定义——分配内存
int b = 10;  // 定义 + 初始化

extern int a;   // 声明，不分配内存，告诉编译器 a 在别处定义

extern int x;
extern int y;
int addtwonum() {
    return x + y;
}

#include <stdio.h>
 
int x = 1;
int y = 2;
int addtwonum();
int main(void)
{
    int result;
    result = addtwonum();
    printf("result is: %d\n", result);
    return 0;
}

gcc addtwonum.c test.c -o main
./main

#include <stdio.h>
#include <stdlib.h>
 
int g_init = 10; // data 段
int g_uninit;    // bss 段
 
static int s_init = 20; // data 段
static int s_uninit;    // bss 段
 
const int g_const = 30; // rodata 或 data
 
void test_function()
{
    int local = 1;                   // 栈
    static int local_static = 2;     // data/bss
    int *heap = malloc(sizeof(int)); // 堆
    *heap = 3;
 
    const char *str = "hello"; // 字符串常量 → rodata
 
    printf("【函数内变量】\n");
    printf(" local (stack)            = %p\n", (void *)&local);
    printf(" local_static (data/bss)  = %p\n", (void *)&local_static);
    printf(" heap (heap)              = %p\n", (void *)heap);
    printf(" str literal (rodata)     = %p\n", (void *)str);
 
    free(heap);
}
 
int main()
{
    printf("【全局变量】\n");
    printf(" g_init (data)            = %p\n", (void *)&g_init);
    printf(" g_uninit (bss)           = %p\n", (void *)&g_uninit);
    printf(" s_init (data)            = %p\n", (void *)&s_init);
    printf(" s_uninit (bss)           = %p\n", (void *)&s_uninit);
    printf(" g_const (rodata/data)    = %p\n", (void *)&g_const);
 
    printf("\n");
    test_function();
 
    return 0;
}

【全局变量】
 g_init (data)            = 00404004
 g_uninit (bss)           = 00407074
 s_init (data)            = 00404008
 s_uninit (bss)           = 00407020
 g_const (rodata/data)    = 00405064
 
【函数内变量】
 local (stack)            = 0061FEF4
 local_static (data/bss)  = 0040400C
 heap (heap)              = 00B91468
 str literal (rodata)     = 00405068

#include <stdio.h>
 
#define LENGTH(array) (sizeof(array) / sizeof(array[0]))
 
int main() {
    int array2[] = {1, 2, 3, 4, 5};
    int length = LENGTH(array2);
 
    printf("Array length: %d\n", length);
 
    return 0;
}

#include <stdio.h>
 
int main() {
    int a = 10;       // normal integer variable
    int *p = &a;      // define pointer p pointing to a's address
 
    printf("Value of variable a: %d\n", a);          
    printf("Address of variable a: %p\n", (void*)&a); 
    printf("Address stored in pointer p: %p\n", (void*)p); 
    printf("Value accessed through pointer p: %d\n", *p);    
 
    // modify the value through pointer
    *p = 20;
    printf("Value of a after modification: %d\n", a); 
 
    // address of the pointer itself
    printf("Address of pointer p: %p\n", (void*)&p);
 
    return 0;
}

#include <stdio.h>
 
int main() {
    int a = 1, b = 2, c = 3;
    int *arr[3] = {&a, &b, &c}; // array of pointers
 
    for (int i = 0; i < 3; i++) {
        printf("arr[%d] points to value = %d\n", i, *arr[i]);
    }
 
    return 0;
}

#include <stdio.h>
 
int main() {
    int a = 10;
    int *p = &a;
    int **pp = &p; // pointer to a pointer
 
    printf("a = %d\n", a);
    printf("*p = %d\n", *p);
    printf("**pp = %d\n", **pp);
 
    **pp = 20; // modify a through double pointer
    printf("a after modification = %d\n", a);
 
    return 0;
}

#include <stdio.h>
 
int add(int a,int b){ return a+b; }
int sub(int a,int b){ return a-b; }
 
int main() {
    int (*func)(int,int); // 函数指针
 
    func = add;
    printf("add: %d\n", func(5,3));
    printf("add address: %p\n", (void*)func);  // 打印函数地址
 
    func = sub;
    printf("sub: %d\n", func(5,3));
    printf("sub address: %p\n", (void*)func);  // 打印函数地址
 
    return 0;
}

#include <stdlib.h>  
#include <stdio.h>
 
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
}
 
// 获取随机值
int getNextRandomValue(void)
{
    return rand();
}
 
int main(void)
{
    int myarray[10];
    /* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    int rows = 2, cols = 3;
    int **matrix = malloc(rows * sizeof(int *)); // 行指针
    for (int i = 0; i < rows; i++)
        matrix[i] = malloc(cols * sizeof(int)); // 每行分配列
 
    matrix[0][0] = 1;
    matrix[1][2] = 9;
 
    printf("%d %d\n", matrix[0][0], matrix[1][2]);
 
    // 释放内存
    for (int i = 0; i < rows; i++)
        free(matrix[i]);
    free(matrix);
 
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
typedef struct Node
{
    int val;
    struct Node *next;
} Node;
 
int main()
{
    Node *head = malloc(sizeof(Node));
    head->val = 10;
    head->next = malloc(sizeof(Node));
    head->next->val = 20;
    head->next->next = NULL;
 
    Node *p = head;
    while (p)
    {
        printf("%d -> ", p->val);
        p = p->next;
    }
    printf("NULL\n");
 
    // 释放内存
    free(head->next);
    free(head);
 
    return 0;
}

#include <stdio.h>
 
int main()
{
    // 1. 自动加 '\0'
    char str1[] = "Hello";
    str1[0] = 'h'; // 可修改
    printf("str1 = %s\n", str1);
 
    // 2. 指定大小初始化
    char str2[10] = "Hi";
    str2[2] = '!';
    str2[3] = '\0'; // 手动补 '\0'
    printf("str2 = %s\n", str2);
 
    // 3. 逐个字符初始化
    char str3[] = {'H', 'e', 'l', 'l', 'o', '\0'};
    str3[0] = 'h'; // 可修改
    printf("str3 = %s\n", str3);
 
    // 4. 指针指向字面量
    char *str4 = "Hello";
    printf("str4 = %s\n", str4);
    // str4[0] = 'h'; // ⚠️ 不可修改，运行可能崩溃
 
    // 5. 空字符串
    char str5[1] = ""; // 栈上的空字符串
    char *str6 = "";   // 只读数据段的空字符串
    printf("str5 = '%s', str6 = '%s'\n", str5, str6);
 
    return 0;
}

#include <stdio.h>
#include <string.h>
 
int main() {
    char str1[20] = "Hello";
    char str2[] = "World";
    char str3[20];
 
    // strlen
    printf("Length of str1: %lu\n", strlen(str1));
 
    // strcpy
    strcpy(str3, str1);
    printf("str3 = %s\n", str3);
 
    // strcat
    strcat(str3, str2);
    printf("After concatenation, str3 = %s\n", str3);
 
    // strcmp
    if(strcmp(str1, str2) < 0) {
        printf("str1 < str2\n");
    }
 
    // strchr
    char *p = strchr(str3, 'o');
    if(p) {
        printf("'o' appears at position: %ld\n", p - str3);
    }
 
    // memset
    memset(str3, '*', 5);
    str3[5] = '\0';
    printf("After memset, str3 = %s\n", str3);
 
    return 0;
}

#include <stdio.h>
#include <string.h>
 
typedef struct
{
    char name[50];
    int age;
    float score;
} Student;
 
int main()
{
    // 初始化结构体
    Student s1 = {"Alice", 20, 95.5};
 
    // 访问成员
    printf("Name: %s\n", s1.name);
    printf("Age: %d\n", s1.age);
    printf("Score: %.2f\n", s1.score);
 
    // 修改成员
    s1.age = 21;
    strcpy(s1.name, "Alice Zhang");
    printf("Updated Name: %s, Age: %d\n", s1.name, s1.age);
 
    // 结构体数组
    Student class[2] = {{"Bob", 22, 88.0}, {"Charlie", 19, 92.5}};
    for (int i = 0; i < 2; i++)
    {
        printf("%s - %d - %.2f\n", class[i].name, class[i].age, class[i].score);
    }
 
    return 0;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
typedef struct
{
    char name[50];
    int age;
    float score;
} Student;
 
void printStudent(Student *p)
{
    printf("%s - %d - %.2f\n", p->name, p->age, p->score);
}
 
int main()
{
    Student s1 = {"Alice", 20, 95.5};
    Student *p = &s1;
 
    // 通过指针访问
    printf("Name: %s, Age: %d\n", p->name, p->age);
 
    // 修改成员
    p->score = 100.0;
    printStudent(p);
 
    // 动态分配
    Student *p2 = (Student *)malloc(sizeof(Student));
    strcpy(p2->name, "Bob");
    p2->age = 22;
    p2->score = 88.0;
    printStudent(p2);
 
    free(p2);
    return 0;
}

#include <stdio.h>
#include <string.h>
 
union Data {
    int i;
    float f;
    char str[20];
};
 
int main() {
    union Data data;
 
    data.i = 10;
    printf("data.i = %d\n", data.i);
 
    data.f = 3.14;   // i 的值被覆盖
    printf("data.f = %.2f\n", data.f);
    printf("data.i = %d\n", data.i); // 输出不可预期
 
    strcpy(data.str, "Hello");
    printf("data.str = %s\n", data.str);
    printf("data.f = %.2f\n", data.f); // 输出不可预期
 
    printf("Size of union: %zu\n", sizeof(data));
 
    return 0;
}

#include <stdio.h>
 
struct Flags {
    unsigned int flag1 : 1;
    unsigned int flag2 : 3;
    unsigned int flag3 : 4;
};
 
int main() {
    struct Flags f;
 
    f.flag1 = 1;
    f.flag2 = 5;  // 3 位能存的最大值是 7
    f.flag3 = 10; // 4 位能存的最大值是 15
 
    printf("flag1 = %u\n", f.flag1);
    printf("flag2 = %u\n", f.flag2);
    printf("flag3 = %u\n", f.flag3);
 
    return 0;
}

#include <stdio.h>
#include <string.h>
 
// 结构体 typedef
typedef struct
{
    char name[50];
    int age;
} Student;
 
// 数组 typedef
typedef int IntArray[5];
 
// 函数指针 typedef
typedef int (*Operation)(int, int);
 
int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }
 
int main()
{
    // 使用结构体别名
    Student s1;
    strcpy(s1.name, "Alice");
    s1.age = 20;
    printf("%s - %d\n", s1.name, s1.age);
 
    // 使用数组别名
    IntArray arr = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++)
        printf("%d ", arr[i]);
    printf("\n");
 
    // 使用函数指针别名
    Operation op = add;
    printf("2 + 3 = %d\n", op(2, 3));
    op = multiply;
    printf("2 * 3 = %d\n", op(2, 3));
 
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define FILENAME "example.txt"
#define MAX_LINE 256
 
// 创建/写文件
void write_file() {
    FILE *fp = fopen(FILENAME, "w"); // 覆盖写
    if (!fp) { perror("Failed to open file"); return; }
 
    fprintf(fp, "Alice, 20, 95\n");
    fprintf(fp, "Bob, 22, 88\n");
    fprintf(fp, "Charlie, 21, 92\n");
    fclose(fp);
    printf("File written successfully.\n");
}
 
// 读取文件
void read_file() {
    FILE *fp = fopen(FILENAME, "r");
    if (!fp) { printf("File not found.\n"); return; }
 
    char line[MAX_LINE];
    printf("File content:\n");
    while (fgets(line, sizeof(line), fp)) {
        printf("%s", line);
    }
    fclose(fp);
}
 
// 追加写入
void append_file(const char *text) {
    FILE *fp = fopen(FILENAME, "a"); // 追加写
    if (!fp) { perror("Failed to open file"); return; }
 
    fprintf(fp, "%s\n", text);
    fclose(fp);
    printf("Appended: %s\n", text);
}
 
// 修改文件内容（替换包含关键字的行）
void modify_file(const char *keyword, const char *new_text) {
    FILE *fp = fopen(FILENAME, "r");
    if (!fp) return;
 
    FILE *tmp = fopen("tmp.txt", "w");
    char line[MAX_LINE];
    int found = 0;
 
    while (fgets(line, sizeof(line), fp)) {
        if (strstr(line, keyword)) {
            fputs(new_text, tmp);
            fputc('\n', tmp);
            found = 1;
        } else {
            fputs(line, tmp);
        }
    }
 
    fclose(fp);
    fclose(tmp);
 
    if (found) {
        remove(FILENAME);
        rename("tmp.txt", FILENAME);
        printf("Modified lines containing: %s\n", keyword);
    } else {
        remove("tmp.txt");
        printf("No line found containing: %s\n", keyword);
    }
}
 
// 删除文件
void delete_file() {
    if (remove(FILENAME) == 0) {
        printf("File deleted successfully.\n");
    } else {
        perror("Failed to delete file");
    }
}
 
// 查找包含关键字的行
void find_in_file(const char *keyword) {
    FILE *fp = fopen(FILENAME, "r");
    if (!fp) { printf("File not found.\n"); return; }
 
    char line[MAX_LINE];
    int found = 0;
 
    printf("Search results for \"%s\":\n", keyword);
    while (fgets(line, sizeof(line), fp)) {
        if (strstr(line, keyword)) {
            printf("%s", line);
            found = 1;
        }
    }
 
    if (!found) printf("No match found.\n");
    fclose(fp);
}
 
int main() {
    // 创建/写
    write_file();
    read_file();
    printf("\n");
 
    // 追加
    append_file("David, 23, 85");
    read_file();
    printf("\n");
 
    // 修改
    modify_file("Bob", "Bob, 22, 90");
    read_file();
    printf("\n");
 
    // 查找
    find_in_file("Charlie");
    printf("\n");
 
    // 删除
    delete_file();
    read_file();
 
    return 0;
}

#include <stdio.h>
#include <stdarg.h>
 
// 可变参数函数：计算 sum
int sum(int count, ...)
{
    int total = 0;
    va_list args;          // 定义参数列表
    va_start(args, count); // 初始化
 
    for (int i = 0; i < count; i++)
    {
        int value = va_arg(args, int); // 获取下一个参数
        total += value;
    }
 
    va_end(args); // 清理
    return total;
}
 
int main()
{
    printf("sum(1, 2, 3) = %d\n", sum(3, 1, 2, 3));
    printf("sum(5, 1, 2, 3, 4, 5) = %d\n", sum(5, 1, 2, 3, 4, 5));
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
    // ---------------------------
    // 1. malloc: allocate uninitialized memory
    // ---------------------------
    int *arr1 = (int *)malloc(5 * sizeof(int));
    if (!arr1)
    {
        perror("malloc failed");
        return 1;
    }
    printf("Contents of memory allocated by malloc (uninitialized, may contain garbage values):\n");
    for (int i = 0; i < 5; i++)
        printf("%d ", arr1[i]);
    printf("\n");
 
    // ---------------------------
    // 2. calloc: allocate and initialize memory to 0
    // ---------------------------
    int *arr2 = (int *)calloc(5, sizeof(int));
    if (!arr2)
    {
        perror("calloc failed");
        return 1;
    }
    printf("Contents of memory allocated by calloc (initialized to 0):\n");
    for (int i = 0; i < 5; i++)
        printf("%d ", arr2[i]);
    printf("\n");
 
    // ---------------------------
    // 3. realloc: change memory size
    // ---------------------------
    for (int i = 0; i < 5; i++)
        arr2[i] = i + 1;
    arr2 = (int *)realloc(arr2, 8 * sizeof(int)); // expand to 8 elements
    if (!arr2)
    {
        perror("realloc failed");
        return 1;
    }
    for (int i = 5; i < 8; i++)
        arr2[i] = i + 1; // initialize new elements
    printf("Contents of memory after realloc:\n");
    for (int i = 0; i < 8; i++)
        printf("%d ", arr2[i]);
    printf("\n");
 
    // ---------------------------
    // 4. free: release memory
    // ---------------------------
    free(arr1);
    free(arr2);
    arr1 = NULL;
    arr2 = NULL;
    printf("Memory has been freed.\n");
 
    return 0;
}

#include <stdio.h>
 
int main(int argc, char *argv[]) {
    printf("Number of arguments: %d\n", argc);
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

#include <iostream>
#include <limits> // std::numeric_limits
 
int main()
{
   std::cout << "bool: " << std::numeric_limits<bool>::min() << " to "
             << std::numeric_limits<bool>::max() << "\n";
 
   std::cout << "char: " << int(std::numeric_limits<char>::min()) << " to "
             << int(std::numeric_limits<char>::max()) << "\n";
 
   std::cout << "unsigned char: " << int(std::numeric_limits<unsigned char>::min()) << " to "
             << int(std::numeric_limits<unsigned char>::max()) << "\n";
 
   std::cout << "short: " << std::numeric_limits<short>::min() << " to "
             << std::numeric_limits<short>::max() << "\n";
 
   std::cout << "unsigned short: " << std::numeric_limits<unsigned short>::min() << " to "
             << std::numeric_limits<unsigned short>::max() << "\n";
 
   std::cout << "int: " << std::numeric_limits<int>::min() << " to "
             << std::numeric_limits<int>::max() << "\n";
 
   std::cout << "unsigned int: " << std::numeric_limits<unsigned int>::min() << " to "
             << std::numeric_limits<unsigned int>::max() << "\n";
 
   std::cout << "long long: " << std::numeric_limits<long long>::min() << " to "
             << std::numeric_limits<long long>::max() << "\n";
 
   std::cout << "unsigned long long: " << std::numeric_limits<unsigned long long>::min() << " to "
             << std::numeric_limits<unsigned long long>::max() << "\n";
 
   std::cout << "float: " << std::numeric_limits<float>::min() << " to "
             << std::numeric_limits<float>::max() << "\n";
 
   std::cout << "double: " << std::numeric_limits<double>::min() << " to "
             << std::numeric_limits<double>::max() << "\n";
             
   std::cout << "wchar_t: "
             << std::numeric_limits<wchar_t>::min() << " to "
             << std::numeric_limits<wchar_t>::max() << "\n";
   return 0;
}

#include <iostream>
#include <string>
 
int main() {
    std::string str1 = "Hello";
    std::string str2 = "World";
 
    // Concatenate
    std::string str3 = str1 + " " + str2;
    
    // Length
    std::cout << "Length: " << str3.length() << std::endl;
 
    // Access characters
    for (size_t i = 0; i < str3.length(); i++) {
        std::cout << str3[i] << " ";
    }
    std::cout << std::endl;
 
    // Compare
    if (str1 != str2) {
        std::cout << str1 << " and " << str2 << " are different" << std::endl;
    }
 
    return 0;
}

#include <iostream>
 
void addOne(int &x) { x += 1; }
 
int main()
{
   int a = 5;
   addOne(a);
   std::cout << a << std::endl;
}

#include <iostream>
#include <vector>
using namespace std;
 
int main()
{
   vector<int> v;   // 类似 Python list
   v.push_back(10); // append
   v.push_back(20);
   v.push_back(30);
 
   // 遍历
   for (auto x : v)
      cout << x << " ";
   cout << endl;
 
   // 删除末尾
   v.pop_back();
 
   // 插入
   v.insert(v.begin() + 1, 15); // 类似 Python list.insert(1, 15)
 
   // 输出最终内容
   for (auto x : v)
      cout << x << " ";
   cout << endl;
 
   return 0;
}

#include <iostream>
#include <string>
using namespace std;
 
// 类定义
class Person {
private:
    string name;   // 私有成员，封装数据
    int age;
 
public:
    // 构造函数
    Person(string n, int a) : name(n), age(a) {}
 
    // 公有成员函数
    void introduce() {
        cout << "我是 " << name << "，今年 " << age << " 岁。" << endl;
    }
 
    // 设置年龄（封装示例）
    void setAge(int a) {
        if (a >= 0) age = a;
    }
 
    int getAge() { return age; }
};
 
int main() {
    Person p1("Alice", 20); // 创建对象
    p1.introduce();
 
    p1.setAge(21);
    cout << "修改年龄后: " << p1.getAge() << endl;
 
    return 0;
}

class Student : public Person { // 公有继承
private:
    string school;
 
public:
    Student(string n, int a, string s) : Person(n, a), school(s) {}
 
    void showSchool() {
        cout << "学校: " << school << endl;
    }
};
 
int main() {
    Student s1("Bob", 18, "清华大学");
    s1.introduce();   // 继承父类方法
    s1.showSchool();  // 子类方法
}

class Animal {
public:
    virtual void sound() { // 虚函数
        cout << "动物叫声" << endl;
    }
};
 
class Dog : public Animal {
public:
    void sound() override { // 重写父类虚函数
        cout << "汪汪汪" << endl;
    }
};
 
class Cat : public Animal {
public:
    void sound() override {
        cout << "喵喵喵" << endl;
    }
};
 
void makeSound(Animal* a) {
    a->sound(); // 根据对象实际类型调用
}
 
int main() {
    Dog dog;
    Cat cat;
 
    makeSound(&dog); // 汪汪汪
    makeSound(&cat); // 喵喵喵
}
 

#include <iostream>
using namespace std;
 
// 普通函数重载
int add(int a, int b) {
    return a + b;
}
 
double add(double a, double b) {
    return a + b;
}
 
int add(int a, int b, int c) {
    return a + b + c;
}
 
int main() {
    cout << add(1, 2) << endl;        // 调用 int add(int,int)
    cout << add(1.5, 2.3) << endl;    // 调用 double add(double,double)
    cout << add(1, 2, 3) << endl;     // 调用 int add(int,int,int)
}

#include <iostream>
using namespace std;
 
class Point {
public:
    int x, y;
    Point(int a=0, int b=0) : x(a), y(b) {}
 
    // 重载 + 运算符
    Point operator+(const Point& p) {
        return Point(x + p.x, y + p.y);
    }
 
    void show() {
        cout << "(" << x << "," << y << ")" << endl;
    }
};
 
int main() {
    Point p1(1, 2);
    Point p2(3, 4);
    Point p3 = p1 + p2; // 使用重载的 +
    p3.show();           // 输出 (4,6)
}

#include <iostream>
#include <stdexcept>
using namespace std;
 
double divide(double a, double b)
{
   if (b == 0)
      throw runtime_error("Division by zero"); // throw exception
   return a / b;
}
 
int main()
{
   try
   {
      cout << divide(10, 2) << endl; // normal
      cout << divide(10, 0) << endl; // will throw exception
   }
   catch (const exception &e)
   {
      cout << "Caught exception: " << e.what() << endl;
   }
 
   cout << "Program continues execution" << endl;
   return 0;
}

#include <iostream>
#include <cstdlib> // malloc, free
using namespace std;
 
class MyClass
{
public:
   MyClass()
   {
      cout << "Constructor called" << endl;
   }
   ~MyClass()
   {
      cout << "Destructor called" << endl;
   }
   void sayHello()
   {
      cout << "Hello from MyClass" << endl;
   }
};
 
int main()
{
   cout << "= Using malloc =" << endl;
   // malloc 分配内存，但不会调用构造函数
   MyClass *obj1 = (MyClass *)malloc(sizeof(MyClass));
   // obj1->sayHello(); // 可能未初始化，调用可能异常
   free(obj1); // 不会调用析构函数
 
   cout << "\n= Using new =" << endl;
   // new 分配内存并调用构造函数
   MyClass *obj2 = new MyClass();
   obj2->sayHello();
   delete obj2; // 会调用析构函数
 
   return 0;
}

#include <iostream>
 
namespace A {
    int x = 5;
}
 
namespace B {
    int x = 10;
}
 
int main() {
    std::cout << A::x << std::endl;  // 输出 5
    std::cout << B::x << std::endl;  // 输出 10
}

#include <iostream>
using namespace std;
 
// 函数模板
template <typename T>
T add(T a, T b) {
    return a + b;
}
 
int main() {
    cout << add(10, 20) << endl;      // int
    cout << add(1.5, 2.3) << endl;    // double
    return 0;
}