Re: Reference, but object unchanged?
On Oct 27, 7:00 pm, Markus Pitha <newsgroupsNOS...@pithax.net> wrote:
James Kanze wrote:
I think your real problem is more at that level; you're copying
objects which have identity, and shouldn't be copied. (You
might have a lot of lower level problems as well, but until
you've fixed this one, I suspect that it is a waste of time to
talk about them.)
You were right. I just copied the content of the vector. I can solve the
problem when i use vecKnoten.at(kBez) in my method instead of (*k).
In other words, a reference to the value in the array, instead
of a copy of it.
I'm not sure exactly what you're doing, but it still sounds
suspicious to me. Every time I've had to program something
which looked like a graph, my node elements have been
uncopiable, with the copy constructor declared private, and not
implemented. Which, of course, means that I can't have a vector
of the nodes, only pointers to the nodes.
If the vector is being used for some sort of memory management
scheme, it can be made to work. But be very, very careful; some
operations on the vector will invalidate pointers to elements in
the vector. Except in very, very special cases, I'd use a
vector of pointers to the nodes, to avoid such problems. In
fact, I'd only reference the nodes through pointers. (If you
really need to copy nodes at some point, for algorithmic
reasons, you can always add a clone function, which accesses the
private copy constructor. This allows explicit copy, but you
won't accidentally get any implicit copies.)
The algorithm finds the right components now. Ok, some nodes
are still print out twice, but that's some logical problem I
should be able to solve easily.
Probably, but it could also be a curious side effect of an
invalid pointer, due to vector invalidating a pointer or a
reference to a node. (The behavior of using such a pointer or
reference is undefined. Which means that it can sometimes seem
Unless you're a real expert, I think you should start by making
your nodes (Knoten) uncopiable, and go from there. That will
force you to think in terms of identity (objects), and will
prevent any accidental copying. That will also mean that you
need to use vector<Knoten*>, rather than simply vector<Knoten>,
and if the vector is "owner" of the nodes, you'll have to run
through it deleting all of the elements before allowing
destruction of the vector.
More generally, that means that you will have to consider memory
management issues. The simplest solution in your case is
probably to just install the Boehm collector, and use it.
Barring that, if any given node will only be used in a single
graph (no sharing), you can have the nodes belonging to the
Graph object: the only way to create a node in that case should
be through a factory function in the Graph object; that function
new's the node *and* adds it to a list of all nodes
(vector< Knoten* >). The destructor of Graph then delete's all
of the nodes in the list.
James Kanze (GABI Software) email:firstname.lastname@example.org
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34