用原始或智能指针在c ++中组合？

Question

A little example of what I want to do.

I have a list of (stack allocated) vertices

class Vertex {

    int id;
    double x;
    double y;
    double z;
};

and want to create a list of edges

class Edge {

    int id;
    Vertex * source;
    Vertex * target;
};

with two pointers to its source and target vertex.

Normally I would go for a reference here, but I want to be able to change the source or target vertex during runtime, so I need some kind of pointer type.

So my question: is there a smart pointer which would be useful here or should I just use a normal pointer as above?

Edit

Addressing some points, which came up in the answers:

First, the list should own the vertices, which is why they are on the stack.

Second, the ids are for an other program.

It needs a file with a list of all vertices and their coordinates, and a list of all edges and the ids of its two vertices.

Third, I need some kind of pointer, because the ids of the vertices change during runtime and the source and target vertex of a edge could change to.

(amongst other things some kind of cuts and slicing is performed)

Answer 1

What Composition is

---

Composition (in UML terms) is an association when a given object is "a part" of another objects- ie it has the same lifetime and - what's most important and characteristic - does not exist / make sense on its own .

According to this description, composition is not what we want to achieve - see the second part.

In C or C++, the best way to implement composition is without using any pointers:

class Edge {

    int id;
    Vertex source;
    Vertex target;
};

This approach is best in terms of memory usage (one memory block for the whole object along with composite objects) and probably efficiency too. When you need composition - go for this solution.

Why Composition isn't suitable for this problem

---

Composition implies some consequnces:

• The composed objects don't exist on their own,
• Their association with the composite object is permanent during that object's lifetime.

In your data model, you have separate:

• Array of vertices (independent),
• Array of edges.

Both possibly stack-allocated (but that's not really important).

Then you want each edge to refer to N vertices.

The edge does NOT own them - it only does refer to them. So neither composition, nor a smart pointer (which is designed to introduce some kind of ownership association) is not what you want here, because the design says that the vertices are owned by the array of vertices, not by the edges .

So go for a plain pointer.

You could even use array indices instead of pointers as an alternative (which indeed has its uses, eg if you'd want to use the latter array as an index buffer for 3D rendering). All depends on your needs.

Answer 2

Generally speaking, smart pointers are "smart" because they deal with the ownership issues involved. In the above, who do you want to own the vertices?

Answer 3

Use a normal pointer. If the pointed-at objects are allocated on the stack, a smart pointer won't be all that helpful.

If you are concerned in the longer run about safety and bounds checking and so on, order each Vertex by its id (eg, decide 0<=id<n , then you can have an array of size n ), and store the ids in the Edge rather than the pointers. Then you can use an assert , or whatever, to check that ids are in the legal range.

Answer 4

It's a question of who owns the pointers. If your Edge class owns them then you can use an auto_ptr. However, you say that your Vertex objects are allocated on the stack so there's no real need for explicit clean-up in this scenario, as they'll be deleted when they go out of scope.

Answer 5

It's the usual tradeoff: a smart pointer will be safer but slower. Use Boost's shared_ptr if you want to go that way.

For "business logic", I would strongly advocate using smart pointers. But it looks like you may be doing CPU-intensive graphics processing, which is one of the cases where speed may be an important factor. So I suggest:

//typedef Vertex *VertexPtr
typedef shared_ptr<Vertex> VertexPtr

class Edge {
    int id;
    VertexPtr source;
    VertexPtr target;
};

Use this for debugging, and switch the // when everything's working for a speed boost.

NOTE: If there is any possibility that a vertex may point back to an edge that points to it, things get more complicated -- you will need to use weak_ptr for one of the pointers to avoid circular references.