在扣除 'auto' 之前使用 'static auto&' 函数

Question

有一个分配器：

template<typename T>
class pool_allocator {
public:
    using value_type = T;
    using pointer = value_type *;

    /* Default constructor */
    constexpr pool_allocator( void ) noexcept = default;

    /* Converting constructor used for rebinding */
    template<typename U>
    constexpr pool_allocator( const pool_allocator<U> & ) noexcept {}

    [[nodiscard]] pointer allocate( size_t n, [[maybe_unused]] const pointer hint = nullptr ) const noexcept {
        return get_pool().allocate( n );
    }

    void deallocate( pointer ptr, size_t n ) const noexcept {
        get_pool().deallocate( ptr, n );
    }

private:
    /* Must be defined in particular .cpp files */
    static auto & get_pool( void ) noexcept;
};

它需要为 .cpp 文件中的特定类型定义 get_pool()。 pool_allocator 在内存池中分配实例。

struct cpu { ... };

要定义池本身 - 实例所在的内存区域可能如下所示：

memory_pool<cpu, 4> cpu_storage;

template<>
auto & pool_allocator<cpu>::get_pool( void ) noexcept {
    return cpu_storage;
}

在尝试使用时：

class process {
    unique_ptr<cpu> m_cpu { nullptr };
};

我面临 GCC 报告的问题：

error: use of 'static auto& ReVolta::pool_allocator<T>::get_pool() [with T = cpu]' before deduction of 'auto'
get_pool().deallocate( ptr, n ); // line of code within the pool_allocator<T>::deallocate(...) implemnetation 

我可以请求帮助吗？

Answer 1

我怀疑您要么在单独的 c++ 文件中定义（即提供其主体）并使用了 get_pool 函数，要么它们在同一个文件中但首先使用。

在第一种情况下，您可能会执行以下操作：

// f.hpp
auto f();

// f.cpp
auto f() { return 42; }

// main.cpp
#include "f.hpp"
int main() { return f(); }

现在像试图编译main.cpp 的编译器一样思考。由于您是 c++ 编译器，you can only see the content of f.hpp and main.cpp。但是你怎么知道f的确切返回类型呢？

在第二种情况下，您可能已经做了类似的事情（在单个 cpp 文件中）：

auto f();

int main() {
    return f();
}

auto f() {
    return 42;
}

当您编写return f(); 时，编译器仍然需要知道42 的返回类型。但它还没有看到定义。但是，如果您颠倒顺序：

auto f();

auto f() {
    return 42;
}

int main() {
    return f();
}

它会编译。

---

无论哪种方式，在模板中声明一个函数但不立即跟上定义（与类定义内联或紧跟在标头中的类定义之后）仍然是非常规的，因为如果您定义cpp 文件中的模板成员，you would not be able to use it in other cpp files。