Re: warning taking address of temporary using reference
PGK wrote:
I recently noticed that I could declare a variable of a struct such as
struct A { int *m_p; int m_size; };
using a static initialisation in a global context:
A a = { (int[4]){1,2,3,4}, 4 };
Just wondering, but is this syntax a feature from C++0x or from GCC?
I then wondered, if the A struct is a base class for a class with a
vtable such as the simplified Arr:
struct Arr : public A {
Arr() { }
~Arr() { if (m_bAlloc) delete m_p; }
private:
bool m_bAlloc;
};
I'm not sure where you see a vtable here, I'll just assume that you left out
a virtual destructor or virtual memberfunctions.
...I could similarly statically declare b at global scope (assuming I
don't deliberately invoke the Arr destructor):
Arr &b = *(Arr *)&(A){ (int[4]){1,2,3,4}, 4 };
Here, you definitely invoke undefined behaviour, because you treat an A as
an Arr, which it simply isn't. These have different memory layout, so
chances are that this even breaks in practice. Further, if Arr really has
any virtual functions, this will very surely cause problems in practice.
Don't use C-style casts, these only make it impossible for the compiler to
warn you.
However, if I instead declare something like b, at local scope, I
receive (GCC 4.4.5) the warning "taking address of temporary":
int main(int argc, char * argv[])
{
static Arr &c = *(Arr *)&(A){ (int[4]){1,2,3,4}, 4 };
return 0;
}
I'd say that both the global and local variant are equally wrong. However, I
think you are using a GCC extension, so what it does is actually up to that
compiler. In any case, the equivalent thing exists even in standard C++:
std::string& i = std::string();
Here I get "initialisation of non-const reference from a temporary". I can
continue by forcing the compiler:
std::string& i = *(std::string*)&std::string();
and get the same compiler warning about taking the address of a temporary.
I don't intend to modify these Arr variables, so I would be happy to
use const; however I couldn't find any locations for const which would
silence the error.
The point is that the string (in my case) used to initialise the reference
will be destroyed at the end of the line (with the semicolon), leaving 'i'
a dangling reference. The same problem applies to your code.
If I split the declaration over two lines though,
the warning disappears:
int main(int argc, char * argv[])
{
static A c0 = { (int[4]){1,2,3,4}, 4 };
static Arr &c = *(Arr *)&c0;
return 0;
}
Is it truly better to split over two lines?
As mentioned above, it is not only better, but it actually just works, which
the other variant doesn't, at least not reliably so.
Is it possible to make the declaration on one line?
Yes, sure:
Arr c;
Seriously, stop messing with the C++ type system. The compiler had a reason
not to let your code compile without brute-force casts.
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! ]