我试着查找了一下，使用头文件之类的得到了一些混合的结果。
基本上，我有多个.cpp文件，其中包含我为二叉树、BST、链表等编写的全部函数。
与其每次复制和粘贴需要的函数，我想只需执行：
#include <myBSTFunctions.h>
我希望能够调用并使用自己编写的函数。
要实现这个目标需要哪些步骤呢？需要创建一个包含我使用的所有函数原型的头文件吗？
把定义了真正函数的 .cpp 文件和头文件放在什么地方才最合适呢？
有没有一种方法能够直接调用函数文件所在文件夹的路径呢？也就是说，我更想把它放在与主源代码的 .cpp 文件相同的文件夹中，以便与我的同事分享。
我该如何做到这一点呢？
这是在 Windows 操作系统下使用 MinGW 编译器的方法。
在头文件中声明函数：
// File MyFunctions.h
int myFunction1(int, int);
int myFunction2(int, int);
在文件MyFunctions.cpp中实现它们：
// File MyFunctions.cpp
#include "MyFunctions.h"
int myFunction1(int a, int b){
// Your code
int myFunction2(int a, int b){
// Your code
}
// OtherFile.cpp
#include "MyFunctions.h"
// Now you have access to the functions defined in MyFunctions.h in this file
我不了解MinGW，但它应该看起来像这样：
g++ otherfile.cpp MyFunctions.cpp...
你需要定义一个functionsExample.cpp文件，在其中定义所有函数，并创建一个functionsExample.h文件，在其中声明你的函数。
你将在functionsExample.cpp文件中包含以下内容：
#include "functionsExample.h"
#include <iostream>
int example(int x, int y)
{
return x + y;
}
#ifndef FUNCTIONSEXAMPLE_H
#define FUNCTIONSEXAMPLE_H
int example(int x, int y);
#endif
然后在.cpp文件中，您想运行示例函数。只需添加：
#include "functionsExample.h"
但是如我说的那样，您应该对头文件保护、预处理器指令和文件组织进行一些研究，以深入了解这个问题。以下是一些我推荐的链接:
#include "functionsExample.h"，正如第一个链接建议的那样：“这样可以让编译器在编译时而不是链接时捕获某些类型的错误。” - starriet最简单的方法是使用构建工具。我个人偏好Meson，但CMake 更受欢迎。还有其他的，但这两个都不会错。它们都是跨平台的，支持不同的工具链。这意味着只要你的代码是标准的C++，你就可以在MinGW、Visual Studio、G++或Clang上编译它，而不需要更改任何内容。它们让你从平台上可用的工具链中选择。每个工具都在其网站上有一个快速入门教程。
配置文件由您编写，指定要使用哪些程序源文件以及要构建哪些可执行文件。您在配置步骤中选择使用的构建链，然后可以通过运行Make或Ninja（Meson所需且建议使用CMake）来构建可执行文件。如果更改源代码，只需要重新运行Make或Ninja。当然，只有更改部分才会被重新构建。受到更改影响的可执行文件也将被重新链接。观看一些详细的构建过程可能会有教育意义，以便熟悉您系统上的构建过程。
PS：传统上，在#include中，您使用尖括号（<>）表示系统头文件，使用引号（""）表示自己的头文件。这与首先查找它们的位置有关。
这篇文章旨在为现有答案提供补充，因为它们没有解决一个非常普遍的问题（特别是对于初学者）：如何在单独的源文件中包含带有模板的头文件。
class.hpp：#pragma once // Non-standard but supported by almost (if not) all compilers
// Some class
template<class T> class Class {
T data;
public:
Class();
};
// Some function
template<class T> T square(const T& x);
文件 class.cpp：
#include "class.hpp"
#include <iostream>
template<class T> Class<T>::Class()
{
std::cout << "Class()" << '\n';
}
template<class T> T square(const T& x)
{
return x*x;
}
Class对象，或调用square()函数：#include "class.hpp"
#include <iostream>
int main()
{
Class<int> clss; // should output Class()
std::cout << square<int>(3); // should print 9
}
使用以下命令进行编译：
g++ class.cpp main.cpp -o cpptest.exe
./gcc/bin/ld.exe: main.cpp(.text+0x15): undefined reference to 'Class<int>::Class()'
./gcc/bin/ld.exe: main.cpp(.text+0x28): undefined reference to 'int square<int>(int const&)'
假设你有这个函数：
template<class T> T add(const T& x, const T& y)
{
return x + y;
}
你可以这样调用：
int res = add<int>(2, 3);
在调用时刻（即编译器看到对add()的调用时），编译器会创建函数实现的副本：
int add(const int& x, const int& y)
{
return x + y;
}
然后你的调用将变成：
int res = add(2, 3);
这显然意味着当调用被找到时，模板函数的实现必须对编译器可见，以便编译器能够复制它。而为了让编译器找到/看到它，它必须在同一个翻译单元中。
这就是模板魔法在幕后的工作原理。有关更多信息，请参阅此答案。
通过编译步骤：
#include指令替换为所包含文件的内容。.cpp文件（也称为“翻译单元”）。结果将是每个单元的目标文件。请注意，一些代码（如main.cpp中的代码）引用另一个代码（class.cpp）。这将在下一步中解决。应用上述第1步，我们将有两个翻译单元（.cpp文件）：
文件class.cpp：
template<class T> class Class {
T data;
public:
Class();
};
template<class T> T square(const T& x);
/* <iostream> code ... */
template<class T> Class<T>::Class()
{
std::cout << "Class()" << '\n';
}
template<class T> T square(const T& x)
{
return x*x;
}
文件 main.cpp：
template<class T> class Class {
T data;
public:
Class();
};
template<class T> T square(const T& x);
/* <iostream> code ... */
int main()
{
Class<int> clss;
std::cout << square<int>(3);
}
应用以上步骤2，我们将只有地址（这不是真正的对象代码的外观，这只是一个简化）：
文件 class.cpp:
/* Nothing to generate for 'Class' definition. Remember, templates are just models (hence the word "template"), not concrete classes/functions. */
/* Nothing to generate for square()'s definition: It's a template, not concrete. */
iostream_object_code
/* Nothing to generate for 'Class' implementation. It's a template, not concrete. */
/* Nothing to generate for square()'s implementation: It's a template, not concrete. */
文件 main.cpp:
/* Class is not concrete: nothing is generated. */
/* square() is not concrete: nothing is generated. */
iostream_object_code
int main()
{
class_int_obj_placeholder clss;
__operator_xx(cout_obj_ref, fn100017(3));
}
执行上述步骤3，您将得到undefined reference错误：链接器不知道任何翻译单元中的fn100017()。因为square()是一个模板（或者模型），编译器没有生成任何具体实现。对于Class也是同样的情况。
main.cpp中包含时，两者都将对编译器可见，因为它们在同一个翻译单元中。文件class.hpp：
#pragma once
template<class T> class Class {
T data;
public:
Class();
};
template<class T> T square(const T& x);
#include "class_impl.hpp"
文件 class_impl.hpp：
#include <iostream>
template<class T> Class<T>::Class()
{
std::cout << "Class()" << '\n';
}
template<class T> T square(const T& x)
{
return x*x;
}
使用相同的命令编译并运行main.cpp：
Class()
9
g++ A.cpp B.cpp- user4581301g++ A.cpp ../../source/b/B.cpp的意思是在当前文件夹中查找A.cpp，并向后返回两个文件夹，在source/b中查找B.cpp。请注意，这只是告诉编译器文件的位置，并不会改变文件本身。 - user4581301static关键字在函数声明之前将其链接性限制为内部，也就是说，静态函数不能在其定义之外的文件中使用。 - undefined