C++ function member return

Question

I am currently learning the basics of C++ and I have found the following code:

#include <iostream>
using namespace std;

class MyClass {
    int x;
public:
    MyClass(int val) : x(val) {}
    int& get() {return x;}
};

int main() {
  MyClass foo (10);
  foo.get() = 15;  
  cout << foo.get() << '\n';

  return 0;  
}

I don't understand why the line foo.get() = 15 works. To me it looks like a get and set at the same time. I guess it works due to the return type being int& and not only int.

Can someone explain to me how it works?

Thanks.

It's analogous to `int* get() { return &x; }` and `*foo.get() = 15;` Note that in this case, you may as well just make the x public. — Neil Kirk, Sep 10 '14 at 20:29
It works because it returns a reference to member variable `x`. That is, an alias of member variable `x`. — 101010, Sep 10 '14 at 20:29
Why? This isn't possible in C#, unless you mean properties which are not the same thing. — paulm, Sep 11 '14 at 11:29

score 5 · Answer 1 · edited May 23 '17 at 12:18

5

Your foo.get is returning a reference to an int (noted int&).

References can be assigned (so they are l-values). Read the wikipage on C++ references, it is explaining better than I have time to. Or read carefully a good C++ programming book, like e.g. Stroustrup's Programming : Principles and Practice Using C++ or a Tour of C++ or The C++ Programming Language (or all of them!)

As Neil Kirk commented, you could nearly see references as a pointer implicitly dereferenced. In other words, and if you are familiar with C, think of int* get() { return &x; } and *foo.get() = 15;

See also this reference vs. pointer question

edited May 23 '17 at 12:18

Community

1
1

answered Sep 10 '14 at 20:29

Basile Starynkevitch

223,805
18
296
547

seeing references as a pointer implicitly dereferenced is as wrong as it is untrue. – 101010 Sep 10 '14 at 20:33
1

I agree that is not exactly true, but if you have a better way to explain it in a few sentences, please try. – Basile Starynkevitch Sep 10 '14 at 20:34
1

90% of the time a reference is just a *const pointer in disguise. – Neil Kirk Sep 10 '14 at 20:37
2

`int *p = NULL; int &r = *p;` (trolling, but informative trolling, as there is no magic non-null protection that people think there can be) – Neil Kirk Sep 10 '14 at 20:42
@NeilKirk: That dereferencing is Undefined Behavior, you lost before you came to initializing the reference. – Deduplicator Sep 10 '14 at 21:06
Learn to accept criticism when you state something that is untrue and misleading. A reference is just an alias for a variable. – 101010 Sep 10 '14 at 21:49
Depending on your definition of variable: `int&i = t[j];` might not fit (since the only C++ variables are `t`, `j` and the defined ref `i`) – Basile Starynkevitch Sep 11 '14 at 00:43

score 2 · Answer 2 · answered Sep 10 '14 at 20:32

2

The line works because the function is returning a reference, that's semantically equivalent to:

  int* get() {return &x;}

and:

  *foo.get() = 15;

answered Sep 10 '14 at 20:32

Paul Evans

27,315
3
37
54

1

@Josh -1, what is your point exactly? Paul is talking about this specific use, not all uses of references ever. – M.M Sep 10 '14 at 20:40
@MattMcNabb thanks. of course the compiler enforces a different set of *rules* on *references* with respect to *pointers*, such as making it *very* difficult to reseat or zero a *reference*, but the topic is deep enough to be well outside the scope of both the OP's question and SO itself. – Paul Evans Sep 10 '14 at 20:56

score 1 · Answer 3 · answered Sep 10 '14 at 20:53

In C++ the return value from function is a variable which it is stored in the stack or the heap, but without a known name to you. so here

int& get() {return x;}

so foo.get() as one group ( foo.get() ) return a variable, in your case this is a by reference variable which mean the return of (foo.get()) is the variable x inside the foo class.

so doing foo.get() = 15 is same as doing foo.x = 15 because its return by reference.

Note : foo.x = 15 will give compiler error because x is private by default, but its very okay to return it as reference to access it.

score 0 · Answer 4 · edited May 23 '17 at 10:28

Code written is perfectly valid. You return non-constant reference to user code. User assigns to it, so your class member variable gets new value.

It seems that you are worrying about preserving encapsulation here. From this perspective, in a form you written it, your getter is not correct. Most times we return either a value or a constant reference:

int get() { return x; }

const int& get() { return x; }

This way user will not be able to mutate member variable returned. Getter is a dumb "return me" function, so, most times, we assume that it shall not mutate internal class state. To be cautious, we also often make getters constant members:

const int& get() const { return x; }

Of course there are exceptions (notably, lazy eveluation). And also, user could cast out constness. But it is another story.

See also: Const-correctness, Mutator_method, The Definitive C++ Book Guide and List ("Best practices" and "Intermediate")

C++ function member return

4 Answers4