Is there a solution for it that isn't playing with pointers?
My aim is to have a function that would take an int as a parameter by reference, but when no int is passed, a default int is given, but that default has to be by reference too - i don't know how to achieve it though.
You are asking for the impossible. Consider: no int is passed, so the default int value is used. The function modifies the value of the argument. Effectively, the default int value has changed! This is powerful, as it allows you to make the value of say, 0 become 1 (i.e., the int literal 0 becomes the int literal 1, meaning that 0 == 1 is true).Quote:
My aim is to have a function that would take an int as a parameter by reference, but when no int is passed, a default int is given, but that default has to be by reference too - i don't know how to achieve it though.
Perhaps you actually do not want to modify the argument, thus passing by value or const reference will do?
You can't take a reference of a constant, so if you did "somefunc(4)" with the above declaration (without the default) it would also fail.
The reason to have a reference is that you will be able to modify the passed in variable. Since a constant can't be changed, it's kind of meaningless to pass in a constant as a reference, even if the compiler would allow it.
We may be able to give you an option if you explain further what you actually are trying to achieve with this.
One alternative is of course to declare two functions:
--Code:void somefunc(int &a)
{
// this is called with one integer parameter.
...
}
void somefunc()
{
// This is called when no parameter is given.
...
}
Mats
You can't have a reference to a literal value, therefore having a default argument for a reference doesn't make much sense.
One thing you could do (I don't reccomend doing this because it involves global variables) is make your reference have a default variable to refer to
Or, you could just overload your functions (This is a much better solution)Code:#include <iostream>
int default_arg = 10;
void foo(int& bar = default_arg)
{
std::cout << bar << std::endl;
}
int main()
{
int i = 5;
foo(i);
foo();
}
Code:#include <iostream>
void foo(int& bar)
{
std::cout << bar << std::endl;
}
void foo()
{
std::cout << 10 << std::endl;
}
int main()
{
int i = 5;
foo(i);
foo();
}
actually, it's a bit more complicated, a vector gets passed, but i brought a simple example with int.
when no vector is passed, an empty, default, vector is given and the for cycle(that handles the vector) will not modify anything - since it can be a constant - the for cycle wouldn't mind.
And yes, maybe I am asking the impossible, cause I don't even know what a "literal" means.
A "literal" is a constant value, such as 4, 36, "A string", 'a' or anything else that is always going to result in the same value when compiled.
--
Mats
If you don't want to modify the vector/int, then make it a reference to const.
If you want to modify the vector (or int) then you can't do it (although I think maybe VC++ might allow it as an extension). You'll have to use pointers. But this is an example of where a pointer makes sense. You have an optional argument. So use a pointer defaulted to null, and that will indicate whether the user intended to pass an object for modification.
oh, ok. thanks for explaining.
would this work:
somefunc(int& a = 4 [a not to compiler: I will not change the literal, honestly. Please, don't whine :) ])
It might. It depends on your compiler settings. Some modern compilers have a LISTEN_TO_BEGGING flag that could allow that to work.
Yes, and this is how you do it:Quote:
oh, ok. thanks for explaining.
would this work:
somefunc(int& a = 4 [a not to compiler: I will not change the literal, honestly. Please, don't whine ])
If you are planning to modify the argument, then there must be something wrong with your logic.Code:void sumfunc(const int& a = 4);
You can definitely take a reference of a constant. The reference must be "const" in order to do it.Quote:
Originally Posted by matsp
Code:const int &a = 5;
>> If you are planning to modify the argument, then there must be something wrong with your logic.
It is an optional argument that needs to be modified, but the OP just wants to know if that can be implemented with references. The logic is fine but it just won't work with references.
Write a 2nd function:
Code:void SomeFunc( const vector<blah>& vec )
{
...
}
void SomeFunc()
{
vector<blah> vec;
SomeFunc( vec );
}
I'm not convinced of that; a function that accepts an argument by non-const reference, and modifies an argument that is not passed (should that be allowed) would reasonably be expected to exhibit spurious behaviour.Quote:
Originally Posted by Daved
Well, the global variable isn't a problem. The whole thingy lies in a class and I could make a member which is actually an empty vector(I am actually dealing with vectors instead of ints) and make it a default argument.Quote:
Originally Posted by Bench82
an ingenious solution imho. thanks.
btw, I reverted back to using pointers - it's more straightforward and can support my aims - everything works fine.
thanks to everyone.