Hi all,
I have a quick question regarding binding temporary to const
reference. I wrote a little toy program to test it, but I don't seems
to understand the behaviour. Consider the following code snipplet:
// Data class, also overload operator<<
class Data { ... };
// Holds the data
class DataHolder
{
public:
DataHolder(Data data_): m_data(data_) {} // 1
void dump() const { cout << m_data << "\n"; }
private:
const Data& m_data;
};
Scenerio A)
int main()
{
DataHolder holder( Data(....) );
// this line will dump out some garbage. My understanding is that
// The member variable m_data binds to a temporary copied of Data
// and when the DataHolder constructor completes, the temporary is
// destroyed that, the m_data reference is no longer valid
holder.dump();
return 1;
}
Scenerio B)
int main()
{
Data data( .. );
DataHolder holder( data );
// this line successfully dump the contents of data. I am not sure
why?
// shouldn't it behaves the same Scenerio A?
holder.dump();
return 1;
}
Scenerio C)
Change the DataHolder constructor to the following
DataHolder(Data& data_): m_data(data_) {} or
DataHolder(const Data& data_): m_data(data_) {}
int main()
{
Data data( .. );
DataHolder holder( data );
// this line successfully dump the contents of data. I am not sure
why?
holder.dump();
return 1;
}
Scenerio D)
Now, rather than using Data as a class, we change data to the
following:
enum Data
{
LONG,
FLOAT,
INT
};
When re-running scenerio A - C, the contents of data seems to be
dumping out
correctly. I am not sure why?
Can anyone enlighten me? Your help is appreciated. Thanks!!!!
Kaede
