dangling references?

Discussion in 'C++' started by Tony Johansson, Apr 6, 2005.

  1. Hello Experts!

    I'm reading in a book about C++ and the book says common errors is
    "A function should not return a constant references to its parameter passed
    by constant references"
    Why?
    Here I have written a method that has exactly this which is the parameter is
    passed by constant references and I return constant references what is it
    that can cause common error by writng in this way.

    main()
    {
    int tal = 9;
    Test t;
    t.foo(tal);
    }

    class Test
    {
    const int& foo(const int& i)
    {
    return i;
    }
    };

    Many thanks
    //Tony
    Tony Johansson, Apr 6, 2005
    #1
    1. Advertising

  2. Tony Johansson

    Jay Nabonne Guest

    On Wed, 06 Apr 2005 20:59:13 +0000, Tony Johansson wrote:

    > Hello Experts!
    >
    > I'm reading in a book about C++ and the book says common errors is
    > "A function should not return a constant references to its parameter passed
    > by constant references"
    > Why?
    > Here I have written a method that has exactly this which is the parameter is
    > passed by constant references and I return constant references what is it
    > that can cause common error by writng in this way.
    >
    > main()
    > {
    > int tal = 9;
    > Test t;
    > t.foo(tal);
    > }
    >
    > class Test
    > {
    > const int& foo(const int& i)
    > {
    > return i;
    > }
    > };
    >
    > Many thanks
    > //Tony


    You can bind a temporary to a const reference. What if you did:

    t.foo(9);

    Here's another example:

    #include <iostream>

    class A
    {
    public:
    A() { i = 3; }
    ~A() { i = 5; }
    int GetI() const { return i; }
    private:
    int i;
    };

    const A& foo(const A& a)
    {
    return a;
    }

    int main()
    {
    const A& a = foo(A());
    std::cout << a.GetI() << std::endl;
    }

    gcc gives "5" (though I suspect we've entered into undefined behavior at
    this point).

    - Jay
    Jay Nabonne, Apr 6, 2005
    #2
    1. Advertising

  3. * Tony Johansson:
    >
    > I'm reading in a book about C++ and the book says common errors is
    > "A function should not return a constant references to its parameter passed
    > by constant references"
    > Why?


    Because the ref-to-const parameter means you can (easily) pass in a temporary,
    e.g. the literal number 42, and that temporary will not exist any longer when
    evaluation of the expression that the function call occurs in is finished.
    Actually it may be destroyed even earlier, as soon as the function returns,
    because §5.2.2/4 says "The lifetime of a parameter ends when the function in
    which it is defined returns". However, §12.2/5 says "A temporary bound to a
    reference parameter in a function call persists until the completion of the
    full expression containing the call." Take your pick.

    Thus, for a temporary as argument, the function result can only be safely
    used inside the expression the function call occurs in. And even there it
    might not be safe to use it. Depending on how you read the Holy Standard.

    Personally I think §12.2/5 is the most specific and therefore applies, and a
    fair amount of code would, I believe, be broken if §5.2.2/4 is the "winner".


    > Here I have written a method that has exactly this which is the parameter is
    > passed by constant references and I return constant references what is it
    > that can cause common error by writng in this way.
    >
    > main()


    'main' must have 'int' result type; this should not compile
    (unfortunately a certain compiler from a large company allows it).


    > {
    > int tal = 9;
    > Test t;


    Class 'Test' is not known at this point.

    This should not compile.

    I don't know any compiler that accepts it.


    > t.foo(tal);


    Any real test would have to use the result.

    However, that only tells you what a specific compiler does.

    It doesn't tell you whether it's behavior mandated by the standard.


    > }
    >
    > class Test
    > {
    > const int& foo(const int& i)
    > {
    > return i;
    > }
    > };


    Hth.

    --
    A: Because it messes up the order in which people normally read text.
    Q: Why is it such a bad thing?
    A: Top-posting.
    Q: What is the most annoying thing on usenet and in e-mail?
    Alf P. Steinbach, Apr 6, 2005
    #3
  4. Tony Johansson wrote:

    > I'm reading in a book about C++


    Could you please cite the book?

    > and the book says that a common error is
    >
    > "A function should not return a constant references
    > to its parameter passed by constant references"


    Can you please cite the passage which contains the above quote?
    Can you tell us the name of the author?

    > Why?


    > Here I have written a method that has exactly this
    > [where] the parameter is passed by constant reference
    > and I return constant a reference.
    > What is it that can cause a common error by writng in this way?



    > cat main.cc

    #include <iostream>

    class Test {
    public:
    const int& foo(const int& i) const {
    return i;
    }
    };

    int main(int argc, char* argv[]) {
    int tal = 9;
    Test t;
    std::cout << "t.foo(" << tal << ") = "
    << t.foo(tal) << std::endl;
    return 0;
    }

    > g++ -Wall -ansi -pedantic -O2 -o main main.cc
    > ./main

    t.foo(9) = 9

    It works just fine for me.

    My guess is that you have misread the author
    and now you are confused.
    E. Robert Tisdale, Apr 6, 2005
    #4
  5. Tony Johansson

    Pete Becker Guest

    Tony Johansson wrote:
    > Hello Experts!
    >
    > I'm reading in a book about C++ and the book says common errors is
    > "A function should not return a constant references to its parameter passed
    > by constant references"
    > Why?


    const int& f(const int& i)
    {
    return i;
    }

    void bogus()
    {
    const int& j = f(int());
    // j is now dangling
    }

    The danger is that if you call f with a temporary, as the code above
    does, it returns a reference to that temporary, which becomes invalid
    when the temporary goes away. That danger doesn't mean you shouldn't do
    it, but that if you do, you have to be sure of how you use it.

    --

    Pete Becker
    Dinkumware, Ltd. (http://www.dinkumware.com)
    Pete Becker, Apr 6, 2005
    #5
  6. Tony Johansson

    msalters Guest

    Alf P. Steinbach wrote:
    > * Tony Johansson:
    > >
    > > I'm reading in a book about C++ and the book says common errors is
    > > "A function should not return a constant references to its

    parameter passed
    > > by constant references"
    > > Why?

    >
    > Because the ref-to-const parameter means you can (easily) pass in a

    temporary,
    > e.g. the literal number 42, and that temporary will not exist any

    longer when
    > evaluation of the expression that the function call occurs in is

    finished.
    > Actually it may be destroyed even earlier, as soon as the function

    returns,
    > because §5.2.2/4 says "The lifetime of a parameter ends when the

    function in
    > which it is defined returns".


    No, 5.2.2/4 talks about the reference parameter and not the object
    to which the reference is bound. Compare:

    void foo() {
    int i = 0;
    {
    int const& ri = i;
    }
    }
    The lifetime of ri ends at the first }, but the lifetime of i ends
    at the second }.
    The fact that the reference is bound to a temporary doesn't matter
    here. The only case in which a temporary is destroyed due to the
    end of the lifetime of a reference is when the temporary would have
    been destoyed earlier in the absence of the reference. I.e.
    references can extend lifetimes but not shorten them.

    Regards,
    Michiel Salters
    msalters, Apr 7, 2005
    #6
  7. * msalters:
    >
    > Alf P. Steinbach wrote:
    > > * Tony Johansson:
    > > >
    > > > I'm reading in a book about C++ and the book says common errors is
    > > > "A function should not return a constant references to its

    > parameter passed
    > > > by constant references"
    > > > Why?

    > >
    > > Because the ref-to-const parameter means you can (easily) pass in a

    > temporary,
    > > e.g. the literal number 42, and that temporary will not exist any

    > longer when
    > > evaluation of the expression that the function call occurs in is

    > finished.
    > > Actually it may be destroyed even earlier, as soon as the function

    > returns,
    > > because =A75.2.2/4 says "The lifetime of a parameter ends when the

    > function in
    > > which it is defined returns".

    >
    > No, 5.2.2/4 talks about the reference parameter and not the object
    > to which the reference is bound. Compare:
    >
    > void foo() {
    > int i =3D 0;
    > {
    > int const& ri =3D i;
    > }
    > }
    > The lifetime of ri ends at the first }, but the lifetime of i ends
    > at the second }.


    On reflection I think you're right.

    Which means my tentative conclusion in the posting the above was a follow-up
    to was right, for the wrong reasons.

    However, I also think the standard is unclear & even misleading here.

    --
    A: Because it messes up the order in which people normally read text.
    Q: Why is it such a bad thing?
    A: Top-posting.
    Q: What is the most annoying thing on usenet and in e-mail?
    Alf P. Steinbach, Apr 7, 2005
    #7
    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. rootz anabo
    Replies:
    0
    Views:
    461
    rootz anabo
    Feb 3, 2005
  2. Hans Van den Eynden

    dangling reference

    Hans Van den Eynden, Oct 16, 2004, in forum: Java
    Replies:
    1
    Views:
    2,858
    Joona I Palaste
    Oct 16, 2004
  3. Richard

    Detecting dangling memory references

    Richard, May 3, 2004, in forum: C Programming
    Replies:
    5
    Views:
    329
    Peter Nilsson
    May 4, 2004
  4. Matthias Kaeppler

    Dangling references?

    Matthias Kaeppler, Oct 10, 2005, in forum: C++
    Replies:
    6
    Views:
    440
  5. Jarek Blakarz
    Replies:
    2
    Views:
    346
    Jarek Blakarz
    Nov 6, 2012
Loading...

Share This Page