Thread: 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;
}

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.

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

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.