7、MPC 工具集开发配置文件顺序思路

约 1707 字大约 6 分钟

2026-03-26

🎯 核心思路：从简单到复杂，从具体到抽象

MPC 配置文件开发应该遵循 自底向上、渐进式构建 的思路，而不是一次性写好所有配置。

📋 一、配置文件开发顺序

阶段 1：单文件项目（验证环境）

目标：验证 MPC 工具可用，熟悉基本语法

# 1. 最简单的项目 - 单个源文件
mkdir -p hello
cd hello

# 创建源文件
cat > hello.cpp << 'EOF'
#include <iostream>
int main() {
    std::cout << "Hello MPC!" << std::endl;
    return 0;
}
EOF

# 2. 创建最简单的 MPC 配置
cat > workspace.mwc << 'EOF'
workspace(Hello) {
    hello.cpp
}
EOF

# 3. 构建
mkdir build && cd build
mwc -type gnuace ../workspace.mwc
make
./hello

阶段目标：✅ 确保 MPC 能工作

阶段 2：添加项目配置（分离源文件）

目标：学习使用 .mpc 文件

# 项目结构
# .
# ├── src/
# │   └── hello.cpp
# ├── hello.mpc          # 项目配置
# └── workspace.mwc      # 工作区配置

# 1. 创建项目配置
cat > hello.mpc << 'EOF'
project(hello) {
    exename = hello
    Source_Files {
        src/hello.cpp
    }
}
EOF

# 2. 创建工作区
cat > workspace.mwc << 'EOF'
workspace(Hello) {
    hello.mpc
}
EOF

阶段目标：✅ 学会使用 .mpc 文件

阶段 3：多项目组织（库 + 可执行文件）

目标：学习项目依赖和链接

# 项目结构
# .
# ├── lib/
# │   ├── mylib.cpp
# │   └── mylib.mpc
# ├── app/
# │   ├── main.cpp
# │   └── app.mpc
# └── workspace.mwc

# 1. 库项目配置
cat > lib/mylib.mpc << 'EOF'
project(mylib) {
    staticname = mylib
    Source_Files {
        mylib.cpp
    }
}
EOF

# 2. 应用项目配置（依赖库）
cat > app/app.mpc << 'EOF'
project(myapp) {
    exename = myapp
    libs += mylib
    Source_Files {
        main.cpp
    }
}
EOF

# 3. 工作区
cat > workspace.mwc << 'EOF'
workspace(MyProject) {
    lib/mylib.mpc
    app/app.mpc
}
EOF

阶段目标：✅ 学会项目依赖管理

阶段 4：提取公共配置（基础项目）

目标：学习使用 .mpb 继承公共配置

# 项目结构
# .
# ├── config/
# │   └── common.mpb      # 公共配置
# ├── lib/
# │   └── mylib.mpc
# └── app/
#     └── app.mpc

# 1. 公共配置
cat > config/common.mpb << 'EOF'
project(common) {
    cxxflags += -std=c++11 -Wall
    includes += include
}
EOF

# 2. 库项目继承公共配置
cat > lib/mylib.mpc << 'EOF'
project(mylib) : common {
    staticname = mylib
    Source_Files { mylib.cpp }
}
EOF

# 3. 工作区添加 include 路径
cat > workspace.mwc << 'EOF'
workspace(MyProject) {
    cmdline += -include config
    lib/mylib.mpc
    app/app.mpc
}
EOF

阶段目标：✅ 学会配置复用

阶段 5：添加特性控制

目标：学习条件编译和特性管理

# 1. 特性文件
cat > features/project.features << 'EOF'
debug=0
ssl=0
EOF

# 2. 项目中使用特性
cat > lib/mylib.mpc << 'EOF'
project(mylib) : common {
    staticname = mylib
    Source_Files { mylib.cpp }
    
    # 根据特性条件编译
    requires += ssl
    macros += USE_SSL
}
EOF

# 3. 工作区
cat > workspace.mwc << 'EOF'
workspace(MyProject) {
    cmdline += -include config
    cmdline += -feature_file features/project.features
    lib/mylib.mpc
    app/app.mpc
}
EOF

阶段目标：✅ 学会特性控制

阶段 6：多平台支持

目标：学习平台特定配置

cat > lib/mylib.mpc << 'EOF'
project(mylib) : common {
    staticname = mylib
    Source_Files { mylib.cpp }
    
    # Windows 特定配置
    specific(prop:microsoft) {
        cxxflags += /EHsc
    }
    
    # Linux 特定配置
    specific(prop:gnu) {
        cxxflags += -fPIC
    }
}
EOF

阶段目标：✅ 学会跨平台配置

📝 二、从 C++ 代码到 MPC 配置的开发流程

步骤 1：分析 C++ 代码结构

// 你的 C++ 项目结构
myproject/
├── include/
│   └── mylib.h          // 公共头文件
├── src/
│   ├── core.cpp         // 核心实现
│   ├── utils.cpp        // 工具函数
│   └── main.cpp         // 主程序

分析要点：

哪些文件是库？哪些是可执行文件？
文件之间的依赖关系？
是否有公共头文件目录？

步骤 2：确定配置策略

代码特征	MPC 配置策略
单个可执行文件	直接列出 `.cpp` 文件
库 + 可执行文件	分离 `.mpc` 文件，用 `libs` 链接
多个项目共享配置	创建 `.mpb` 基础项目
条件编译	创建 `.features` 文件
跨平台	使用 `specific()` 块

步骤 3：编写 MPC 配置（自底向上）

3.1 先写最底层的库配置

# lib/mylib.mpc
project(mylib) {
    staticname = mylib
    Source_Files {
        core.cpp
        utils.cpp
    }
}

3.2 再写应用配置

# app/app.mpc
project(myapp) {
    exename = myapp
    libs += mylib
    Source_Files {
        main.cpp
    }
}

3.3 最后写工作区

# workspace.mwc
workspace(MyProject) {
    lib/mylib.mpc
    app/app.mpc
}

步骤 4：验证和调试

# 1. 先生成 Makefile
cd build
mwc -type gnuace ../workspace.mwc

# 2. 查看生成的规则
make -n

# 3. 编译
make

# 4. 如果失败，检查错误
# 常见错误：头文件路径、库依赖顺序

🎨 三、配置文件模板库

模板 1：最简单的可执行程序

# workspace.mwc
workspace(App) {
    main.cpp
}

模板 2：带头文件的单个程序

# app.mpc
project(app) {
    exename = app
    includes += include
    Source_Files { main.cpp }
}

模板 3：一个库 + 一个程序

# lib/lib.mpc
project(lib) {
    staticname = lib
    includes += include
    Source_Files { lib.cpp }
}

# app/app.mpc
project(app) {
    exename = app
    includes += include
    libs += lib
    Source_Files { main.cpp }
}

# workspace.mwc
workspace(Project) {
    lib/lib.mpc
    app/app.mpc
}

模板 4：多库 + 公共配置

# config/common.mpb
project(common) {
    cxxflags += -std=c++11 -Wall
    includes += include
}

# lib1/lib1.mpc
project(lib1) : common {
    staticname = lib1
    Source_Files { lib1.cpp }
}

# lib2/lib2.mpc
project(lib2) : common {
    staticname = lib2
    libs += lib1
    Source_Files { lib2.cpp }
}

# app/app.mpc
project(app) : common {
    exename = app
    libs += lib1 lib2
    Source_Files { main.cpp }
}

# workspace.mwc
workspace(Project) {
    cmdline += -include config
    lib1/lib1.mpc
    lib2/lib2.mpc
    app/app.mpc
}

🔄 四、配置开发流程图

┌─────────────────────────────────────────────────────────────┐
│                    1. 分析 C++ 代码                          │
├─────────────────────────────────────────────────────────────┤
│  • 识别模块边界                                              │
│  • 确定依赖关系                                              │
│  • 找出公共配置                                              │
└──────────────────────────┬──────────────────────────────────┘
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    2. 确定配置策略                           │
├─────────────────────────────────────────────────────────────┤
│  • 单文件 → 直接列源文件                                     │
│  • 多模块 → 分离 .mpc 文件                                   │
│  • 共享配置 → 创建 .mpb 文件                                 │
└──────────────────────────┬──────────────────────────────────┘
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    3. 编写配置文件（自底向上）                │
├─────────────────────────────────────────────────────────────┤
│  ① 先写底层库 .mpc                                          │
│  ② 再写上层应用 .mpc                                        │
│  ③ 提取公共部分到 .mpb                                      │
│  ④ 创建工作区 .mwc                                          │
└──────────────────────────┬──────────────────────────────────┘
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    4. 验证和调试                             │
├─────────────────────────────────────────────────────────────┤
│  ① 生成 Makefile                                            │
│  ② 测试编译                                                  │
│  ③ 调整头文件路径和库顺序                                    │
└─────────────────────────────────────────────────────────────┘

💡 五、关键原则

原则	说明
渐进式开发	从最简单的配置开始，逐步增加复杂度
自底向上	先写被依赖的库，再写依赖的应用
一次只做一件事	每次只添加一个配置特性
保持简单	能用 3 行配置，不用 30 行
测试每个阶段	每加一个模块就编译测试一次

📝 六、你的 Message Logger 项目配置思路

第 1 步：分析代码结构

你的项目：
├── include/core/logger.h      # 公共头文件
├── include/file/file_logger.h # 公共头文件
├── src/core/logger.cpp         # 核心库实现
├── src/file/file_logger.cpp    # 文件库实现（依赖核心库）
└── src/app/main.cpp            # 主程序（依赖两个库）

第 2 步：确定模块依赖

logger_core (库) ←── logger_file (库) ←── logger_app (可执行)

第 3 步：逐步编写配置

阶段 1：先让核心库能编译

# src/core/logger.mpc
project(logger_core) {
    staticname = logger_core
    Source_Files { logger.cpp }
}

阶段 2：添加文件库（依赖核心库）

# src/file/file_logger.mpc
project(logger_file) {
    staticname = logger_file
    libs += logger_core
    Source_Files { file_logger.cpp }
}

阶段 3：添加主程序

# src/app/logger_app.mpc
project(logger_app) {
    exename = logger
    libs += logger_core logger_file
    Source_Files { main.cpp }
}

阶段 4：创建工作区

# workspace.mwc
workspace(MessageLogger) {
    src/core/logger.mpc
    src/file/file_logger.mpc
    src/app/logger_app.mpc
}

阶段 5：添加头文件路径（可选，MPC 有时会自动处理）

如果编译时找不到头文件，添加公共配置：

# config/common.mpb
project(common) {
    includes += include
}

# 修改每个 .mpc 继承 common
project(logger_core) : common { ... }
project(logger_file) : common { ... }
project(logger_app) : common { ... }

# 工作区添加 include 路径
workspace(MessageLogger) {
    cmdline += -include config
    ...
}

✅ 总结

MPC 配置开发的核心思路：

先运行最简单的配置 → 验证环境
逐步添加模块 → 每次只加一个
先写库，后写应用 → 自底向上
发现问题再完善 → 不要过度设计
保持配置简单 → 能用默认就用默认

记住：MPC 配置是服务于代码的，不是为配置而配置。从你的 C++ 代码结构出发，用最少的配置让项目跑起来，再根据需要逐步完善。

贡献者

codingLab

7、MPC 工具集开发配置文件顺序思路

详情