1. C/C++特性控制方法

C/C++特性控制通过预处理器指令（如 #ifdef、#ifndef、#if 和 #else）实现类似的条件编译控制。通过编译时，通过gcc -D 定义预处理宏，来实现条件编译。

1.1 C/C++Feature控制逻辑

使用预处理器指令来启用或禁用代码片段：

#ifdef FEATURE_FOO
void foo_function() {
    printf("Foo feature is enabled\n");
}
#else
void foo_function() {
    printf("Foo feature is not enabled\n");
}
#endif

编译时定义宏来控制特性：

gcc -DFEATURE_FOO main.c -o main

构建配置文件，可以使用构建系统（如 Makefile 或 CMake）来控制编译选项。例如，使用 Makefile 定义不同的构建配置：

ifeq ($(CONFIG),debug)
    CFLAGS += -DDEBUG
endif

ifeq ($(CONFIG),secure)
    CFLAGS += -DSECURE
endif

编译时指定配置：

make CONFIG=debug

1.2 常见应用

1.2.1 条件依赖

通过预处理器控制包含的头文件或代码：

#ifdef USE_JSON
#include <json.h>
#endif

编译时定义宏：

gcc -DUSE_JSON main.c -o main

1.2.2 性能优化

选择不同的实现以优化性能：

#ifdef FAST_MATH
void compute() {
    // 使用快速但复杂的算法
}
#else
void compute() {
    // 使用简单但慢的算法
}
#endif

1.2.3 平台特定代码

根据目标平台选择不同的代码路径：

#ifdef _WIN32
void platform_function() {
    printf("Running on Windows\n");
}
#elif __linux__
void platform_function() {
    printf("Running on Linux\n");
}
#endif

1.2.4调试和日志

控制调试信息和日志记录：

#ifdef DEBUG
void debug_log(const char *message) {
    printf("DEBUG: %s\n", message);
}
#else
void debug_log(const char *message) {
    // 不做任何事情
}
#endif

1.2.5 API 兼容性

控制 API 的不同版本或不同功能集：

#ifdef API_V1
void api_function() {
    // V1 版本实现
}
#elif defined(API_V2)
void api_function() {
    // V2 版本实现
}
#endif

2. Rust 特性控制方法

2.1. Rust 控制逻辑

以下是一些关于 Rust Feat 的常用逻辑控制方法：

• 定义特性

在 Cargo.toml 文件中定义特性：

[features]
default = ["foo"]   # 默认启用的特性
foo = []
bar = []

• 使用特性

在代码中使用特性通过 cfg 属性：

#[cfg(feature = "foo")]
fn foo_function() {
    println!("Foo feature is enabled");
}

#[cfg(feature = "bar")]
fn bar_function() {
    println!("Bar feature is enabled");
}

• 启用特性

在构建或运行项目时启用特性：

# 启用单个特性
cargo build --features "foo"
# 启用多个特性
cargo build --features "foo bar"
# 禁用所有默认特性
cargo build --no-default-features
#禁用默认特性并启用特定特性
cargo build --no-default-features --features "bar"

• 条件依赖

在 Cargo.toml 中为特性添加条件依赖：

[dependencies]
serde = { version = "1.0", optional = true }  # 将依赖作为可选依赖项

[features]
default = []
serde_support = ["serde"]    # 使用feature 条件控制依赖项

• 测试特性

运行测试时启用特性：

cargo test --features "foo"

• 配置特性组合

根据特性组合不同的代码逻辑：

#[cfg(all(feature = "foo", feature = "bar"))]
fn combined_feature_function() {
    println!("Both foo and bar features are enabled");
}

• 特性文档

为特性添加文档说明，便于使用者了解特性用途：

[features]
default = ["foo"]
foo = [] # This feature enables the foo functionality
bar = [] # This feature enables the bar functionality

2.2. 常见应用

Rust 的特性（Features）机制在多个场景中广泛应用，主要用于控制编译时的行为，使代码库更具灵活性和可配置性。以下是一些常见的应用场景：

2.2.1. 条件依赖

为库或应用添加可选依赖，通过特性启用或禁用：

[dependencies]
serde = { version = "1.0", optional = true }

[features]
default = []
serde_support = ["serde"]

使用时启用特性：

#[cfg(feature = "serde_support")]
extern crate serde;

2.2.2. 编译

根据特性编译不同的代码路径，避免不必要的代码在最终二进制文件中：

#[cfg(feature = "foo")]
fn foo_function() {
    println!("Foo feature is enabled");
}

#[cfg(not(feature = "foo"))]
fn foo_function() {
    println!("Foo feature is not enabled");
}

2.2.3. 库的精简

为减少最终二进制的大小，通过特性裁剪不必要的功能：

[features]
default = ["full"]
full = ["feature1", "feature2"]
minimal = []

在使用库时选择所需的特性：

cargo build --no-default-features --features "minimal"

2.2.4. 平台特定代码

根据目标平台启用或禁用特定功能：

#[cfg(target_os = "windows")]
fn platform_function() {
    println!("Running on Windows");
}

#[cfg(target_os = "linux")]
fn platform_function() {
    println!("Running on Linux");
}

2.2.5. 测试配置

通过特性控制测试代码路径，启用或禁用某些测试：

#[cfg(test)]
mod tests {
    #[cfg(feature = "extended_tests")]
    #[test]
    fn test_extended() {
        // 扩展测试
    }
}

运行测试时启用特性：

cargo test --features "extended_tests"

2.2.6. 调试和日志

通过特性启用或禁用调试信息和日志记录：

#[cfg(feature = "debug")]
fn debug_log(message: &str) {
    println!("DEBUG: {}", message);
}

#[cfg(not(feature = "debug"))]
fn debug_log(_: &str) {
    // 不做任何事情
}

其实，rust 自身提供了debug_assertions针对release 和 debug 提供条件标记。

fn main() {
    // 使用 cfg 宏来判断是否为 debug 版本
    if cfg!(debug_assertions) {
        println!("This is a debug build");
    } else {
        println!("This is a release build");
    }
    
    // 也可以使用 #[cfg] 属性来条件编译代码段
    debug_only_function();
    release_only_function();
}

#[cfg(debug_assertions)]
fn debug_only_function() {
    println!("This function only runs in debug builds");
}

#[cfg(not(debug_assertions))]
fn release_only_function() {
    println!("This function only runs in release builds");
}

Ps: cfg! 宏

cfg! 宏是一种在编译时进行条件判断的工具，它返回一个布尔值，用于在代码中做条件分支。它常用于区分编译模式（如 debug 或 release）、目标平台（如操作系统）以及自定义特性。通过使用 cfg! 宏，可以根据编译时的配置进行相应的代码处理，以实现更灵活和可配置的代码。具体的是在编译器实现，下面demo 可以看看原理：

macro_rules! cfg {
    (feature = $feature:expr) => {
        {
            // 检查特性是否启用
            // 这个逻辑实际上由编译器实现，这里只是伪代码示意
            if is_feature_enabled($feature) {
                true
            } else {
                false
            }
        }
    };
    (target_os = $os:expr) => {
        {
            // 检查目标操作系统
            // 实际上由编译器实现的逻辑，这里只是伪代码示意
            if target_os() == $os {
                true
            } else {
                false
            }
        }
    };
    (debug_assertions) => {
        {
            // 检查是否启用了 debug_assertions
            // 实际上由编译器实现的逻辑，这里只是伪代码示意
            if debug_assertions_enabled() {
                true
            } else {
                false
            }
        }
    };
    // 其他条件判断
}

fn is_feature_enabled(feature: &str) -> bool {
    // 伪代码：实际实现依赖于编译器的内部机制
    // 返回是否启用了指定特性
}

fn target_os() -> &'static str {
    // 伪代码：实际实现依赖于编译器的内部机制
    // 返回当前目标操作系统
}

fn debug_assertions_enabled() -> bool {
    // 伪代码：实际实现依赖于编译器的内部机制
    // 返回是否启用了 debug_assertions
}

3. Rust 在项目中的实践

以syskits为例， 通过Cargo.toml 为特性添加条件依赖和控制。

3.1. 主项目对feature的整合

[features]
default = ["feat_common_core"]

## OS feature shortcodes
unix = ["feat_os_unix"]
windows = ["feat_os_windows"]
feat_selinux = [
  "cp/selinux",
  "ls/selinux",
  "selinux",
  "feat_require_selinux",
]
feat_common_core = [
  "arch",
  "base32",
  ...
 ]

3.2. 主项目对平台的区分

[features]
default = ["unix"]

## OS feature shortcodes
unix = ["feat_os_unix"]
windows = ["feat_os_windows"]

feat_os_unix = [
  "feat_common_core",
  "feat_selinux",
  "feat_acl",
  "chcon",
  "chgrp",
... ...
]

# "feat_os_windows" == 可在现代/常见的windows平台上构建/运行的实用工具集
feat_os_windows = [
  "feat_common_core",  
]

3.3. 主项目对功能模块控制

[workspace.dependencies]
arch = { optional = true, package = "ct_arch", path = "src/ct/arch" }
base32 = { optional = true, package = "ct_base32", path = "src/ct/base32" }
base64 = { optional = true, package = "ct_base64", path = "src/ct/base64" }
... ...