how to use reference for lvalue

Hello..
i'd like to make class func that i could use it with lvalue

Code:

---

class foo
{
  int x;
 
  public:
 
    foo();
    void set_x();
}

foo::foo()
{
  x=0;
}

void foo::set_x()
{
  ...
  ... //have no idea what to do
}


int main(){
 foo.set_x()=1;

return 0;
}

---

i know that lvalue has a connection with putting the a value inside an adrs:
int b=0;
int *a=&b
a=1 -> b=1.
but how could i do it with class

p.s.
thnx in advance

Why not just pass an argument?

Code:

---

void foo::set_x(int new_x)
{
    x = new_x;
}

---

guess you want something like this ( I think set_x() is not a good name for a getter function )

Code:

---

class foo {
  int x;
public:
    foo();
    int & get_x();
};

foo::foo(){
  x=0;
}

int & foo::get_x(){
    return x;
}

int main(){
    foo f;
    f.get_x()=1;
    return 0;
}

---

Kurt

That may be a little problematic though, since the getter then cannot be const. I think a straightforward setter is better, if you need getter/setters at all.

Quote:

---

Originally Posted by laserlight

That may be a little problematic though, since the getter then cannot be const. I think a straightforward setter is better, if you need getter/setters at all.

---

I wouldn't call it get OR set. I'd just call it x(), since it could be used either way. blah.x() = 5.

Quote:

---

I wouldn't call it get OR set. I'd just call it x(), since it could be used either way. blah.x() = 5.

---

It would effectively still be a getter that cannot be const, plus "x()" cannot be used as x is already a member variable.

Quote:

---

Originally Posted by laserlight

It would effectively still be a getter that cannot be const, plus "x()" cannot be used as x is already a member variable.

---

I would agree to any name ( maybe get_x_ref() ? ). I just don't like set_x().
Kurt

wow i didn't thout i get so many replies so fast...

so if i undrstand cprrectly when i do :

Code:

---

class foo{
    type varibale;
    ..
    ..
    public:
      type& func();
}

type & func(){
  return varibale;
}

---

what i do is acualy return a refernce (private case of a normal pointer)to the local varibale
so it is actually like :

Code:

---

#include <iostream>

using namespace std;

class foo
{
        int x;
       
        public:
                foo();
                int* value();
                void print();
};

foo::foo()
{
x=1;
}
int*  foo::value()
{
 return &x;
}

void foo::print()
{
        cout<<x<<endl;
}

int main()
{
        foo *a=new foo;
        int *ptr = a->value();
        a->print();
        *ptr=2;
        a->print();

return 0;
}

---

p.s.
if we used the same attitude in c++ like in our life we would call a refernce a fantic pointer (will never change his opnion)
XD

Since a reference cannot be changed to refer to something else (though the value of what it refers to can be changed if it is not a const reference), it is probably closer to:

Code:

---

int* const foo::value()
{
    return &x;
}

---

Nontheless, references are not pointers. You might want to read more on references.

Having a getter return a reference or pointer completely defeats the point in having indirect access in the first place. You can't enforce invariants on setting, you can't hide the data implementation - you might as well make the member public and save yourself the syntactic inconvenience.