如何隐藏实现帮助程序模板？

Question

假设我在头文件中声明了两个模板函数：

template <typename T> void func1(const T& value);
template <typename T> void func2(const T& value);

并假设这些函数的实现（也在头文件中而不是在源文件中，因为它们是模板）使用一些实现辅助函数，该函数也是模板：

template <typename T> void helper(const T& value) {
    // ...
}

template <typename T> void func1(const T& value) {
    // ...
    helper(value);
}

template <typename T> void func2(const T& value) {
    // ...
    helper(value);
}

在我包含头文件的任何源文件中，辅助函数都将可见。我不希望这样，因为辅助函数只是一个实现细节。有没有办法隐藏辅助功能？

Answer 1

一种常见的方法（例如，在许多 Boost 库中使用）是将帮助程序放在名为 details 的命名空间中，可能在单独的标头中（包含在“public”标头中）。

没有办法阻止它可见和可调用，但这非常清楚地表明它是实现的一部分，而不是接口的一部分。

Answer 2

既定的先例是将此类事物放入专门（即一致）命名的嵌套命名空间中。 Boost 使用命名空间详细信息，Loki 使用私有命名空间。显然，没有什么可以阻止任何人使用这些命名空间的内容，但这两个名称都传达了这样的含义：它们的内容不适合一般消费。

话虽这么说，一个简单的替代方案是将 func1 和 func2 从自由函数模板转换为某个公共类的静态成员函数模板；这样，helper 就可以简单地成为该类的私有成员，对外界不可见：

struct funcs {
    template<typename T>
    static void func1(T const& value) {
        // ...
        helper(value);
    }

    template<typename T>
    static void func2(T const& value) {
        // ...
        helper(value);
    }

private:
    template<typename T>
    static void helper(T const& value) {
        // ...
    }
};

Answer 3

我想到了两个选项：

1. 将所有实现移至 hpp 文件中，该文件包含在 h 文件的底部。
2. 将代码重构为类模板，然后将助手设为私有。

Answer 4

在C++20中，您现在可以使用模块。
为此，您可以创建一个模块 some_module.cppm 保存所有函数并仅标记接口（单个函数或命名空间）使用 export< /code>，同时不公开辅助函数：

// some_module.cppm
export module some_module;

template <typename T> 
void helper(const T& value) {
  // ...
}

export
template <typename T>
void func1(const T& value) {
  // ...
  helper(value);
}

export
template <typename T>
void func2(const T& value) {
  // ...
  helper(value);
}

在上述情况下，仅导出函数 func1 和 func2 并可在 main 内访问。 cpp：

// main.cpp
#include <cstdlib>
import some_module;

int main() {
  func1(1.0);
  func2(2.0);
  return EXIT_SUCCESS;
}

在clang++12 您可以使用以下三个命令编译此代码：

clang++ -std=c++2b -fmodules-ts --precompile some_module.cppm -o some_module.pcm
clang++ -std=c++2b -fmodules-ts -c some_module.pcm -o some_module.o
clang++ -std=c++2b -fmodules-ts -fprebuilt-module-path=. some_module.o main.cpp -o main
./main

Answer 5

由于代码的用户需要查看 func1 函数的完整定义，因此无法隐藏其实现及其辅助函数实现。

但是，如果将实现移至另一个文件，用户将必须面对模板声明：

//templates.h
template< typename T > void f1( T& );

#include <templates_impl.h> // post-inclusion

以及定义：

// templates_impl.h
template< typename T > void f1_helper( T& ) {
}

template< typename T > void f1( T& ) {
   // the function body
}

Answer 6

我会（如前所述）创建一个模板类，将所有函数设为静态，并将辅助函数设为私有。但除此之外，我还建议将构造函数设为私有，如下所示：

template <typename T>
class Foo{
public:
  static void func1(const T& value);
  static void func2(const T& value);
private:
  Foo();
  static void helper(const T& value);
}

当将构造函数设为私有时，编译器将不允许此模板类的实例。所以下面的代码将变得非法：

#include "foo.h"

int main(){
  int number = 0;
  Foo<int>::func1(number); //allowed
  Foo<int>::func2(number); //allowed
  Foo<int>::helper(number); //not allowed, because it's private
  Foo<int> foo_instance; //not allowed, because it's private
}

那么为什么有人想要这个呢？因为您可能永远不希望拥有完全相同的不同实例。当编译器告诉您某个类的构造函数是私有的时，您可以假设没有必要拥有它的不同实例。

Answer 7

我知道你的意思是你想将它隐藏得如此精细，以至于调用者只要不更改你的代码文件就无法找到你的辅助函数。我非常了解这一点，因为我最近也有非常相似的需求。

那么，将辅助函数包装在匿名命名空间中怎么样？这是我最近发现的最优雅的风格：

namespace YourModule
{
namespace
{//Your helper functions}
//Your public functions
}

这种做法有效地从外部隐藏了你的内部功能。我找不到调用者可以访问匿名命名空间中的函数的任何方法。

正如 @user3635700 所回答的，将命名空间转换为充满静态函数的类通常不是一个好习惯，特别是当您有静态变量的模板时，例如：

template <uint8_t TimerCode>
static uint16_t MillisecondsElapsed;

如果此变量出现在类中，则必须初始化它课堂之外的某个地方！但是，您不能这样做，因为它是模板！卧槽！

看来，被一些人诟病的头文件中的匿名命名空间是唯一也是最完美的解决方案，可以满足我们的需求。