Week 01: C 语言简介与开发环境

           C (1972)
          / | \
         /  |  \
    C++ (1983)  Objective-C (1984)
        |
    Java/C# (语法影响)
        |
    Go/Rust (现代系统语言)

// 源代码
#include <stdio.h>
#define PI 3.14159

int main(void) {
    printf("PI = %f\n", PI);
    return 0;
}

# 查看预处理结果
gcc -E main.c -o main.i

# 生成汇编代码
gcc -S main.c -o main.s

; 示例汇编输出
main:
    push    rbp
    mov     rbp, rsp
    lea     rdi, [rip+.LC0]
    movsd   xmm0, [rip+.LC1]
    call    printf
    xor     eax, eax
    pop     rbp
    ret

# 生成目标文件
gcc -c main.c -o main.o

# 链接生成可执行文件
gcc main.o -o main

# 完整编译过程
gcc main.c -o main

# 等价于
gcc -E main.c -o main.i     # 预处理
gcc -S main.i -o main.s     # 编译
gcc -c main.s -o main.o     # 汇编
gcc main.o -o main          # 链接

sudo apt update
sudo apt install build-essential
gcc --version

xcode-select --install
# 或安装 Homebrew 后
brew install gcc

gcc -Wall -Wextra -Werror -pedantic -std=c11 -g main.c -o main

# 安装 ARM 交叉编译器 (Debian/Ubuntu)
sudo apt install gcc-aarch64-linux-gnu

# 交叉编译
aarch64-linux-gnu-gcc -o hello_arm hello.c

# 查看目标架构
file hello_arm
# hello_arm: ELF 64-bit LSB executable, ARM aarch64

# 通过 CROSS_COMPILE 变量切换
CROSS_COMPILE ?=
CC = $(CROSS_COMPILE)gcc
AR = $(CROSS_COMPILE)ar

# 使用: make CROSS_COMPILE=aarch64-linux-gnu-

aarch64-linux-gnu-gcc --sysroot=/path/to/sysroot -o hello hello.c

// hello.c
#include <stdio.h>

int main(void) {
    printf("Hello, World!\n");
    return 0;
}

gcc hello.c -o hello
./hello
# Hello, World!

#include <stdio.h>      // 1. 预处理指令: 包含标准输入输出头文件

int main(void) {        // 2. main 函数: 程序入口点
                        //    int: 返回类型
                        //    void: 无参数
    
    printf("Hello\n");  // 3. 函数调用: 输出字符串
    
    return 0;           // 4. 返回值: 0 表示成功
}

// 形式 1: 无参数
int main(void) {
    return 0;
}

// 形式 2: 带命令行参数
int main(int argc, char *argv[]) {
    // argc: 参数个数
    // argv: 参数数组
    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }
    return 0;
}

// 形式 3: 带环境变量 (POSIX 扩展)
int main(int argc, char *argv[], char *envp[]) {
    return 0;
}

# 查看上一个程序的返回值
echo $?

int x;          // 声明
int y = 10;     // 声明并初始化

int a, b, c;    // 同时声明多个变量
int d = 1, e = 2;

#include <stdio.h>
#include <limits.h>

int main(void) {
    printf("char: %zu bytes, range: %d to %d\n", 
           sizeof(char), CHAR_MIN, CHAR_MAX);
    printf("int: %zu bytes, range: %d to %d\n", 
           sizeof(int), INT_MIN, INT_MAX);
    printf("long: %zu bytes, range: %ld to %ld\n", 
           sizeof(long), LONG_MIN, LONG_MAX);
    return 0;
}

int x = -10;            // 有符号 (默认)
unsigned int y = 10;    // 无符号 (只能为正)

// 类型范围
// signed int:   -2,147,483,648 to 2,147,483,647
// unsigned int: 0 to 4,294,967,295

#include <stdint.h>

int8_t   a;   // 精确 8 位有符号
uint8_t  b;   // 精确 8 位无符号
int16_t  c;   // 精确 16 位有符号
uint16_t d;   // 精确 16 位无符号
int32_t  e;   // 精确 32 位有符号
uint32_t f;   // 精确 32 位无符号
int64_t  g;   // 精确 64 位有符号
uint64_t h;   // 精确 64 位无符号

size_t   i;   // 无符号, 用于表示大小
ssize_t  j;   // 有符号, 用于表示大小或错误

#include <stdio.h>
#include <float.h>

int main(void) {
    float f = 3.14159265358979f;   // f 后缀表示 float
    double d = 3.14159265358979;   // 默认 double
    
    printf("float: %.15f\n", f);   // 精度不足
    printf("double: %.15f\n", d);  // 精度足够
    
    printf("float epsilon: %e\n", FLT_EPSILON);
    printf("double epsilon: %e\n", DBL_EPSILON);
    return 0;
}

char c = 'A';           // 字符字面量
char d = 65;            // ASCII 值

printf("%c\n", c);      // A
printf("%d\n", c);      // 65

// 转义字符
char newline = '\n';    // 换行
char tab = '\t';        // 制表符
char quote = '\'';      // 单引号
char backslash = '\\';  // 反斜杠
char null_char = '\0';  // 空字符

#include <stdbool.h>

bool flag = true;
bool done = false;

if (flag) {
    printf("flag is true\n");
}

// 实现上, bool 是 _Bool 的别名
// true 是 1, false 是 0

gcc -c main.c -o main.o
gcc -c util.c -o util.o
gcc main.o util.o -o program

# Makefile
CC = gcc
CFLAGS = -Wall -Wextra -g

program: main.o util.o
	$(CC) main.o util.o -o program

main.o: main.c util.h
	$(CC) $(CFLAGS) -c main.c -o main.o

util.o: util.c util.h
	$(CC) $(CFLAGS) -c util.c -o util.o

clean:
	rm -f *.o program

make           # 构建默认目标 (第一个)
make program   # 构建指定目标
make clean     # 执行 clean 规则
make -j4       # 并行编译 (4 个任务)

target: prerequisites
	recipe
	recipe

# 递归展开 (使用时展开)
CC = gcc
CFLAGS = $(WARN_FLAGS) -O2

# 简单展开 (定义时展开)
CC := gcc
OBJS := main.o util.o

# 条件赋值 (未定义时才赋值)
CC ?= gcc

# 追加
CFLAGS += -g

$@    # 目标文件名
$<    # 第一个依赖文件
$^    # 所有依赖文件 (去重)
$+    # 所有依赖文件 (不去重)
$?    # 比目标新的依赖文件
$*    # 匹配的 stem (模式规则中)
$(@D) # 目标的目录部分
$(@F) # 目标的文件名部分

program: main.o util.o
	$(CC) $^ -o $@
# 展开为: gcc main.o util.o -o program

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@
# 对于 main.o: gcc -Wall -c main.c -o main.o

# 通用规则: 从 .c 生成 .o
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# 通用规则: 从 .c 生成可执行文件
%: %.c
	$(CC) $(CFLAGS) $< -o $@

# 内置: .c -> .o
%.o: %.c
	$(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

# 内置: .o -> 可执行文件
%: %.o
	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

CC = gcc
CFLAGS = -Wall -g

program: main.o util.o
# 依赖隐式规则自动编译 .c -> .o

# 替换
$(subst from,to,text)
SRCS := main.c util.c
OBJS := $(subst .c,.o,$(SRCS))  # main.o util.o

# 模式替换
$(patsubst pattern,replacement,text)
OBJS := $(patsubst %.c,%.o,$(SRCS))

# 简写形式
OBJS := $(SRCS:.c=.o)

# 去除空格
$(strip text)

# 查找
$(findstring find,text)

# 过滤
$(filter pattern,text)
$(filter-out pattern,text)

# 目录部分
$(dir src/main.c)  # src/

# 文件名部分
$(notdir src/main.c)  # main.c

# 后缀
$(suffix main.c)  # .c

# 基名
$(basename main.c)  # main

# 添加后缀
$(addsuffix .o,main util)  # main.o util.o

# 添加前缀
$(addprefix src/,main.c)  # src/main.c

# 展开通配符
SRCS := $(wildcard *.c)
SRCS := $(wildcard src/*.c)

# 执行 shell 命令
DATE := $(shell date +%Y%m%d)
UNAME := $(shell uname -s)

# ifdef / ifndef
DEBUG := 1
ifdef DEBUG
    CFLAGS += -g -DDEBUG
else
    CFLAGS += -O2
endif

# ifeq / ifneq
OS := $(shell uname -s)
ifeq ($(OS),Linux)
    LDLIBS += -lpthread
endif

ifeq ($(CC),gcc)
    CFLAGS += -std=gnu11
else ifeq ($(CC),clang)
    CFLAGS += -std=c11
endif

# 声明为伪目标 (不是实际文件)
.PHONY: all clean install test

all: program

clean:
	rm -f *.o program

install: program
	cp program /usr/local/bin/

test: program
	./program --test

gcc -MM main.c
# 输出: main.o: main.c util.h config.h

CC = gcc
CFLAGS = -Wall -g
SRCS = main.c util.c
OBJS = $(SRCS:.c=.o)
DEPS = $(SRCS:.c=.d)

program: $(OBJS)
	$(CC) $(LDFLAGS) $^ -o $@

# 生成依赖文件
%.d: %.c
	$(CC) -MM -MF $@ -MT '$*.o $@' $<

# 编译规则
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# 包含依赖文件
-include $(DEPS)

clean:
	rm -f $(OBJS) $(DEPS) program

.PHONY: clean

CFLAGS = -Wall -g -MMD -MP

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

-include $(OBJS:.o=.d)

# 项目结构:
# src/main.c src/util.c
# include/util.h
# build/

SRCDIR = src
INCDIR = include
BUILDDIR = build

SRCS = $(wildcard $(SRCDIR)/*.c)
OBJS = $(patsubst $(SRCDIR)/%.c,$(BUILDDIR)/%.o,$(SRCS))

CFLAGS = -Wall -I$(INCDIR)

$(BUILDDIR)/program: $(OBJS)
	$(CC) $^ -o $@

$(BUILDDIR)/%.o: $(SRCDIR)/%.c | $(BUILDDIR)
	$(CC) $(CFLAGS) -c $< -o $@

$(BUILDDIR):
	mkdir -p $@

clean:
	rm -rf $(BUILDDIR)

.PHONY: clean

# === 配置 ===
CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11
LDFLAGS :=
LDLIBS  :=

# 调试/发布模式
ifdef DEBUG
    CFLAGS += -g -O0 -DDEBUG
else
    CFLAGS += -O2 -DNDEBUG
endif

# === 源文件 ===
SRCDIR  := src
INCDIR  := include
BUILDDIR := build

SRCS := $(wildcard $(SRCDIR)/*.c)
OBJS := $(patsubst $(SRCDIR)/%.c,$(BUILDDIR)/%.o,$(SRCS))
DEPS := $(OBJS:.o=.d)

TARGET := $(BUILDDIR)/myprogram

# === 规则 ===
.PHONY: all clean rebuild

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

$(BUILDDIR)/%.o: $(SRCDIR)/%.c | $(BUILDDIR)
	$(CC) $(CFLAGS) -I$(INCDIR) -MMD -MP -c $< -o $@

$(BUILDDIR):
	mkdir -p $@

clean:
	rm -rf $(BUILDDIR)

rebuild: clean all

# 包含自动生成的依赖
-include $(DEPS)

make                # 发布构建
make DEBUG=1        # 调试构建
make -j$(nproc)     # 并行构建
make clean          # 清理
make rebuild        # 重新构建

make -n             # 只打印命令, 不执行
make -B             # 强制重新构建所有
make --debug=v      # 详细调试信息
make -p             # 打印所有规则和变量
make VAR=value      # 命令行覆盖变量

# 1. 使用有意义的变量名
SOURCES := $(wildcard src/*.c)
OBJECTS := $(SOURCES:.c=.o)
TARGET  := bin/myapp

# 2. 分组相关配置
# === 编译器配置 ===
CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11

# === 目录配置 ===
SRCDIR  := src
OBJDIR  := obj
BINDIR  := bin

# 3. 添加注释说明复杂规则
# 生成依赖文件, -MT 指定目标, -MF 指定输出文件
%.d: %.c
	$(CC) -MM -MT '$*.o $@' -MF $@ $<

# 4. 使用 .PHONY 声明所有伪目标
.PHONY: all clean install test debug release

# 检测操作系统
UNAME := $(shell uname -s)

ifeq ($(UNAME),Linux)
    LDLIBS  += -lpthread -lrt
    INSTALL := install
endif

ifeq ($(UNAME),Darwin)
    LDLIBS  += -lpthread
    INSTALL := ginstall
endif

ifeq ($(OS),Windows_NT)
    EXE     := .exe
    RM      := del /Q
else
    EXE     :=
    RM      := rm -f
endif

TARGET := myapp$(EXE)

# 1. 使用 -Werror 将警告视为错误
CFLAGS += -Werror

# 2. 命令失败时停止
.DELETE_ON_ERROR:

# 3. 检查工具是否存在
check-tools:
	@which $(CC) > /dev/null || (echo "Error: $(CC) not found" && exit 1)
	@which ar > /dev/null || (echo "Error: ar not found" && exit 1)

# 4. 使用 || true 忽略特定错误
clean:
	$(RM) $(OBJECTS) || true
	$(RM) $(TARGET) || true

project/
├── Makefile           # 主 Makefile
├── config.mk          # 配置变量 (可选)
├── rules.mk           # 通用规则 (可选)
├── src/               # 源代码
│   ├── main.c
│   └── module/
│       ├── module.c
│       └── module.h
├── include/           # 公共头文件
│   └── public_api.h
├── lib/               # 第三方库
├── tests/             # 测试代码
│   ├── Makefile
│   └── test_module.c
├── obj/               # 目标文件 (生成)
├── bin/               # 可执行文件 (生成)
└── docs/              # 文档

# 包含配置
include config.mk

# 模块列表
MODULES := core network utils

# 收集所有源文件
SRCS :=
include $(addsuffix /module.mk,$(addprefix src/,$(MODULES)))

OBJS := $(patsubst src/%.c,obj/%.o,$(SRCS))

all: $(TARGET)

$(TARGET): $(OBJS)
	@mkdir -p $(dir $@)
	$(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

obj/%.o: src/%.c
	@mkdir -p $(dir $@)
	$(CC) $(CFLAGS) -c $< -o $@

include rules.mk

# 本模块的源文件
SRCS += src/core/init.c
SRCS += src/core/config.c
SRCS += src/core/logger.c

# 项目配置
PROJECT := myproject
VERSION := 1.0.0

# 编译器
CC      := gcc
CFLAGS  := -Wall -Wextra -std=c11 -Iinclude

# 目录
SRCDIR  := src
OBJDIR  := obj
BINDIR  := bin

# 目标
TARGET  := $(BINDIR)/$(PROJECT)

# 安装路径
PREFIX  := /usr/local

# 顶层 Makefile
SUBDIRS := lib src tests

all:
	@for dir in $(SUBDIRS); do \
		$(MAKE) -C $$dir; \
	done

clean:
	@for dir in $(SUBDIRS); do \
		$(MAKE) -C $$dir clean; \
	done

# 使用 include 合并所有 module.mk
# 所有依赖在同一个 Make 实例中处理
include src/core/module.mk
include src/network/module.mk
include tests/module.mk

# 从 Git 获取版本信息
GIT_VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "unknown")
GIT_COMMIT  := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
BUILD_TIME  := $(shell date -u '+%Y-%m-%d %H:%M:%S UTC')

CFLAGS += -DVERSION=\"$(GIT_VERSION)\"
CFLAGS += -DGIT_COMMIT=\"$(GIT_COMMIT)\"
CFLAGS += -DBUILD_TIME=\"$(BUILD_TIME)\"

// 在代码中使用
printf("Version: %s (%s)\n", VERSION, GIT_COMMIT);
printf("Built: %s\n", BUILD_TIME);

# CI 友好的目标
.PHONY: ci lint test coverage

# CI 入口点
ci: lint build test

# 代码检查
lint:
	cppcheck --enable=all --error-exitcode=1 $(SRCDIR)
	clang-format --dry-run --Werror $(SRCS)

# 测试
test: $(TARGET)
	./run_tests.sh

# 代码覆盖率
coverage: CFLAGS += --coverage
coverage: LDFLAGS += --coverage
coverage: clean build test
	gcov -o $(OBJDIR) $(SRCS)
	lcov --capture --directory $(OBJDIR) --output-file coverage.info
	genhtml coverage.info --output-directory coverage_report

name: CI
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install dependencies
        run: sudo apt-get install -y cppcheck
      - name: Lint
        run: make lint
      - name: Build
        run: make -j$(nproc)
      - name: Test
        run: make test

# 支持本地配置覆盖 (不提交到版本控制)
-include local.mk

# 支持环境变量覆盖
CC      ?= gcc
PREFIX  ?= /usr/local
DEBUG   ?= 0

# 支持命令行覆盖
# make CC=clang DEBUG=1

# 开发者本地配置
CC := clang
CFLAGS += -fsanitize=address
DEBUG := 1

# 遵循 GNU 标准目标
.PHONY: all install uninstall clean distclean check dist

# 默认目标
all: $(TARGET)

# 安装到系统
install: $(TARGET)
	$(INSTALL) -d $(DESTDIR)$(PREFIX)/bin
	$(INSTALL) -m 755 $(TARGET) $(DESTDIR)$(PREFIX)/bin/

# 卸载
uninstall:
	$(RM) $(DESTDIR)$(PREFIX)/bin/$(notdir $(TARGET))

# 清理构建产物
clean:
	$(RM) -r $(OBJDIR) $(BINDIR)

# 清理所有生成文件 (包括配置)
distclean: clean
	$(RM) config.mk local.mk

# 运行测试
check: test

# 创建发布包
dist:
	git archive --prefix=$(PROJECT)-$(VERSION)/ -o $(PROJECT)-$(VERSION).tar.gz HEAD

# 提供帮助目标
.PHONY: help

help:
	@echo "Usage: make [target] [VAR=value]"
	@echo ""
	@echo "Targets:"
	@echo "  all       Build the project (default)"
	@echo "  clean     Remove build artifacts"
	@echo "  install   Install to PREFIX (default: /usr/local)"
	@echo "  test      Run tests"
	@echo "  help      Show this help"
	@echo ""
	@echo "Variables:"
	@echo "  CC        C compiler (default: gcc)"
	@echo "  DEBUG     Enable debug build (default: 0)"
	@echo "  PREFIX    Install prefix (default: /usr/local)"
	@echo ""
	@echo "Examples:"
	@echo "  make DEBUG=1"
	@echo "  make CC=clang"
	@echo "  make install PREFIX=/opt/myapp"

# 错误: 使用空格缩进 (最常见错误)
target:
    echo "Hello"  # 4 个空格, 会报错

# 正确: 使用 Tab 缩进
target:
	echo "Hello"  # 1 个 Tab

# 递归展开 (=): 使用时展开
A = $(B)
B = hello
# A 的值是 "hello"

# 简单展开 (:=): 定义时展开
A := $(B)
B := hello
# A 的值是 "" (定义时 B 还未定义)

# 错误: 通配符在变量中不自动展开
SRCS = *.c  # SRCS 的值是字面量 "*.c"

# 正确: 使用 wildcard 函数
SRCS = $(wildcard *.c)

target:
	@echo "静默执行, 不打印命令本身"
	-rm file_that_might_not_exist  # 忽略错误
	+$(MAKE) -C subdir  # 即使 -n 模式也执行

# 问题: 隐含的依赖关系
all: prog1 prog2
prog1: common.o main1.o
prog2: common.o main2.o

# 并行构建时, common.o 可能被同时编译两次
# 解决: 确保依赖图正确, 不重复编译

# 或者使用 .NOTPARALLEL (不推荐, 会禁用并行)
.NOTPARALLEL: