Re: [eigen] Very interesting read which might be important for us

[Hauke Heibel <hauke.heibel@xxxxxxxxxxxxxx>]

Yeah, this is also mentioned in one of the comments of the article.
The comment starts with

"That’s not the Guru question, the guru question what is the exception
to this rule?"

- Hauke

On Wed, May 19, 2010 at 4:34 PM, Mark Borgerding <mark@xxxxxxxxxxxxxx> wrote:
> Hauke Heibel wrote:
>>
>> Well, at least from a programmers point of view.
>>
>>
>> http://herbsutter.com/2008/01/01/gotw-88-a-candidate-for-the-most-important-const/
>>
>> - Hauke
>>
>>
>
> Interesting.  Unfortunately this const-reference-to-a-temporary seems to be
> limited to immediate stack variables, not stack structures that have
> const-refs inside them.
> I hoped this might allow one to create a lightweight reference that could be
> passed around.  See attached file.
> The tests 3&4 did not behave as I expected.  I think what I was hoping for
> is not possible with automatic variables.   The output from the program
> (linux x86_64, gcc 4.1.2) is:
>
> [markb@hedy ~]$ g++ -Wall -O2 -o test_const_retval test_const_retval.cc &&
> ./test_const_retval
>
> test 1: return by value:
> BigExpensiveObject default constructor
> BigExpensiveObject being used
> BigExpensiveObject destructor
>
> test 2:grab const ref to a temporary
> BigExpensiveObject default constructor
> BigExpensiveObject being used
> BigExpensiveObject destructor
>
> test 3:proxy object created from function returning temporary
> BigExpensiveObject default constructor
> ConstRef constructor
> BigExpensiveObject destructor
> BigExpensiveObject being used
> ConstRef destructor
>
> test 4:proxy object
> BigExpensiveObject default constructor
> ConstRef constructor
> BigExpensiveObject destructor
> BigExpensiveObject being used
> ConstRef destructor
>
>
> #include <iostream>
> using namespace std;
>
> struct BigExpensiveObject
> {
>    BigExpensiveObject(){ cout << "BigExpensiveObject default constructor\n";
> }
>    ~BigExpensiveObject() { cout << "BigExpensiveObject destructor\n"; }
>    BigExpensiveObject(const BigExpensiveObject & other ){ cout <<
> "BigExpensiveObject copy constructor\n"; }
>    void Use() const { cout << "BigExpensiveObject being used\n"; }
> };
>
> struct ConstRef
> {
>    const BigExpensiveObject &  ref;
>    ConstRef( const BigExpensiveObject & beo) : ref(beo) {cout << "ConstRef
> constructor\n";}
>    ConstRef( const ConstRef & other) : ref(other.ref) {cout << "ConstRef
> copy constructor\n";}
>    ~ConstRef() {cout << "ConstRef destructor\n";}
>    operator const BigExpensiveObject &  () const {return ref;}
> };
>
> BigExpensiveObject simple_return_value()
> {
>    BigExpensiveObject beo;
>    return beo;
> }
>
> ConstRef proxy_return_value()
> {
>    BigExpensiveObject beo;
>    return ConstRef(beo);
> }
>
> int main(int argc,char ** argv)
> {
>    cout <<  "\ntest 1: return by value:\n";
>    {
>        BigExpensiveObject beo = simple_return_value();
>        beo.Use();
>    }
>
>    cout << "\ntest 2:grab const ref to a temporary\n";
>    {
>        const BigExpensiveObject & beo = simple_return_value();
>        beo.Use();
>    }
>
>    cout << "\ntest 3:proxy object created from function returning
> temporary\n";
>    {
>        ConstRef p = simple_return_value();
>        // AAARGH! the destructor gets called here, leaving a dangling
> reference
>        p.ref.Use();
>    }
>
>    cout << "\ntest 4:proxy object\n";
>    {
>        ConstRef p = proxy_return_value();
>        // AAARGH! the destructor gets called here, leaving a dangling
> reference
>        p.ref.Use();
>    }
>
>    return 0;
> }