提升智能指针设计问题

Question

This is my first time experiencing smart pointers in c++ and i have some understanding issues. I want to design some kind of a Component Based OpenGL framework.

So I have a Scene class which creates Nodes ( and stores the for itself ) and return it as a shared_ptr. Node class has a list of Components which are created in Node class and again returned as a shared_ptr BUT these Components also need a reference to their owner (Node) and the Node itself should pass its pointer to its Components.

Now: the pointer to the Node in its components, what should it be? a shared_ptr or a weak_ptr. and how to pass that wthitin the Node itself ( Node has no reference to its shared_ptr which is stored in the Scene )

//! EDIT 1

class Scene
{
vector<shared_ptr<Node>>  nodes;
public:
weak_ptr<Node>  NewNode();
}

class Node
{
vector<shared_ptr<Component>> components;
public:
weak_ptr<Component> AddComponent();
weak_ptr<Component> GetComponent(String classname);
vecotr<weak_ptr<Component>> GetComponents(String classname);
}

class Component
{
weak_ptr<Node> owner;
Component(weak_ptr<Node> owner_refernce);
public:
// component stuff
weak_ptr<Node> GetOwner();
friend class Node;
}

Please help me to make the best design here.

// EDIT1 : to be more clear!

Scene is the only OWNER of a Node. It creates and destroys them. Each Node OWNS all of its Components. It creates and destroys them. And the Components need a reference to their Owners which they will share with other objects ( by returning the owner in Get method ).

-> Scene owns Nodes and Nodes own Component.

-> Scene shares Nodes ( return Node object by name )

-> Node shared all its Components ( return Component by classname )

-> Components share their owner ( return owner reference )

How can i share Objects without sharing the ownership? weak_ptr ??

EDIT 2: It seems smart pointers are no use in this case. so I am going with row pointers for now

Answer 1

From your description, it sounds like Node instances have a clear owner ( Scene ). If so, shared_ptr isn't necessarily the best solution; std::unique_ptr , or even raw pointers (with the necessary deletes in ~Scene ) would probably be more appropriate. Or perhaps Boost's pointer vector. The same considerations apply to Component and Node . And the parent pointers in Component look like they're strictly for navigation, so raw pointers would be the most appropriate.