C++头文件和源文件有什么区别？一文搞懂.h和.cpp的作用

// math_utils.h
#ifndef math_utils_h  // 头文件保护
#define math_utils_h

#include <cmath>      // 包含标准库头文件

// 常量定义
const double pi = 3.1415926535;

// 函数声明
double calculatecirclearea(double radius);
double calculatedistance(double x1, double y1, double x2, double y2);

// 类声明
class calculator {
private:
    double lastresult;
    
public:
    calculator();
    double add(double a, double b);
    double multiply(double a, double b);
    double getlastresult() const;
};

// 内联函数定义
inline double square(double x) {
    return x * x;
}

#endif // math_utils_h

// math_utils.cpp
#include "math_utils.h"  // 包含对应的头文件
#include <iostream>

// 函数定义
double calculatecirclearea(double radius) {
    return pi * radius * radius;
}

double calculatedistance(double x1, double y1, double x2, double y2) {
    return std::sqrt(square(x2 - x1) + square(y2 - y1));
}

// 类成员函数定义
calculator::calculator() : lastresult(0) {}

double calculator::add(double a, double b) {
    lastresult = a + b;
    return lastresult;
}

double calculator::multiply(double a, double b) {
    lastresult = a * b;
    return lastresult;
}

double calculator::getlastresult() const {
    return lastresult;
}

// 头文件和源文件使用相同的基名
// ✅ 推荐
student.h          // 类 student 的声明
student.cpp        // 类 student 的实现

// ✅ 也可以明确包含类名（文件中只包含一个类时）
class_student.h
class_student.cpp

// ❌ 避免不一致，虽然这样也没错
student.h          // 头文件大写
student.cpp        // 源文件小写 - 不一致！

// large_module.h
class largemodule {
public:
    void featurea();
    void featureb();
    void featurec();
};

// 由于实现太大，拆分成多个源文件：
// large_module_feature_a.cpp
#include "large_module.h"
void largemodule::featurea() { /* 实现a */ }

// large_module_feature_b.cpp  
#include "large_module.h"
void largemodule::featureb() { /* 实现b */ }

// large_module_feature_c.cpp
#include "large_module.h"  
void largemodule::featurec() { /* 实现c */ }

// idatabase.h - 接口
class idatabase {
public:
    virtual void connect() = 0;
    virtual void query(const std::string& sql) = 0;
};

// mysql_database.cpp - mysql实现
#include "idatabase.h"
class mysqldatabase : public idatabase {
    // mysql特定实现
};

// sqlite_database.cpp - sqlite实现  
#include "idatabase.h"
class sqlitedatabase : public idatabase {
    // sqlite特定实现
};

// vector_utils.h - 主要模板
template<typename t>
class vectorutils {
    // 通用实现
};

// vector_utils_specializations.cpp - 特化实现
#include "vector_utils.h"
// 特定类型的特化实现
template<>
class vectorutils<std::string> {
    // 字符串向量的特殊处理
};

project/
├── calculator.h
├── calculator.cpp      // 直接对应
├── utils.h
├── utils.cpp          // 直接对应
└── main.cpp

project/
├── core/
│   ├── logger.h
│   ├── logger.cpp              // 直接对应
│   ├── config.h
│   └── config.cpp              // 直接对应
├── network/
│   ├── http_client.h
│   ├── http_client.cpp         // 直接对应
│   ├── http_request.h
│   ├── http_request.cpp        // 直接对应
│   ├── http_response.h
│   └── http_response.cpp       // 直接对应
└── main.cpp

large_project/
├── core/
│   ├── database/
│   │   ├── idatabase.h                    // 接口
│   │   ├── mysql_database.h              // 实现1头文件
│   │   ├── mysql_database.cpp            // 实现1源文件
│   │   ├── postgresql_database.h         // 实现2头文件
│   │   └── postgresql_database.cpp       // 实现2源文件
│   └── utils/
│       ├── string_utils.h
│       ├── string_utils.cpp              // 主要实现
│       ├── string_utils_unicode.cpp      // 特殊功能实现
│       └── string_utils_performance.cpp  // 优化实现
└── main.cpp

// main.cpp
// 假设我们直接定义所有内容：

// 在多个地方都需要这个函数声明
void log_message(const std::string& message);  // 声明1

int main() {
    log_message("program started");
    return 0;
}

void log_message(const std::string& message) {  // 定义
    std::cout << message << std::endl;
}

// 在另一个函数中又需要声明
void log_message(const std::string& message);  // 声明2 - 重复！
void another_function() {
    log_message("another function");
}

// ✅ 有头文件的情况：

// logger.h - 声明接口
#ifndef logger_h
#define logger_h
#include <string>
void log_message(const std::string& message);
void set_log_level(int level);
#endif

// logger.cpp - 实现细节
#include "logger.h"
#include <iostream>

static int current_log_level = 1;  // 实现细节，对外隐藏

void log_message(const std::string& message) {
    if (current_log_level > 0) {
        std::cout << "[log] " << message << std::endl;
    }
}

void set_log_level(int level) {
    current_log_level = level;
}

// main.cpp - 只关心接口
#include "logger.h"

int main() {
    set_log_level(2);
    log_message("program started");  // 只知道接口，不知道实现
    return 0;
}

// 没有头文件的情况：
// 每次修改实现，所有包含该实现的文件都要重新编译

// 有头文件的情况：
// 修改 logger.cpp → 只需重新编译 logger.cpp
// 修改 logger.h   → 需要重新编译所有包含它的文件

// ❌ 没有头文件的问题：
// file1.cpp
void helper_function();  // 声明
void function_a() {
    helper_function();
}

// file2.cpp  
void helper_function();  // 重复声明！
void function_b() {
    helper_function();
}

// file3.cpp
void helper_function() {  // 实际定义
    // 实现...
}

// ✅ 使用头文件的解决方案：
// helper.h
void helper_function();

// file1.cpp
#include "helper.h"
void function_a() {
    helper_function();  // 统一的声明
}

// file2.cpp
#include "helper.h"  
void function_b() {
    helper_function();  // 统一的声明
}

// helper.cpp
#include "helper.h"
void helper_function() {
    // 实现...
}

// ❌ 没有头文件的类使用问题：
// main.cpp
class student {  // 必须在每个使用的地方都定义类
private:
    std::string name;
    int age;
public:
    student(const std::string& name, int age);
    void display() const;
};

// 如果多个文件需要使用student，每个文件都要重复类定义！

// ✅ 使用头文件的解决方案：
// student.h
class student {
private:
    std::string name;
    int age;
public:
    student(const std::string& name, int age);
    void display() const;
};

// main.cpp
#include "student.h"  // 一次定义，到处使用

// teacher.cpp  
#include "student.h"  // 同样的类定义

// ✅ 小型工具、测试代码、学习示例
// simple_program.cpp
#include <iostream>

// 直接在同一个文件中定义和使用
void helper() { std::cout << "helper\n"; }

int main() {
    helper();
    return 0;
}

// ✅ 模板代码（通常头文件包含实现）
// template_utils.h
template<typename t>
class simplecontainer {
    // 模板实现通常在头文件中
};

// math_operations.h - 清晰的接口契约
#ifndef math_operations_h
#define math_operations_h

// 明确的输入输出说明
double calculate_circle_area(double radius);
int factorial(int n);
bool is_prime(int number);

#endif

// 使用者只需要看头文件就知道如何使用
// 不需要关心复杂的实现细节

// 团队开发场景：
// developer_a 负责接口设计
// math_api.h
class mathapi {
public:
    virtual double compute(const std::string& expression) = 0;
};

// developer_b 负责实现
// math_implementation.cpp  
#include "math_api.h"
class mathimplementation : public mathapi {
public:
    double compute(const std::string& expression) override {
        // 复杂实现...
    }
};

// developer_c 负责使用
// app.cpp
#include "math_api.h"
// 可以基于接口开发，不依赖具体实现

// 作为库开发者，你可以：
// 只提供头文件和编译后的二进制文件
// mylib.h - 头文件（给用户）
class mylib {
public:
    void public_api();
private:
    void* implementation_details;  // 隐藏实现
};

// mylib.cpp - 源文件（不提供给用户）
#include "mylib.h"
void mylib::public_api() {
    // 专利算法，源代码保密
}

// 用户只需要：
#include "mylib.h"  // 和链接你的二进制库

// 1. 重复包含保护
#ifndef my_header_h     // 样板代码
#define my_header_h
// ...
#endif

// 2. 编译依赖
// 修改头文件 → 所有包含它的源文件重新编译

// 3. 可能的循环依赖
// a.h 包含 b.h, b.h 又包含 a.h

// math_utils.ixx - 模块接口文件，注意后缀
export module mathutils;

export double calculate_area(double radius) {
    return 3.14159 * radius * radius;
}

export class calculator {
public:
    double add(double a, double b) { return a + b; }
};

// main.cpp - 使用模块
import mathutils;

int main() {
    calculator calc;
    double result = calc.add(5, 3);
    return 0;
}