Simple question: How to assign defalut value to bool& ?

[meili100]

The following code is correct and simple

void foo(bool& valid)
{
  valid = true;
  return;
}

void foo2(string& str)
{
  str = "abc";
  return;
}

void main()
{
bool valid;
foo(valid);
string str;
foo2(str);
return;
}

Now what if I want give bool& and string& a default value so that someone can call foo() and foo2() without parameters

void foo(bool& valid = bool(true) )
{
  valid = true;
  return;
}

void foo2(string& str=string(""))
{
  str = "abc";
  return;
}

void main()
{
bool valid;
foo();
foo2();
return;
}

Why it doesn't work?

[carlorfeo]

first:

void main ()

should be

int main ()

one simple solution to your problem may be:
-declare the variables as global (out of main)
-set their value inside main

[Elysia]

Global variables are best avoided.
Now, why would the arguments need to have default parameters anyway since you are going to modify them?
Const arguments may have default values, however.

[tabstop]

I'm not entirely certain you can use default parameters with references. (Normally it would just be

void foo(bool valid = true)

On the other hand, the "right" answer is going to depend on context. If you are expecting to change the value of the parameter inside the function, what does it mean to not give the function a parameter to change?)

[meili100]

Thanks all. I am doing this because I am working on someone else's old code. I need to revise the method foo/foo2 a little to modify a bool/string, but not all callers of this method need that -- and they are in multiple places of the old code that I don't want to change them.

So the solution is to give a default value. If I need to modify a bool/string, I can pass one in. For the previous callers I don't need to revise them

[Elysia]

I'm not entirely certain you can use default parameters with references. (Normally it would just be

void foo(bool valid = true)

On the other hand, the "right" answer is going to depend on context. If you are expecting to change the value of the parameter inside the function, what does it mean to not give the function a parameter to change?)

It is possible with references.

void foo(const string& r = string(""));

So long as it's const it works fine.

Thanks all. I am doing this because I am working on someone else's old code. I need to revise the method foo/foo2 a little to modify a bool/string, but not all callers of this method need that -- and they are in multiple places of the old code that I don't want to change them.

So the hack solution is to give a default value. If I need to modify a bool/string, I can pass one in. For the previous callers I don't need to revise them

The solution I see is to overload the function.

void foo(/*...*/, bool& b)
{
	// Code
	b = true;
}

void foo(/*...*/)
{
	bool b;
	foo(b);
}

That, or use pointers.

[King Mir]

Yeah, non const references can't have a default values. The normal solution is to use a pointer instead. But that's not a quick fix, because you still have to add code to handle the null pointer case.

I suppose you can have a global default, but that's very hackish, and best avoided. Better take a little to fix it the right way now, rather lather on levels of complexity.

[CornedBee]

Elysia's solution ought to work very well. No need for hacks.

[cpjust]

But a const bool& parameter is kind of pointless isn't it?
If the bool doesn't need to be modified, pass it by value instead of reference.
If it does need to be modified and you want a default parameter there are 2 options I can see:

void func( bool*  pB = NULL )
{
    ...
    if ( pB != NULL )
    {
        ...
        pB = true;
    }
}

or

void func( bool&  b ) // For when you care about what b gets set to...
{ ... }

void func() // For when you don't care what b gets set to...
{
    bool b = true;
    func( b );
}

I would prefer the 2nd option since you don't have to deal with NULL pointers...

[Mario F.]

The problem here is the op doesn't want to go to every call location and make the necessary changes. So none of those solutions work.

Conversely, there's no solution to the op problem without having to go to every call location and make changes

[Elysia]

Overloading should work very fine. Just modify the original function to add the extra functionality and overload another function that does not have this argument as a stub that simply wraps the call to the original function.
No (existing) function calls will need to be changed. I don't see how they would have to be?

[Mario F.]

My bad. Misread the op original post. Time to bed.