沉默的人e 发表于 2025-5-15 10:41:09

多文件编程

本帖最后由 沉默的人e 于 2025-5-28 10:19 编辑

多文件编程各位, 很久没写东西了. 刚刚发现, Clion 最近支持了非商业免费使用. 于是想发帖广而告之, 但是料想 Clion 并非 Pycharm, 虽然归为同一公司, 但毕竟服务语言不同, Pycharm 服务于 python 直接解释就可以. 但是 Clion 服务于 C/C++ 恐怕不能直接编译, 于是便有了使用 CMake 管理 C/C++ 项目. 搜索了一圈论坛, 并未有关于 CMake 之文. 遂写此贴以期供大家快速上手 CLion 软件.本文的第一部分, 将会详细讲述预备知识, 即多文件编程相关知识. 使用语言以 C 语言为主. 倘若各位对此有所了解, 知道这个命令是干什么的, 为什么要同时编译 a.c 和 b.c, 跳过本文, 直接看 CMake 介绍篇.
static/image/hrline/5.gif
I. 背景先从我们认识的代码开始, 以下代码的工作内容是计算两个整数相加的结果.#include <stdio.h>

// AddInt函数实现
int AddInt(int a, int b) {
    return a + b;
}

// 主函数
int main() {
    int a = 5;
    int b = 3;
    int c = AddInt(a, b);
   
    printf("The sum of %d and %d is %d\n", a, b, c);
    return 0;
}感觉还可以, 但是把一个不是很重要的东西放在前面, 有些喧宾夺主. 所以我们选择调整顺序:
#include <stdio.h>

// AddInt函数声明
int AddInt(int a, int b);
// 主函数
int main() {
   int a = 5;
   int b = 3;
   int c = AddInt(a, b);
   
   printf("The sum of %d and %d is %d\n", a, b, c);
   return 0;
}

// AddInt 函数实现
int AddInt(int a, int b) {
   return a + b;
}
可以了, 对于目前这个只完成一两个小工作的小项目, 如此编写程序完全ok. 下面假设一个场景, 各位要编写的 c 语言程序需要自定义8个函数用来进行运算, 简化为 fa ~ fh 每个函数的工作大致相同, 是分别针对浮点数的四则运算和针对整数的四则运算功能. 现在按照上述方法, 把这些函数裂开, 声明放到开头, 定义放到末尾:
#include <stdio.h>

float fa(float a, float b);
float fb(float a, float b);
float fc(float a, float b);
float fd(float a, float b);
int fe(int a, int b);
int ff(int a, int b);
int fg(int a, int b);
int fh(int a, int b);

int main() {
    printf("浮点运算:\n");
    printf("5.5 + 3.3 = %.2f\n", fa(5.5f, 3.3f));
    printf("5.5 - 3.3 = %.2f\n", fb(5.5f, 3.3f));
    printf("5.5 * 3.3 = %.2f\n", fc(5.5f, 3.3f));
    printf("5.5 / 3.3 = %.2f\n", fd(5.5f, 3.3f));

    printf("\n整数运算:\n");
    printf("5 + 3 = %d\n", fe(5, 3));
    printf("5 - 3 = %d\n", ff(5, 3));
    printf("5 * 3 = %d\n", fg(5, 3));
    printf("5 / 3 = %d\n", fh(5, 3));

    return 0;
}

float fa(float a, float b) {
    return a + b;
}

float fb(float a, float b) {
    return a - b;
}

float fc(float a, float b) {
    return a * b;
}

float fd(float a, float b) {
    return a / b;
}

int fe(int a, int b) {
    return a + b;
}

int ff(int a, int b) {
    return a - b;
}

int fg(int a, int b) {
    return a * b;
}

int fh(int a, int b) {
    return a / b;
}

水温尚可, 但是进一步考虑, 如果再加上其他功能, 让自定义函数数量达到20甚至30个时, 有点吃不消了. 这就是使用多文件编程的原因之一. 另一个原因也很简单, 如果想要完成某个项目, 使用单文件编程会降低工作效率. 无法保证你的工作会被人影响. 所以需要多文件编程, 一是便于项目的工作分配, 而是让项目结构更加符合逻辑. 下面正式介绍多文件编程.II. 头文件 源代码文件对于一个函数, 就用上例中的 fh 来说:int fh(int a, int b) {
   return a / b;
}
通常将 返回值 函数名(参数列表)部分成为函数头, 函数头末尾加了分号, 这个就成为了语句, 叫函数声明语句.这些保存了函数声明, 结构体定义这些通常在变异过程中只要重复出现就会报错的东西等代码的文件, 被称为头文件, 毕竟大多数情况在项目中, 函数要比结构体的数量要多, 遂用函数头的"头"来代替这个文件的称呼. 头文件通常用 ".h" 或者 ".hpp" (多用于 c++) 作为后缀. 取 header file 首个单词 header 的首字母 h. 比如 stdio.h 和 stdlib.h 等, 都属于头文件.而那些正式定义函数的代码, 也会组成另一个文件, 通常文件名上会与对应的头文件相同, 然后后缀是 .c 或 .cpp.
不是所有的头文件都一定要有对应的源代码文件, 不是所有的源代码文件都有对应的头文件, 比如main函数, 很少有人会写main 函数的函数头. main函数也就自然没有必要专门写一个头文件用来一一对应.这样组织代码, 以那10个函数为例, 一个文件就会分裂成3个文件: 存放函数声明的 calc.h 文件, 存放函数定义的 calc.c 文件, 以及调用这些函数的主文件 main.c (个人习惯如此命名, 也有用这个项目的功能命名的, 比如叫 calculator.c 但这样会导致命名混淆, 个人不推荐).
1. main.c# include <stdio.h>
int main() {
    printf("浮点运算:\n");
    printf("5.5 + 3.3 = %.2f\n", fa(5.5f, 3.3f));
    printf("5.5 - 3.3 = %.2f\n", fb(5.5f, 3.3f));
    printf("5.5 * 3.3 = %.2f\n", fc(5.5f, 3.3f));
    printf("5.5 / 3.3 = %.2f\n", fd(5.5f, 3.3f));

    printf("\n整数运算:\n");
    printf("5 + 3 = %d\n", fe(5, 3));
    printf("5 - 3 = %d\n", ff(5, 3));
    printf("5 * 3 = %d\n", fg(5, 3));
    printf("5 / 3 = %d\n", fh(5, 3));

    return 0;
}2. calc.hfloat fa(float a, float b);
float fb(float a, float b);
float fc(float a, float b);
float fd(float a, float b);
int fe(int a, int b);
int ff(int a, int b);
int fg(int a, int b);
int fh(int a, int b);3. calc.cfloat fa(float a, float b) {
    return a + b;
}

float fb(float a, float b) {
    return a - b;
}

float fc(float a, float b) {
    return a * b;
}

float fd(float a, float b) {
    return a / b;
}

int fe(int a, int b) {
    return a + b;
}

int ff(int a, int b) {
    return a - b;
}

int fg(int a, int b) {
    return a * b;
}

int fh(int a, int b) {
    return a / b;
}III 编译 预编译 include接下来的工作, 就是如何编译文件:
首先, gcc 支持多文件编译, 可以使用 gcc a.c b.c main.c 的方式进行编译, 但是编译成果是一个文件, 如果你尝试编译多个含有 main 函数的文件, 想要得到多个二进制的可运行文件, 会报错.其次, 从笔者学习 Qt 编译的教训来看, 推荐把头文件也带着编译进去, 对于本项目, 不编译头文件也可以. 但是对于某些项目, 不编译头文件会报莫名其妙的错误(对, 就是那个Qt).将上述编写的文件内容放入gcc中编译,很开心的, 报了个错:data:image/png;base64,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尽管我们把 .h 文件放进去编译了, 程序依然不认识, 因为在程序中, 没有将 .h 文件和其他文件关联起来.
所以需要使用 include 操作, 将 .h 文件引入到对应的源文件和使用其中函数的程序文件中.
从网上了解, include 操作效果等价于将被引入的文件原封不动copy到当前行中. include 操作的文件对象有两种, 一种是编译器认识的几个文件地址(这个地址可以人为扩充), 从这些地方找到的文件,引入文件名通常用一对尖括号<>包裹; 另外一种, 就是在当前文件夹内的其他文件, 如果没有找到目标, 则会从前者所说的地址中寻找, 这种文件引入时通常用一对双引号""包裹. include 操作并非编译操作, 而是在编译之前就要完成的操作. 所以他不是编译时行为, 而属于预编译行为. 预编译行为的符号各位都见过, 就是 # 符号. 这就解释了如果你在程序中不写 # include <stdio.h> 你连 printf("Hello World!\n"); 都不能运行的原因.在两个 .c 的源代码文件中的开头, 添加如下代码, 应该就可以解决这个报错的问题了.# include "calc.h"IV 惯例化这个程序到目前为止, 明面上, 没有出现任何错误了, 编译器也是这么说的. 但是, 当我们添加一小段代码时, 问题又出现了.
我们通常会把常量也放到头文件中, 因为这种东西, 一般情况都是全项目通用的. 在 C++ 中, 通常使用 const 关键字, 使用常变量的方式定义常量. 当我们将这种方式应用到本文中的例子时, 编译就会报错:所以对于 C 语言, 老老实实的用 # define 的方法进行常量定义. 不要考虑使用常变量.
视角转到 C++, 我用同样的方法写了一套代码, 分别用 calc.h calc.cpp main.cpp 来记录, 编译仍然报错, 但是使用常变量的方法是C++的官方推荐. 这又当做和解?此处介绍两个操作, 用作条件编译行为的预编译操作, 分别是 ifndef if endif 还有一个常见的 define.其中 ifndef xxx 是 if !defined(xxx) 的简化, 二者等效, 可能部分编译器不认识 ifndef 操作, 此处留心一下.
他们在头文件中的组合方式如下:# ifndef CALC_H
# define CALC_H

// your code

# endif
条件编译的这几个语句都比较简单移动, 如果没定义这个常量, 就定义一下, 然后写代码, 第二次被 include 时候, 由于已经被定义了, 其中的// yourc code部分就被忽略了, 达成条件编译效果. 不要思考 CALC_H 的值是什么, 没有意义的, 如果想要深究, 在c++ 里面使用 cout 对象输出一下就知道了.这种操作是所有写多文件编程的人都认可的方案, 所以我称其惯例化. 对于C语言, 我们也这么写, 尽管它不像c++一样能解决变量重复定义的问题, 为了避免其他问题, 至少为了效率提升, 在C语言的头文件中加入 ifndef 的行为也是很有必要的.
现代编译器可能支持一种新的避免重复编译的操作, 叫 # pragma once .它的优点就是避免 ifndef 中常量重名的可能. 但这种操作并没有完全普及, 没有写入到标准中, 所以现在不能替代 ifndef 操作. 某些公司(比如华为)就在规范化文档里面要求禁止使用 pragma once 行为.


本文向大家介绍了多文件编程的背景意义, 函数切分方法, 头文件的惯例书写格式等. 在项目化中, 这些行为会避免很多麻烦. 下一次将介绍 cmake 使用方法. 若本文有任何存在的错误, 还请评论区批评指正, 如果看到, 笔者会及时更改.
本文回帖, 前5位有效, 赠送鱼币50个感谢各位支持.








player-none 发表于 2025-6-1 15:46:18

虽然不喜欢c++但也来支持下(手机版不支持表情)【\(O-O)/】

爱编程的我 发表于 2025-6-1 18:23:58

对初学者很有意义
{:10_248:}

爱编程的我 发表于 2025-6-4 20:24:14

{:10_248:}
页: [1]
查看完整版本: 多文件编程