C++ C+中基于接口的类强制静态方法+；

我正在创建一个向量类，它可以选择将分配器作为模板参数。为了确保用户定义的分配器与向量一起工作，我提供了一个接口，用于设置给定分配器的最低要求。由于分配器仅用于分配和取消分配，因此它没有成员变量，并且所有方法都是静态的。有没有办法确保任何实现都有一组给定的也是静态的方法？我知道方法不能同时是静态和虚拟的，但我本质上希望从base_分配器派生的任何分配器都有一组方法，并且这些方法都是静态的<总之，<>强>你能处理C++中的<代码>虚拟静态< /代码>矛盾吗？<强> <强> > /p> 这是我当前的代码：

// in namespace mem_core
// Interface for usage of custom allocators with the custom:: namespace containers.
template <typename T>
class base_allocator {
public:
    using T_ptr = T*;
    using T_ref = T&;

    virtual T_ptr address(const T_ref value);

    // memory methods should allocate for amount elements of type T
    virtual void deallocate(T_ptr const ptr, const size_t& count) = 0;
    virtual T_ptr allocate(const size_t& amount) = 0;
};

_MEMORY_CORE_END_ // namespace mem_core }

#undef _MEMORY_CORE_BEGIN_
#undef _MEMORY_CORE_END_

// default allocator CLASS TEMPLATE
template <typename T>
class allocator : public mem_core::base_allocator<T> {
public:

    using value_type = T;
    using T_ptr = T*;
    using T_ref = T&;

    static T_ptr address(T_ref value) noexcept {
        return mem_core::addressof<T>(value);
    }

    static void deallocate(T_ptr const ptr, const size_t& count) {
        mem_core::deallocate<T>(ptr, count);
    }

    static T_ptr allocate(const size_t& amount) {
        return mem_core::allocate<T>(amount);
    }
};

//在名称空间mem\u core中
//用于将自定义分配器与custom:：namespace容器一起使用的接口。
模板
类基类分配器{
公众：
使用T_ptr=T*；
使用T_ref=T&；
虚拟T_ptr地址（常数T_ref值）；
//内存方法应该为T类型的元素分配数量
虚拟无效解除分配（T_ptr const ptr，const size_T&count）=0；
虚拟T_ptr allocate（const size_T&amount）=0；
};
_内存\核心\结束\名称空间内存\核心}
#未定义(未定义)内存(未定义)核心(未定义)开始_
#未定义(未定义)内存(未定义)核心(未定义)端_
//默认分配器类模板
模板
类分配器：公共mem_core:：base_分配器{
公众：
使用值_type=T；
使用T_ptr=T*；
使用T_ref=T&；
静态T_ptr地址（T_ref值）无异常{
返回mem_core:：addressof（value）；
}
静态无效解除分配（T_ptr const ptr、const size_T&count）{
mem_core:：释放（ptr，count）；
}
静态T_ptr分配（常数大小和金额）{
返回mem_core:：分配（金额）；
}
};

这当然有效，但不能保证用户定义的分配器已经使虚拟方法成为静态的，因为这是分配器在vector类中工作的要求。 e、 g.像这样：

template <typename T, typename alloc_type = allocator<T>>
class vector {
public:

    using iterator = vector_iterator<vector<T, alloc_type>>;

    using T_ptr = T*;
    using T_ref = T&;

    using value_type = T;
private:
    T_ptr m_data;
    size_t m_size;
    size_t m_capacity;
public:
    vector() : m_data(nullptr), m_size(0), m_capacity(0) noexcept {};

    vector(const size_t& initial_cap) : m_size(0) {
        m_data = alloc_type::allocate(m_capacity); // Requires static allocate method
        m_capacity = initial_cap;
    }
// rest of vector class ...

模板
类向量{
公众：
使用迭代器=向量迭代器；
使用T_ptr=T*；
使用T_ref=T&；
使用值_type=T；
私人：
T_ptr m_数据；
大小；
容量大小；
公众：
向量（）：m_数据（nullptr），m_大小（0），m_容量（0）noexcept{}；
向量（常量大小和初始大小）：m大小（0）{
m_data=alloc_type:：allocate（m_容量）；//需要静态分配方法
m_容量=初始_上限；
}
//向量类的其余部分。。。

可能需要一个具有定义为静态使用的某些方法的类。下面的示例使用C++20的概念，但只要稍加努力，就可以适应使用纯SFINAE，因为这是这里唯一需要的东西。此示例定义了一个概念

具有静态方法

，需要一个类来实现both“函数”和“函数2”作为静态方法。非静态方法，虚拟或非虚拟，失败：

#include <iostream>
#include <type_traits>

template<typename T> struct is_function : public std::false_type {};

template<typename Ret, typename ...Args>
struct is_function<Ret (*)(Args...)> : public std::true_type {};

struct not_static {

    void function();
    static void function2();
};

struct is_static {
    static void function();
    static void function2();
};

template<typename T>
concept has_static_methods = is_function<decltype(&T::function)>::value &&
    is_function<decltype(&T::function2)>::value;

// Ok's template parameter type must implement both static methods.

template<has_static_methods T> void ok()
{
}

int main()
{
    ok<is_static>();        // OK
    ok<not_static>();       // Error, unsatisfied contsraint.
    return 0;
}

#包括
#包括
模板结构是_函数：public std:：false_type{}；
模板
struct is_function:public std:：true_type{}；
结构不是静态的{
空函数（）；
静态void函数2（）；
};
结构是静态的{
静态空洞函数（）；
静态void函数2（）；
};
模板
概念有静态方法=是函数：：值&&
is_函数：：值；
//Ok的模板参数类型必须实现这两种静态方法。
模板void ok（）
{
}
int main（）
{
ok（）；//ok
ok（）；//错误，未满意的继续。
返回0；
}

通过一点额外的工作，就可以使用特定的签名强制执行静态方法

---

现在，请记住，这并不能真正阻止任何人使用非静态方法定义子类。这需要任何作为参数传递给模板的类来满足此约束。

可能需要使用某些方法定义为静态的类。下面的示例使用C++20的概念，但使用只需做一点工作就可以使用纯SFINAE，因为这是这里唯一需要的东西。此示例定义了一个概念

具有静态方法
，它需要一个类将“function”和“function2”都实现为静态方法。非静态方法，无论是否虚拟，都会失败：

#include <iostream>
#include <type_traits>

template<typename T> struct is_function : public std::false_type {};

template<typename Ret, typename ...Args>
struct is_function<Ret (*)(Args...)> : public std::true_type {};

struct not_static {

    void function();
    static void function2();
};

struct is_static {
    static void function();
    static void function2();
};

template<typename T>
concept has_static_methods = is_function<decltype(&T::function)>::value &&
    is_function<decltype(&T::function2)>::value;

// Ok's template parameter type must implement both static methods.

template<has_static_methods T> void ok()
{
}

int main()
{
    ok<is_static>();        // OK
    ok<not_static>();       // Error, unsatisfied contsraint.
    return 0;
}

#包括
#包括
模板结构是_函数：public std:：false_type{}；
模板
struct is_function:public std:：true_type{}；
结构不是静态的{
空函数（）；
静态void函数2（）；
};
结构是静态的{
静态空洞函数（）；
静态void函数2（）；
};
模板
概念有静态方法=是函数：：值&&
is_函数：：值；
//Ok的模板参数类型必须实现这两种静态方法。
模板void ok（）
{
}
int main（）
{
ok（）；//ok
ok（）；//错误，未满意的继续。
返回0；
}

通过一点额外的工作，就可以使用特定的签名强制执行静态方法

现在，记住这并不能阻止任何人用非静态方法定义一个子类。这需要任何一个类作为参数传递给模板来满足这个约束。
“总之：你能处理C++中的虚拟静态矛盾吗？”不。但是你可以使用静态多态（即模板）。简而言之，你能处理C++中的虚拟静态矛盾吗？“不，但是你可以使用静态多态性（即模板）。。谢谢！这似乎很管用。我忘了提到我正在尝试保持无依赖性，包括STL，但我想实现所需的功能以使一切正常运行是很容易的。再次感谢！谢谢！这似乎很管用。我忘了提到我正在尝试保持无依赖性，包括STL，但我认为它很容易实现所需的功能，让一切工作。再次感谢！