Pass-Through parameters in recursive code

parametersrecursion

When writing large amounts of recursive code (for valid reasons), I have come across many parameters that are not used in specific functions, but are still needed for a subset of all of the functions.
IE this situation (a, b & c are numbers):

function fun1(a, b, c) {
    if(a > b) {
        return fun2(a, b, c);
    } else if(b > c) {
        return fun3(a, b, c);
    } else {
        return a;
    }
}

function fun2(a, b, c) {
    return fun1(a + b, a - b, c);
}

function fun3(a, b, c) {
    return fun1(a * c, b, a / c);
}

(I don't actually know if this terminates)

In this example, fun2 never actually uses c, but it still has to require c as a parameter. In fun3, this is the same thing but for b, and fun1 only cares about a.

In this situation, what should be done to reduce the number of parameters down to only the parameters each function needs & not the parameters that get used in other functions?

(When I say not used, I mean passed through)

Best Answer

You're contradicting yourself:

fun2 never actually uses c

function fun2(a, b, c) {
    return fun1(a + b, a - b, c);
}

Passing a parameter counts as using it. You're thinking that it's unused because it just happens to call fun1, at a time when fun1 also happens to be the method which called fun2 in the first place.

But that's not inherently the case.

fun2 could be using ADifferentMethod(c) internally
fun2 could be called by AnotherCompletelyDifferentMethod()

In either of those cases, your assumption that c is "not used" does not stick.

In this recursive structure, the parent fun1 and the child fun1 should not be labeled as "the same function". They are not. They each have their own separate execution with their own separate scope.

Just like how two separate objects of the same class type are not labeled as "the same object"; two method calls of the same method are not labeled as "the same method" (not in this sense you're trying to use, at least).

Related Solutions

C++ Programming Practices – Using const_cast and volatile for Global Parameters

Don't use volatile const, it sounds like nonsense! Instead, use a class/struct and initialize all variables in the constructor. You can still use const.

Params.h:

struct ConfigParams {

    const int param1;
    const int param2;
    // ...

    // Define a constructor that will load stuff from a configuration file.
    // Tune this to meet your needs, such as parsing the data from a startup command line.
    ConfigParams(const std::string & configFileName);
};

// The global that you will use to fetch the configurations during runtime.
extern const ConfigParams configParams;

Params.cpp:

// Declare the global configuration data table:
const ConfigParams configParams("app_configs.ini");

// The constructor:
ConfigParams::ConfigParams(const std::string & configFileName)
    : param1(getConfigFromFile(configFileName, "param1"))
    , param2(getConfigFromFile(configFileName, "param2"))
    // and so on ...
{
}

// And this function would open the file and lookup the requested parameter key, returning its value:
int getConfigFromFile(const std::string & configFileName, const std::string & key)
{
    // TODO...
}

Recursive Backtracking – How Does Recursive Backtracking Work?

You may imageine backtrack as if you were walking through a dungeon and you must explore all the paths in the dungeon (the dungeon is acyclic - you will never come back to the same place regardless the path you choose). When you come to a place which forks to multiple paths, you choose only one and follow it. Only after you come to an end, you go back to the last fork and choose the next path. When you explored all paths, you go back to previous fork and repeat until you come back to the beginning of the dungeon.

In the code, the for cycle is like the fork in dungeon (in this case with 6 different path where you can continue), the recursive call to diceRolls represents choosing one of the possible paths, the end of a dungeon is when you stop the recursion (you don't stop the execution, you just come one step back). Every time you jump out of the diceRolls function, you continue with the for loop and call diceRolls again.

You end up with interrupting the for loop by a recursive call in the first iteration in the beginning, printing 111, then going one step back and continuing the loop you will get 112, then 113, ...116, and the you go even one step back and get 121, 122, 123,... until you get 661, 662, 666. At that point all your loops and recursive calls finished and the computation ends.

Best Answer

Related Solutions

C++ Programming Practices – Using const_cast and volatile for Global Parameters

Recursive Backtracking – How Does Recursive Backtracking Work?

Related Topic