C ++中指针指针的替代方案？

Question

I find myself at a few places in my game wanting to use pointer-to-pointer in my design. For example, I have a class OpenGLRenderer which creates meshes given vertex/indice/texcoord data, materials given material props, etc. and then a class ResourceManifest which caches meshes/materials from file and upon loading one of these resources creates an instance of it using the OpenGLRenderer . So there is a coupling there.

I typically like to employ RAII design when coding which tempts me to the following relationship:

ResourceManifest(OpenGLRenderer** renderer);

Because when the OpenGL context has been torn down and all OpenGL state-specific stuff needs to be reinitialized, such as when recreating the window, I just recreate the OpenGLRenderer and let the constructor/destructor do all the work and ResourceManifest using it will never be the wiser.

What I am wondering is if this is enough justification of using plain old pointer-to-pointers, are there any more modern tools or techniques available? I've been looking at various smart_ptrs for example, but they do not deal with the problem at hand, as I want to recreate the managed object without passing out new smart_ptrs.

Answer 1

As others have already stated, you could reference a smart pointer.

However, if you also want to provide functionality beyond smart pointerness you could make your code into an iterator especially if the underlying data structures are not homogeneous. Again, this is a matter of how you'll use your pointer to pointer. Then whatever interface you finally use could itself be wrapped in a smart pointer.

Answer 2

What I am wondering is if this is enough justification of using plain old pointer-to-pointers, are there any more modern tools or techniques available? I

In your particular scenario, you could use something like that:

1. There is a class called ResourceLoader which contains std::map<ResourceId, std::weak_ptr<OpenGLResource> > where OpenGL resource is generic clas used by OpenGL resources. ResourceID is whatever you use to identify specific resource (filename, whatever)

2. When you load new resource ResourceLoader checks map for weak_ptr 's converts them to shared_ptr and returns them. If there are no weak_ptr s in map, or if they're NULL, he creates new shared_ptr , pushes its weak_ptr into map, and returns it.

   Semi-c++ peudocode (unchecked, most likely contains typos and syntax errors):

     typedef std::shared_ptr<Resource> ResourcePtr; typedef std::weak_ptr<Resource> ResourceWeakPtr; typedef std::map<ResourceId, ResourceWeakPtr> ResourceMap; class Loader{ public: .... ResourcePtr loadResource(ResourceId id){ ResourceMap::iterator found = resoruceMap.find(id); ResourcePtr result; if ((found == resourceMap.end()) || !(result = found->second.lock())){ result = createResource(id); resourceMap.insert(std::make_pair(id, ResourceWeakPtr(result))); } return result; } void reloadAllResources(){ for (ResourceMap::iterator i = resourceMap.begin(); i != resourceMap.end(); i++){ ResourcePtr cur = i->second.lock(); if (cur) cur->reload(); } } protected: ResourceMap resourceMap; ResourcePtr createResource(ResourceId id){ return ResourcePtr(new Resource()); } }; 

3. When you want to realod lost resources, you simply iterate through resourceMap, and call reload on every object that hasn't expired. See reloadAllResources

Answer 3

I am not even sure I fully understand your question, but let me give it a shot: could you use std::weak_ptr ?

Consider the following (contrived) example:

#include<memory>
#include<iostream>

class Renderer {
 public:
  Renderer()
      : m_calls(0) { }
  void render() {
    m_calls++;
    std::cout<<"Issued render call #"<<m_calls<<std::endl;
  }
  void reset() {
    std::cout<<"Reset called"<<std::endl;
    m_calls = 0;
  }
 private:
  size_t m_calls;  
};

class Context {
 public:
  Context(std::shared_ptr<Renderer> prenderer)
      : m_prenderer(prenderer) {
  }
  void build_cache() {
    if(auto renderer = m_prenderer.lock()) {
      renderer->render();
    } else {
      std::cout<<"Handle the case when I don't have a renderer to work with"<<std::endl;
    }
  }  
 private:
  std::weak_ptr<Renderer> m_prenderer;  
};


int main() {
  auto renderer = std::make_shared<Renderer>();
  Context ctx(renderer);
  ctx.build_cache();
  ctx.build_cache();
  std::cout<<"Here I reset the renderer"<<std::endl;
  renderer->reset();
  ctx.build_cache();

}

Compiled as: g++ example.cpp -std=c++11 (gcc 4.7.2). Output:

Issued render call #1
Issued render call #2
Here I reset the renderer
Reset called
Issued render call #1

The purpose of std::weak_ptr is to share a pointer without sharing ownership. So you could reset or completely recreate your Renderer , and it would be immaterial to Context . Also, dereferencing to a null pointer has well-defined behavior.