Default value to a parameter while passing by reference in C++
Solution 1
You can do it for a const reference, but not for a non-const one. This is because C++ does not allow a temporary (the default value in this case) to be bound to non-const reference.
One way round this would be to use an actual instance as the default:
static int AVAL = 1;
void f( int & x = AVAL ) {
// stuff
}
int main() {
f(); // equivalent to f(AVAL);
}
but this is of very limited practical use.
Solution 2
It has been said in one of the direct comments to your answer already, but just to state it officially. What you want to use is an overload:
virtual const ULONG Write(ULONG &State, bool sequence);
inline const ULONG Write()
{
ULONG state;
bool sequence = true;
Write (state, sequence);
}
Using function overloads also have additional benefits. Firstly you can default any argument you wish:
class A {};
class B {};
class C {};
void foo (A const &, B const &, C const &);
void foo (B const &, C const &); // A defaulted
void foo (A const &, C const &); // B defaulted
void foo (C const &); // A & B defaulted etc...
It is also possible to redefine default arguments to virtual functions in derived class, which overloading avoids:
class Base {
public:
virtual void f1 (int i = 0); // default '0'
virtual void f2 (int);
inline void f2 () {
f2(0); // equivalent to default of '0'
}
};
class Derived : public Base{
public:
virtual void f1 (int i = 10); // default '10'
using Base::f2;
virtual void f2 (int);
};
void bar ()
{
Derived d;
Base & b (d);
d.f1 (); // '10' used
b.f1 (); // '0' used
d.f2 (); // f1(int) called with '0'
b.f2 (); // f1(int) called with '0
}
There is only one situation where a default really needs to be used, and that is on a constructor. It is not possible to call one constructor from another, and so this technique does not work in that case.
Solution 3
There still is the old C way of providing optional arguments: a pointer that can be NULL when not present:
void write( int *optional = 0 ) {
if (optional) *optional = 5;
}
Solution 4
This little template will help you:
template<typename T> class ByRef {
public:
ByRef() {
}
ByRef(const T value) : mValue(value) {
}
operator T&() const {
return((T&)mValue);
}
private:
T mValue;
};
Then you'll be able to:
virtual const ULONG Write(ULONG &State = ByRef<ULONG>(0), bool sequence = true);
Solution 5
There are two reasons to pass an argument by reference: (1) for performance (in which case you want to pass by const reference) and (2) because you need the ability to change the value of the argument inside the function.
I highly doubt that passing an unsigned long on modern architectures is slowing you down too much. So I'm assuming that you're intending to change the value of State
inside the method. The compiler is complaining because the constant 0
cannot be changed, as it's an rvalue ("non-lvalue" in the error message) and unchangeable (const
in the error message).
Simply put, you want a method that can change the argument passed, but by default you want to pass an argument that can't change.
To put it another way, non-const
references have to refer to actual variables. The default value in the function signature (0
) is not a real variable. You're running into the same problem as:
struct Foo {
virtual ULONG Write(ULONG& State, bool sequence = true);
};
Foo f;
ULONG s = 5;
f.Write(s); // perfectly OK, because s is a real variable
f.Write(0); // compiler error, 0 is not a real variable
// if the value of 0 were changed in the function,
// I would have no way to refer to the new value
If you don't actually intend to change State
inside the method you can simply change it to a const ULONG&
. But you're not going to get a big performance benefit from that, so I would recommend changing it to a non-reference ULONG
. I notice that you are already returning a ULONG
, and I have a sneaky suspicion that its value is the value of State
after any needed modifications. In which case I would simply declare the method as so:
// returns value of State
virtual ULONG Write(ULONG State = 0, bool sequence = true);
Of course, I'm not quite sure what you're writing or to where. But that's another question for another time.
Comments
-
Drew Noakes over 3 years
Is it possible to give a default value to a parameter of a function while we are passing the parameter by reference. in C++
For example, when I try to declare a function like:
virtual const ULONG Write(ULONG &State = 0, bool sequence = true);
When I do this it gives an error:
error C2440: 'default argument' : cannot convert from 'const int' to 'unsigned long &' A reference that is not to 'const' cannot be bound to a non-lvalue
-
jamil ahmed almost 15 yearsDon't do this. Google style guide (and others) ban non-const pass by reference and they ban default values, both for good reasons. Here you've got the double whammy.
-
ilya n. almost 15 years@jeffamaphone: why ban default values?
-
Admin almost 15 yearsMercifully, we are not bound by the Google style guide.
-
Admin almost 15 yearsi have a huge code base that uses the function Write. Most of the function calls in the existing code calls Write() without any parameter. So the only option is to make the new parameter with a default value. But the new functionality i need to add is to pass State by reference to Write() which would change the value of state which would be hence visible outside of the function. What's the solution to this?
-
Johannes Schaub - litb almost 15 years"Don't do this. Google style guide (and others) ban non-const pass by reference" i think style guides are known to contain many subjective parts. This looks like one of them.
-
Johannes Schaub - litb almost 15 years
WxWidgets style guide says "don't use templates" and they have good reasons
<- screw std::vector, i say -
ilya n. almost 15 years@sony: create a new function, WriteState.
-
Victor almost 15 yearsThis is what function overloading was for. Though that method is definately a better way.
-
Johannes Schaub - litb almost 15 yearsalso, what does it return, and what is going to get into the out-argument? you may aswell return a struct with both long values combined, and then remove the reference parameter, which clearly is the evil thing in this part.
-
rlbond almost 15 years@jeffamaphone: Google Style Guide also says not to use streams. Will you suggest avoiding them too?
-
Luis Vito almost 15 yearsI don't think the GSG is right about non-const references, but the advice to avoid default parameters is sound. The code which uses default parameters is usually not easy to read, because callMe(5) may in reality supply a bunch of values to the underlying algorithms which you have no knowledge about when you look at the client code, but which are relevant to you (so encapsulation principle does not apply here).
-
Max Lybbert almost 15 yearsI have no problem using the default arguments with STL containers and std::string. Would anybody care to convince me otherwise?
-
Luis Vito almost 15 yearsThis is different. STL has a well-known, well-defined interface. Once you start using default parameters in your in-house code, it creeps all over the place. You get monstrosities like price(a) calling price(a, 0) calling price(a, 0, false) calling price (a, 0, false, null) etc.
-
Max Lybbert almost 15 yearsI've only seen the price(a) monstrosity in Java-style overloading meant to imitate default parameters.
-
David Rodríguez - dribeas over 14 yearsA hammer is a horrible tool to place a screwdriver, but it is quite usable with nails. The fact that you can misuse a feature should only warn you about possible pitfalls but not prohibit its use.
-
Mr. Boy over 14 yearsOoh, Google says do X. So what?
-
Jim Balter over 6 yearsThe restriction in the google style guide, whether it has good reasons or not, has nothing at all to do with this question and the reason that non-lvalues cannot be bound to refs.
-
Jim Balter over 6 years" the only option is to make the new parameter with a default value" -- um, no, that isn't the only option, certainly not with a ref parameter.
-
-
Admin almost 15 yearsif i make it const, will it allow me to pass a different address to the function? or will the address of State be always 0 and so meaningless?
-
Admin almost 15 yearsIf you are using references, you are not passing addresses.
-
Johannes Schaub - litb almost 15 yearsboost::array to the rescue void f(int &x = boost::array<int,1>()[0]) { .. } :)
-
Admin almost 15 yearsDefault values are not "evaluated as constants".
-
Admin almost 15 yearsif not addresses what's actually getting passed?
-
Admin almost 15 years@Sony A reference. It is wriong to think of it as an address. If you want an address, use a pointer.
-
Admin almost 15 yearsso in that case, If i do as below, will that work? void f( int * x = 0 ) { // stuff }
-
Admin almost 15 yearsWell, that passes a NULL pointer. I think you need to edit your original question to explain better what you are trying to do.
-
David Thornley almost 15 yearsThe traditional FORTRAN way would have been to change the value of 0, but that doesn't happen in C++.
-
Richard Corden almost 15 yearsIMHO, this style is quite "smelly". The only time a default argument is ever really justifiable is when it's used in a constructor. In every other case function overloads provide exactly the same semantics without any of the other problems associated with defaults.
-
Mr. Boy over 14 yearsSome people think a default-param is less horrible than a giant multiplication of overloads.
-
Pietro almost 13 yearsMaybe at the end, you ment:
d.f2(); // f2(int) called with '0' b.f2(); // f2(int) called with '0'
-
JustSomeGuy almost 12 yearsDereferencing a NULL pointer is illegal. This may work in some cases, but it's illegal. Read more here parashift.com/c++-faq-lite/references.html#faq-8.7
-
Andrew Cheong over 9 yearsWhere does the instantiation of
ByRef
live, memory-wise? Isn't it a temporary object that would get destroyed upon leaving some scope (like the constructor)? -
Mike Weir over 9 years@AndrewCheong Its entire intent is to be constructed in-spot and destructed when the line is complete. It's a means of exposing a reference for the duration of a call so that a default parameter can be provided even when it expects a reference. This code is used in an active project and functions as expected.
-
Claudiu over 9 yearsI found it useful to overload a function which might return multiple values, but the caller might not care for some of them. The caller can simply not specify them instead of having to create a local var
-
Fred Schoen over 8 yearsOn the last statement: from C++ 11 onwards, you can use delegating constructors to call one constructor from the other to avoid code duplication.
-
parasrish about 8 yearsIt works. Basically, it is to access the value-at-reference for checking the NULL pointing reference (logically there is no NULL-reference, only that what you point is NULL). Atop, if you are using some library, which operates on "references", then there will generally be some APIs like "isNull()" for doing the same for the library specific reference variables. And is suggested to use those APIs in such cases.
-
uLoop about 7 yearsI really like this method, very short and simple. Super practical if sometimes you want to return some additional info, statistics, etc. that you usually dont need.
-
Janus Troelsen almost 7 years@JohannesSchaub-litb is there a C++17 solution for this?
-
Jim Balter over 6 yearsIt's pointless and even ridiculous to pass a long as a const ref, and doesn't achieve what the OP wants.
-
stu over 4 yearsI think all he's saying is that internally, a reference is implemented effectively by a pointer.