const references? I'm confused.

:(

Well, not really the answer I was hoping for but okay :D Somewhat inefficient to make copies of large objects just to prevent the client from messing with class internals.

Seriously, there must be another way. What do I have all those const modifiers for?!

There shouldn't be any problems initializing a const& with the const& returned from the get call if that's what you're asking. (A long as you don't keep it longer than the lifetime of the variable it references that is...)

Code:

---

class C
{
  int a;
public:
  const int & Get() const { return a; };
};

int main()
{
  C c;
  const int & ref = c.Get();

  std::cout << ref;
  return 0;
}

---

This works just fine...

Quote:

---

This works just fine...

---

And that's what I don't understand. Because:
Get() returns a reference to a temporary copy of C::a instead of C::a itself. Outside Get() that temporary object shouldn't exist any longer and ref would reference an object which is no more.

I'm still missing an explanation for this :)

Not having the almighty standard available, I can't say for sure, but are you absolutely positive that is the case? I can't really see why it should be that way.

Consider this example:

Code:

---

#include <iostream>

class some_class
        {
        public:
                some_class()
                        :
                        a(0)
                        {}

        private:
                int a;
       
        public:
                  const int& get_data() const
                          {
                          return a;
                          }

                  void alter()
                          {
                          a = 100;
                          }
        };

int main()
        {
        some_class object;
        const int & ref = object.get_data();

        object.alter();

        std::cout << ref;

        system("pause");
        return 0;
        }

---

If ref actually referenced a temporary instead of a like you say, this code should print "0". On my compiler it prints "100", which I would persume to be correct.

This is what I've read in the book, maybe I misunderstood that part:

Quote:

---

Consider:
double & dr = 1; // error: l-value needed
const double & cdr = 1; // ok

The Interpretation of this last initialization might be:

double temp = double(1);
const double & cdr = temp;

A temporary created to hold a reference initializer persists until the end of its reference's scope.
References to variables and references to constants are distinguished because the introduction of a temporary in the case of the variable is highly error-prone; an assignment to the variable would become an assignment to the -- soon to disappear -- temporary. No such problem exists for references to constants and references to constants are often important as function arguments. [...]

---

I'm not sure if in the case of returning a const & too will be created a temporary.

Okay... Now I get what you're getting at. :)

If I interpret this correctly, the "reference to a temporary" thing only happens if you assign a constant value to a const reference like that first example you posted. (const double & cdr = 1) That is not what you are doing in your class. You are returning a const& to an actual variable, and therefore no temporaries are needed.

If you on the other hand return the constant value 100 in your class instead of 'a', a temporary would be created and kept alive until all references to it have gone out of scope.

Yes that makes sense. Alright now I know where I'm at, thanks.

Time to upgrade your compiler. Current g++ versions treat the error in your code as an error, not as a warning.

Code:

---

[treuss]src>g++ -o constref constref.cc
constref.cc: In function `int main()':
constref.cc:11: error: invalid initialization of reference of type 'int&' from
  expression of type 'const int'
[treuss]src>g++ --version
g++ (GCC) 3.3.3 (Debian 20040401)
Copyright (C) 2003 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

---