C++:存储复制操作不合理或不可能的资源

C++: Storing resources whose copy operation is unreasonable or impossible

本文关键字：不可能 资源 不合理 操作 存储 复制 C++      更新时间：2023-10-16

我想写一个ContentManager类，它为游戏加载和维护不同类型的资产（与XNA的ContentManager相比）。我的头文件如下所示：

class ContentManager
{
public:
  ContentManager(Direct3D& d3d, const std::string& rootDirectory = "Resource");
 ~ContentManager();
  template<typename T>
  const T& Load(const std::string& assetName);
private:
  Direct3D& d3d_;
  std::string rootDirectory_;
  std::map<std::string, Texture> textures_;
};

正如您所看到的，我为每个资产类型都有一个映射（目前仅针对纹理）和一个通用的Load<T>()方法，我为要存储的每个资产类型显式实例化该方法。Load<Texture>()从磁盘读取一个图像文件（如果它还没有在地图中），创建一个新的Texture，将其插入地图并返回

我的Texture类基本上创建并封装了一个原始IDirect3DTexture9，以遵循RAII习惯用法（析构函数在texture_上调用Release()）：

class Texture
{
public:
  Texture();
  Texture(Direct3D& d3d, unsigned int width, unsigned int height, 
    const std::vector<unsigned char>& stream);
  ~Texture();
  IDirect3DTexture9* GetD3DTexture() const { return texture_; }
private:
  IDirect3DTexture9* texture_;
};

在测试我的代码时，我意识到每个纹理都被释放了两次，因为Texture对象的（浅）副本是在某个时候创建的，当然，每个对象都调用了析构函数。

此外，尽管Load<T>()返回了对映射元素的引用，但调用者可以自己进行复制并触发同样的问题。我的想法：

  • 将Texture的复制构造函数设为私有并不是解决方案，因为在创建std::pair以将新元素插入映射时，无论如何都需要复制。

  • 定义一个自定义副本构造函数来创建深度副本似乎根本不合理，因为我需要创建底层Direct3D纹理的副本，而它实际上应该只存在一次。

那么我有什么选择呢？这可以通过使用智能指针来解决吗？映射中应存储哪种类型，Load<T>()应返回哪种类型？

使用C++11，该语言添加了一个名为移动的功能，这正是您遇到的原因。幸运的是，修改代码以使用移动机制非常简单：

class Texture
{
public:
  Texture() noexcept;
  Texture(Direct3D& d3d, unsigned int width, unsigned int height, 
    const std::vector<unsigned char>& stream);
  Texture(Texture&& rhs) noexcept
  : texture_(rhs.texture_) //take the content from rhs
  {rhs.texture_ = nullptr;} //rhs no longer owns the content
  Texture& operator=(Texture&& rhs) noexcept
  {
    Clear(); //erase previous content if any
    texture_ = rhs.texture_; //take the content from rhs
    rhs.texture_ = nullptr; //rhs no longer owns the content
    return *this;
  }
  ~Texture() noexcept {Clear();}
  IDirect3DTexture9* GetD3DTexture() const noexcept { return texture_; }
private:
  void Clear() noexcept; //does nothing if texture_ is nullptr
  IDirect3DTexture9* texture_;
};

这添加了一个"移动构造函数"和一个"移赋值"，它将将内容从一个Texture移动到另一个，这样一次只有一个指向给定的IDirect3DTexture9。编译器应该检测到这两个，并停止生成隐式复制构造函数和复制赋值，这样就不能再复制Texture了，这正是你想要的，因为深度复制IDirect3DTexture9很难，甚至没有意义。纹理类现在被神奇地修复了。

现在，其他班呢？没有变化。std::map<std::string, Texture>足够聪明，可以检测到您的类具有noexcept移动运算符，因此它将自动使用它们而不是副本。它还使map本身可移动但不可复制。由于map是可移动但不可复制的，这自动地使ContentManager可移动但不能复制。仔细想想，移动内容是有道理的，但你不想复制所有这些。所以这些不需要任何改变

现在，由于右值对你来说显然是一个新概念，这里有一个速成课程：

Texture getter(); //returns a temporary Texture
Texture a = getter(); //since the right hand side is a temporary,
                        //the compiler will try to move construct it, and only 
                        //copy construct if it can't be moved.
a = getter(); //since the right hand side is a temporary,
                        //the compiler will try to move assign it, and only 
                        //copy assign if it can't be moved.
void setter1(Texture&); //receives a reference to an outside texture object
setter1(a); //works exactly as it always has
setter1(getter()); //compiler error, reference to temporary
setter1(std::move(a)); //compiler error, passing rreference && instead of lreference &.
void setter2(Texture); //receives a local texture object
setter2(a); //compiler error, no copy constructor
setter1(getter()); //creates the Texture by moving the data from the temporary
setter2(std::move(a)); //The compiler moves the content from a to the function;
                      //the function receives the content previously held by a, and 
                      //a now has no content.  Careful not to read from a after this.
void setter3(Texture&&); //receives a reference to a temporary texture
setter3(a); //compiler error, a is not a temporary
setter3(getter()); //function receives reference to the temporary, all is good
setter3(std::move(a)); //function thinks a is temporary, and will probably remove 
                       //it's content. Careful not to read from a after this.

将构造函数设为私有构造函数
制作一个包含指向对象而不是对象本身的指针的贴图。

最好是为每个对象保留一个引用计数器。因此，我将使用共享指针（std:：map<std:：string，std:：tr1:：shared_ptr<…>>）。

您也可以尝试使用内容管理器来释放对象（即：release（T&object）），并在映射本身中保留一个引用计数器。但最好的是共享指针。。

是的，我建议为此使用智能指针。特别是，您可以使用shared_ptr。根据您的编译器版本或可用的框架，您可能希望使用C++11变体，例如Boost的实现。

答案就在你的指尖：不要使用insert:）

  1. 您忘记了三巨头的规则：如果您编写复制构造函数、复制赋值运算符或析构函数中的任何一个，您很可能应该编写另外两个。在这种情况下，将它们设为私人
  2. 在map中插入元素的方法有很多，insert只是其中之一

纯C++03解决方案：

class Texture
{
public:
  Texture(): texture_(0) {}
  Load(Direct3D& d3d, unsigned int width, unsigned int height, 
       const std::vector<unsigned char>& stream);
  ~Texture();
  IDirect3DTexture9* GetD3DTexture() const { return texture_; }
private:
  IDirect3DTexture9* texture_;
};

template<typename T>
T const& ContentManager::Load(const std::string& assetName) {
    Texture& t = textures_[assetName];
    t.Load(....);
    return ...;
}

现在，您首先将对象放置在映射中（使用其默认构造函数），然后实际填充它。

在C++11中，您还有两种选择：

  • 定义一个能够重新定位对象的移动构造函数
  • 使用emplace并以textures_.emplace(std::piecewise_construct, std::make_tuple(assetName), std::make_tuple(...));中的对的piecewise_construct构造函数为目标
相关文章：