Re: The Case of the Missing Object
kelvSYC wrote:
I'm having a problem with an object suddenly disappearing on me.
Suppose I have this class
class Foo {
typedef std::map<std::vector<int>, int> LookupTable;
mutable std::map<size_t, LookupTable> tablesForSize;
void evaluate(...) const;
};
void Foo::evaluate(...) {
...
size_t tableKey = ...;
LookupTable table = tablesForSize(tableKey);
....
std::vector<int> innerTableKey = ...;
if (table.count(innerTableKey) == 0) {
table[innerTableKey] = new_unique_value;
}
return table[innerTableKey];
}
A few things here:
- evaluate() has return type void but returns a value.
- Depending on what you really return from evaluate(), you could be in
trouble, because it could be a reference to a member of the local 'table'
object.
- tablesForSize is used like a function, but declared like an object.
- This whole thing contains lots of pseudocode, so it is questionable
if it
is reprentative for the problem you have at all.
In evaluate(), the function is supposed to come up with a size_t
(tableKey) based on its input, then return the corresponding
LookupTable (table) from tablesForSize. This function also comes up
with a vector<int> (innerTableKey) based on its input, and the
function returns the value corresponding to the vector<int> from table
(or if absent, returns a new value; each LookupTable is basically
built up over multiple calls to evaluate()).
Could you simplify the code in order to create an example? This would help
you find the problem yourself.
BTW: Since evaluate() is used to fill the internal table, making that a
const function is basically a lie. I predict this lie will come back at you
sooner or later. I would really consider splitting responsibility between
filling the map and accessing it. Of course, if this only does lazy
evaluation of something, then it can be the right approach. Anyway, this
doesn't belong into example code.
The problem is as follows: suppose that evaluate() is being called
twice in succession (eg. in a loop). In the second evaluate(),
the tableKey that's computed is the same is the one computed from
the first call, and thus the table retrieved is the same table as from
the first evaluate(). However, for some unknown reason, table is now
blank, instead of having the entry created from the previous call to
evaluate()! What happened to the entry, and what should I do to get
it back?
Your function seems to have a local object of type 'LookupTable' named
'table'. Anything you insert into that object only survives until the
function returns, because the object is local. What you want is to insert
into tablesForSize() instead.
Good luck!
Uli
--
Domino Laser GmbH
Gesch??ftsf??hrer: Thorsten F??cking, Amtsgericht Hamburg HR B62 932
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]