I need to create a Bar object, which has a private object Foo f.
However, the value of Foo object parameter should be passed by the specific method int genValue().
If I initialize f in the constructor scope Bar(){...}, the compiler yell error, something like there is no constructor Foo().
If I construct like this Bar(): f(genValue()), the compiler yells the error:
test.cpp: In constructor ‘Bar::Bar()’:
test.cpp:16:19: error: cannot bind non-const lvalue reference of type ‘int&’ to an rvalue of type ‘int’
Bar(): f(genValue()){
~~~~~~~~^~
test.cpp:7:2: note: initializing argument 1 of ‘Foo::Foo(int&)’
Foo(int &x) {
^~~
Example code:
class Foo {
public:
Foo(int &x) {
this->x = x;
}
private:
int x;
};
class Bar {
public:
Bar(): f(genValue()){
}
private:
Foo f;
int genValue(){
int x;
// do something ...
x = 1;
return x;
}
};
int main() {
Bar bar ();
return 0;
}
How can I fix the problem, if I don’t want to modify Foo class and its argument value should be passed from genValue()? And, I don’t want to use pure pointer (*), but a solution with smart pointer is okay!
1
A non-const reference parameter, such as an int&, can only refer to an “lvalue,” which is a named variable.
auto takes_nonconst_reference = [](int&){};
auto takes_const_reference = [](const int&){};
auto takes_value = [](int){};
auto returns_int = []{return 42;};
int foo = 1;
// OK
takes_nonconst_reference(foo);
takes_const_reference(foo);
takes_const_reference(returns_int());
takes_value(foo);
takes_value(returns_int());
// compilation error, value returned from a function is not a named variable
takes_nonconst_reference(returns_int());
In this particular case, since your class is storing a copy of the constructor parameter, you should pass it by value (int, not int& nor const int&).
8
Don’t pass int&, it can’t be bound to a constant or temporary because those can’t be modified – use const int& instead.
Actually for simple types you should prefer to pass by value instead, and let the optimizer worry about providing the best implementation.