Re: How to detect const reference to temporary issues at compile
or runtime?
On 11/30/2010 8:56 PM, Clinton Mead wrote:
I've found recently that most of the errors in my C++ programs are of
a form like the following example:
#include<iostream>
class Z
{
public:
Z(int n) : n(n) {}
int n;
};
class Y
{
public:
Y(const Z& z) : z(z) {}
const Z& z;
};
class X
{
public:
X(const Y& y) : y(y) {}
Y y;
};
class Big
{
public:
Big()
{
for (int i = 0; i< 1000; ++i) { a[i] = i + 1000; }
}
int a[1000];
};
X get_x() { return X(Y(Z(123))); }
int main()
{
X x = get_x();
Big b;
std::cout<< x.y.z.n<< std::endl;
}
OUTPUT: 1000
I would expect this program to output 123 (the value of x.y.z.n set in
get_x()) but the creation of "Big b" overwrites the temporary Z. As a
result, the reference to the temporary Z in the object Y is now
overwritten with Big b, and hence the output is not what I would
expect.
Simply put, your program has undefined behavior. You initialize the
data member of your 'Y' with a reference to a temporary. For a very
brief moment that reference is valid, then the temporary gets destroyed
and the reference becomes invalid. Any attempt to use it has undefined
behavior as the result.
When I compiled this program with gcc 4.5 with the option "-Wall", it
gave no warning.
The compilers aren't *that* sophisticated. I don't know of any that
would exist that could determine the problem.
The fix is obviously to remove the reference from the member Z in the
class Y. However, often class Y is part of a library which I have not
developed (boost::fusion most recently), and in addition the situation
is much more complicated than this example I've given.
This there some sort of option to gcc, or any additional software that
would allow me to detect such issues preferably at compile time, but
even runtime would be better than nothing?
Why don't you ask in the gcc newsgroup, 'gnu.gcc.help' or in the g++
newsgroup, 'gnu.g++.help'? But don't hold your breath.
You could try C++-lint, of course. They might be just smart enough to
warn you about having a ref to const object as a member...
Problems like the one you showed are similar to
struct A { int a; A(int a_) : a(a_) {} };
struct B { A* pA; B(A* p) : pA(p) {} };
int fubar() {
A* pA = new A(666);
B b(pA);
delete pA;
return b.pA->a; // hope it returns 666
}
.. This one is actually worse because it might even work the first
couple of years. Then your code mutates to the point there is something
else added to the 'fubar' function, after which it stops working, and by
that time the original programmer has moved on, and nobody wants to look
for bugs in the "legacy" code, etc.
Rule: don't store pointers or references to any external objects unless
you are *sure* they don't disappear on you. IOW, control your objects'
ownership carefully.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask