自己实现一个删除器，让删除器成为你类的朋友。 然后像这样编辑你的声明：

static std::unique_ptr<GLSLShader, your_deleter> create();

这是一个上下文挑战。

你正在解决错误的问题。

GLuint id，将调用对象的构造和glCreateShader()glDeleteShader()

在此处解决问题。

零法则是让资源包装器管理生存期，而不是在业务逻辑类型中这样做。我们可以围绕一个包装器编写一个包装器，它知道如何清理自己并且是仅移动的，通过劫持来存储一个整数而不是指针，从而防止双重破坏。GLuintstd::unique_ptr

来吧：

// "pointers" in unique ptrs must be comparable to nullptr.
// So, let us make an integer qualify:
template<class Int>
struct nullable{
  Int val=0;
  nullable()=default;
  nullable(Int v):val(v){}
  friend bool operator==(std::nullptr_t, nullable const& self){return !static_cast<bool>(self);}
  friend bool operator!=(std::nullptr_t, nullable const& self){return static_cast<bool>(self);}
  friend bool operator==(nullable const& self, std::nullptr_t){return !static_cast<bool>(self);}
  friend bool operator!=(nullable const& self, std::nullptr_t){return static_cast<bool>(self);}
  operator Int()const{return val;}
};

// This both statelessly stores the deleter, and
// tells the unique ptr to use a nullable<Int> instead of an Int*:
template<class Int, void(*deleter)(Int)>
struct IntDeleter{
  using pointer=nullable<Int>;
  void operator()(pointer p)const{
    deleter(p);
  }
};

// Unique ptr's core functionality is cleanup on destruction
// You can change what it uses for a pointer. 
template<class Int, void(*deleter)(Int)>
using IntResource=std::unique_ptr<Int, IntDeleter<Int,deleter>>;

// Here we statelessly remember how to destroy this particular
// kind of GLuint, and make it an RAII type with move support:
using GLShaderResource=IntResource<GLuint,glDeleteShader>;

现在，该类型知道它是一个着色器，并以非 null 方式清理它。

GLShaderResource id(glCreateShader());
SomeGLFunction(id.get());

对于任何错别字，我们深表歉意。

在你的班级中填充，复制 ctor 被阻止，移动 ctor 做正确的事情，dtor 自动清理，等等。

struct GLSLShader {
  // public!
  ~GLSLShader() = default;
  GLSLShader() { // OpenGL create calls for id };
private: // does this really need to be private?
  GLShaderResource id;
};

简单多了。

std::vector<GLSLShader> v;

这很有效。我们是半常规的（只移动常规类型，没有排序支持），并且对这些感到满意。0 规则意味着拥有它的 ，也是半规则的，并且支持 RAII - 资源分配是初始化 - 这反过来意味着它在存储在容器中时会自行正确清理。GLShaderResourcevectorGLSLShaderstd

“常规”类型意味着它“行为类似于”——类似于原型值类型。C++ 的标准库和大部分 C++ 在使用常规或半常规类型时都喜欢它。int

请注意，这基本上是零开销; 是一样的，堆上什么都没有。我们有一堆编译时类型的机器包装一个简单的 32 位整数;编译时类型机制生成代码，但不会使数据比 32 位更复杂。sizeof(GLShaderResource)GLuint

活生生的例子。

间接费用包括：

1. 某些调用约定使传递包装与传递 .structintint

2. 在销毁时，我们检查其中的每一个，看看它是否是为了决定我们是否要调用;编译器有时可以证明某些东西保证为零并跳过该检查。但它不会告诉你它是否真的做到了。 （OTOH，众所周知，人类不善于证明他们跟踪了所有资源，所以一些运行时检查并不是最糟糕的事情）。0glDeleteShader

3. 如果您正在执行完全未优化的构建，则在调用 OpenGL 函数时会有一些额外的指令。但是在编译器进行任何非零级别的ing之后，它们就会消失。inline

4. 该类型在几个方面（可复制、可销毁、可构造）并不“微不足道”（C++ 标准中的一个术语），这使得在 C++ 标准下做类似的事情是非法的;你不能以一些低级的方式将其视为原始内存。memset

一个问题！

许多 OpenGL 实现都有 / 等的指针，上面依赖于它们是实际的函数，而不是指针或宏或其他任何东西。glDeleteShaderglCreateShader

有两种简单的解决方法。第一种是在上面的参数中添加 a（两个点）。这有一个问题，即它只在它们现在是实际指针时才起作用，而不是当它们是实际函数时才起作用。&deleter

制作在这两种情况下都能正常工作的代码有点棘手，但我认为几乎每个 GL 实现都使用函数指针，所以除非你想做一个“库质量”的实现，否则你应该很好。在这种情况下，您可以编写一些帮助程序类型来创建 constexpr 函数指针，这些指针按名称调用（或不调用）函数指针。

最后，显然一些析构函数需要额外的参数。这是一张草图。

using GLuint=std::uint32_t;

GLuint glCreateShaderImpl() { return 7; }
auto glCreateShader = glCreateShaderImpl;
void glDeleteShaderImpl(GLuint x) { std::cout << x << " deleted\n"; }
auto glDeleteShader = glDeleteShaderImpl;

std::pair<GLuint, GLuint> glCreateTextureWrapper() { return {7,1024}; }

void glDeleteTextureImpl(GLuint x, GLuint size) { std::cout << x << " deleted size [" << size << "]\n"; }
auto glDeleteTexture = glDeleteTextureImpl;

template<class Int>
struct nullable{
  Int val=0;
  nullable()=default;
  nullable(Int v):val(v){}
  nullable(std::nullptr_t){}
  friend bool operator==(std::nullptr_t, nullable const& self){return !static_cast<bool>(self);}
  friend bool operator!=(std::nullptr_t, nullable const& self){return static_cast<bool>(self);}
  friend bool operator==(nullable const& self, std::nullptr_t){return !static_cast<bool>(self);}
  friend bool operator!=(nullable const& self, std::nullptr_t){return static_cast<bool>(self);}
  operator Int()const{return val;}
};

template<class Int, auto& deleter>
struct IntDeleter;

template<class Int, class...Args, void(*&deleter)(Int, Args...)>
struct IntDeleter<Int, deleter>:
  std::tuple<std::decay_t<Args>...>
{
  using base = std::tuple<std::decay_t<Args>...>;
  using base::base;
  using pointer=nullable<Int>;
  void operator()(pointer p)const{
    std::apply([&p](std::decay_t<Args> const&...args)->void{
        deleter(p, args...);
    }, static_cast<base const&>(*this));
  }
};

template<class Int, void(*&deleter)(Int)>
using IntResource=std::unique_ptr<Int, IntDeleter<Int,deleter>>;

using GLShaderResource=IntResource<GLuint,glDeleteShader>;

using GLTextureResource=std::unique_ptr<GLuint,IntDeleter<GLuint, glDeleteTexture>>;

int main() {
    auto res = GLShaderResource(glCreateShader());
    std::cout << res.get() << "\n";
    auto tex = std::make_from_tuple<GLTextureResource>(glCreateTextureWrapper());
    std::cout << tex.get() << "\n";
}