Optionally taking a function variable as a parameter

Question

I have two functions that do nearly the same thing, the only difference is that one instantiates one of its variables while the other takes it as a parameter:

void f1()
{
    myType o;
    // do work on o
}

void f2(shared_ptr<myType> o)
{
    // do work on o
}

This is because some callers need o after the work is done, while some others do not. There is a lot of work done, and right now keeping the functions in sync is a copy-paste affair (also changing "o." to "o->"). Is it possible to combine these into a single function, such that if the caller passes in an o, then that is used (as in f2), otherwise one is constructed (as in f1)? Perhaps by setting a default value in the signature?

Have a look at: http://stackoverflow.com/questions/1657883/variable-number-of-arguments-in-c — Joanne C, Mar 27 '14 at 21:09
@0x499602D2 I get an error, "redefinition of default parameter". — Justin R., Mar 27 '14 at 21:10
@fatcat1111 you should only specify the default parameter in the function declaration, **not** the definition. Else you get the error you cite. — Bathsheba, Mar 27 '14 at 21:11

Chnossos · Accepted Answer · 2014-07-19T19:28:01.903

4

Use the std::make_shared function in conjunction with a default parameter :

void f2 (shared_ptr<myType> o = make_shared<myType>())

edited Jul 19 '14 at 19:28

answered Mar 27 '14 at 21:11

Chnossos

9,971
4
28
40

Could this be generalized to support parameters that require some pointer manipulation, like "f(shared_ptr& o)"? – Justin R. Mar 27 '14 at 23:13
For a reference to have a default parameter, you need a global variable of the same type, i.e. one `shared_ptr g = std::make_shared();` in the global scope, and then `void f (std::shared_ptr & o = g)`. What do you want to do, specifically ? – Chnossos Mar 28 '14 at 00:00
My concrete aim was met by your answer. I was just thinking through this, trying to wrap my head around defaults. – Justin R. Mar 28 '14 at 01:38

score 1 · Answer 2 · answered Mar 27 '14 at 21:15

The first function can forward to the second function by using a std::shared_ptr with a null deleter:

struct null_deleter
{
    template <typename T>
    void operator()(T*) { }
};

void f1()
{
    myType o;
    f2(std::shared_ptr<myType>(&o, null_deleter{}));
}

score 0 · Answer 3 · answered Mar 27 '14 at 21:12

0

Simply overload the functions:

void f1() // void seems odd, wouldn't you return o after you've done work on it?
{
    yourType o;
    // do work on o
}
void f1(yourType& o)
{
    // do work on o
}

answered Mar 27 '14 at 21:12

smoothware

898
7
19

I was hoping to have just one function, so that I don't have to duplicate code between f1 and f2 (or f1 & f1). As an aside, the work done in these functions are all side-effects. It's a very non-functional design. – Justin R. Mar 27 '14 at 21:14
1

Call second from first, put all the logic in the function with the argument. – Joanne C Mar 27 '14 at 21:14

Optionally taking a function variable as a parameter

3 Answers3