taking address of temporary object

Discussion in 'C++' started by V.Subramanian, India, Feb 10, 2012.

  1. The following post is for learning purpose only.
    I am using g++ 3.4.3
    Consider the following program x.cpp

    #include <cstdlib>
    #include <iostream>
    #include <ostream>

    using namespace std;

    class Test {
    public:
    explicit Test(int arg = 0);
    Test& operator+=(const Test& rhs);
    int value() const;
    private:
    int x;
    };

    inline Test::Test(int arg) : x(arg)
    {
    }

    inline Test& Test::eek:perator+=(const Test& rhs)
    {
    x += rhs.value();
    return *this;
    }

    inline int Test::value() const
    {
    return x;
    }

    inline const Test operator+(const Test& lhs,
    const Test& rhs)
    {
    Test temp(lhs);
    return temp += rhs;
    }

    int main()
    {
    Test x(100);
    Test y(200);
    const Test* p = &(x + y);

    int a = 10;
    int b = 20;
    const int* i = &(a + b);

    return EXIT_SUCCESS;
    }

    When I compile this program x.cpp as
    g++ -std=c++98 -pedantic -Wall -Wextra x.cpp
    I get the following warning and error.

    x.cpp: In function `int main()':
    x.cpp:42: warning: taking address of temporary
    x.cpp:46: error: non-lvalue in unary `&'
    x.cpp:42: warning: unused variable 'p'
    x.cpp:46: warning: unused variable 'i'

    Question:
    In the above code, why does the compiler give warning for
    taking the address of temporary-class-object namely
    (x + y) whereas it generates error for taking the address of
    temporary-built-in-object namely (a + b) ? I expected error
    message for taking &(x + y) similar to that of &(a + b).

    Is ithis behaviour specific to g++3.4.3 ? Or the standard
    itself requires so ?

    Please explain.

    Thanks
    V.Subramanian
    V.Subramanian, India, Feb 10, 2012
    #1
    1. Advertising

  2. On 2/10/2012 8:44 AM, V.Subramanian, India wrote:
    > The following post is for learning purpose only.
    > I am using g++ 3.4.3
    > Consider the following program x.cpp
    >
    > #include<cstdlib>
    > #include<iostream>
    > #include<ostream>
    >
    > using namespace std;
    >
    > class Test {
    > public:
    > explicit Test(int arg = 0);
    > Test& operator+=(const Test& rhs);
    > int value() const;
    > private:
    > int x;
    > };
    >
    > inline Test::Test(int arg) : x(arg)
    > {
    > }
    >
    > inline Test& Test::eek:perator+=(const Test& rhs)
    > {
    > x += rhs.value();
    > return *this;
    > }
    >
    > inline int Test::value() const
    > {
    > return x;
    > }
    >
    > inline const Test operator+(const Test& lhs,
    > const Test& rhs)
    > {
    > Test temp(lhs);
    > return temp += rhs;
    > }
    >
    > int main()
    > {
    > Test x(100);
    > Test y(200);
    > const Test* p =&(x + y);
    >
    > int a = 10;
    > int b = 20;
    > const int* i =&(a + b);
    >
    > return EXIT_SUCCESS;
    > }
    >
    > When I compile this program x.cpp as
    > g++ -std=c++98 -pedantic -Wall -Wextra x.cpp
    > I get the following warning and error.
    >
    > x.cpp: In function `int main()':
    > x.cpp:42: warning: taking address of temporary
    > x.cpp:46: error: non-lvalue in unary `&'
    > x.cpp:42: warning: unused variable 'p'
    > x.cpp:46: warning: unused variable 'i'
    >
    > Question:
    > In the above code, why does the compiler give warning for
    > taking the address of temporary-class-object namely
    > (x + y) whereas it generates error for taking the address of
    > temporary-built-in-object namely (a + b) ? I expected error
    > message for taking&(x + y) similar to that of&(a + b).
    >
    > Is ithis behaviour specific to g++3.4.3 ? Or the standard
    > itself requires so ?
    >
    > Please explain.


    I think the answer lies in the fact that a temporary object of a class
    type (especially one that has a c-tor) usually resides in memory anyway
    (and the compiler knows that), so taking its address is not a totally
    impossible operation, whereas a temporary of a built-in type can easily
    reside in the CPU register which does not have an address.

    A class object that has any non-static member functions must have the
    unique "this" pointer when the control is inside that function, which
    means that even a temporary has to reside in memory.

    V
    --
    I do not respond to top-posted replies, please don't ask
    Victor Bazarov, Feb 10, 2012
    #2
    1. Advertising

  3. On 10.02.2012 14:44, V.Subramanian, India wrote:
    > The following post is for learning purpose only.
    > I am using g++ 3.4.3
    > Consider the following program x.cpp
    >
    > #include<cstdlib>
    > #include<iostream>
    > #include<ostream>
    >
    > using namespace std;
    >
    > class Test {
    > public:
    > explicit Test(int arg = 0);
    > Test& operator+=(const Test& rhs);
    > int value() const;
    > private:
    > int x;
    > };
    >
    > inline Test::Test(int arg) : x(arg)
    > {
    > }
    >
    > inline Test& Test::eek:perator+=(const Test& rhs)
    > {
    > x += rhs.value();
    > return *this;
    > }
    >
    > inline int Test::value() const
    > {
    > return x;
    > }
    >
    > inline const Test operator+(const Test& lhs,
    > const Test& rhs)
    > {
    > Test temp(lhs);
    > return temp += rhs;
    > }
    >
    > int main()
    > {
    > Test x(100);
    > Test y(200);
    > const Test* p =&(x + y);
    >
    > int a = 10;
    > int b = 20;
    > const int* i =&(a + b);
    >
    > return EXIT_SUCCESS;
    > }


    Please convert tabs to spaces before posting.


    > When I compile this program x.cpp as
    > g++ -std=c++98 -pedantic -Wall -Wextra x.cpp
    > I get the following warning and error.
    >
    > x.cpp: In function `int main()':
    > x.cpp:42: warning: taking address of temporary
    > x.cpp:46: error: non-lvalue in unary `&'
    > x.cpp:42: warning: unused variable 'p'
    > x.cpp:46: warning: unused variable 'i'


    Hm, it should not compile at all. Lemme test.

    <test>
    [d:\dev\test]
    > g++ -std=c++98 -pedantic -Wall -Wextra foo.cpp

    foo.cpp: In function 'int main()':
    foo.cpp:42:25: error: taking address of temporary [-fpermissive]
    foo.cpp:46:24: error: lvalue required as unary '&' operand
    foo.cpp:42:14: warning: unused variable 'p' [-Wunused-variable]
    foo.cpp:46:13: warning: unused variable 'i' [-Wunused-variable]

    [d:\dev\test]
    > _

    </test>

    Solution: upgrade to more recent version of the compiler.


    >
    > Question:
    > In the above code, why does the compiler give warning for
    > taking the address of temporary-class-object namely
    > (x + y) whereas it generates error for taking the address of
    > temporary-built-in-object namely (a + b) ? I expected error
    > message for taking&(x + y) similar to that of&(a + b).


    I think it must be a very old version of g++ you're using.

    The Holy Standard does not permit using the built-in address operator to
    take the address of a temporary.


    > Is ithis behaviour specific to g++3.4.3 ? Or the standard
    > itself requires so ?


    Specific.


    Cheers & hth.,

    - Alf
    Alf P. Steinbach, Feb 10, 2012
    #3
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Henning Hasemann
    Replies:
    17
    Views:
    1,141
    mangesh
    Jun 30, 2006
  2. Replies:
    0
    Views:
    1,118
  3. Replies:
    3
    Views:
    727
  4. Replies:
    7
    Views:
    3,211
    James Kanze
    Feb 12, 2008
  5. Andy Gibbs
    Replies:
    5
    Views:
    4,042
    Andy Gibbs
    Nov 19, 2008
Loading...

Share This Page