Recursive function that uses static var - c++

Question

So this function seems to require the use of a static function, The problem I have realized is that there is no way to reset the static var before the recursive function ends. Is there a way to do it that I am not seeing or is there a good way to do this without the use of the static var.
The goal of this function is to fill an array with the odd var first, so say you call it fillAryOddFirst(ary, 13) then the array would be filled in the following order
[13, 11, 9, 7, 5, 3, 1, 2, 4, 6, 8, 12]
void fillAryOddFirst(int ary[], int size) {
static int pos;
if (size <= 0) {
return;
}
if(size % 2 != 0){
ary[pos] = size;
pos++;
}
fillAryOddFirst(ary, size-1);
if(size % 2 == 0 ){
ary[pos] = size;
pos++;
}
return;
}

Answer 1

No, there is no way to reset a local static variable.
If you want to be able to reset it, your only option is to make it a global variable, i.e. move its declaration outside the function.
Another possibility is to make it a parameter that you pass by reference :
void fillAryOddFirst(int ary[], int size, int &pos)
{
if (size <= 0)
{
return;
}
if (size % 2 != 0)
{
ary[pos] = size;
pos++;
}
fillAryOddFirst(ary, size - 1, pos);
if(size % 2 == 0 )
{
ary[pos] = size;
pos++;
}
}
void fillAryOddFirst(int ary[], int size)
{
int pos = 0;
fillAryOddFirst(ary, size, pos);
}

Answer 2

If size is odd, write the first element. If it is even, write the last element. In either case, recursively "focus" on the remaining subarray:
void fillAryOddFirst(int ary[], int size) {
if(size > 0) {
if(size % 2 == 1) {
// +---+---|...|---+
// | s | ? |???| ? |
// +---+---|...|---+
// ^ ary ^ ary + size
// ^ ary + 1 ^ (ary + 1) + (size - 1)
// \-----------/ focus on this range
ary[0] = size;
fillAryOddFirst(ary + 1, size - 1);
} else /*if(size % 2 == 0)*/ {
// +---|...|---+---+
// | ? |???| ? | s |
// +---|...|---+---+
// ^ ary ^ ary + size
// | ^ ary + (size - 1)
// \-----------/ focus on this range
ary[size - 1] = size;
fillAryOddFirst(ary, size - 1);
}
}
}
Written as a loop, that would be
void fillAryOddFirst(int ary[], int size) {
for(; size > 0; size--) {
if(size % 2 == 1) *ary++ = size;
else ary[size - 1] = size;
}
}
That is, you're iterating through size down through 1 and placing the odds at the start and the evens at the end.

Answer 3

"...is there a good way to do this without the use of the static var."
Yes. Wrap the function in a class.
In a class, the "static int pos" function variable can become a simple data attribute of the wrapper.
Below are several code samples.
1) The first is to demonstrate your issue is repeatable.
2) A simple class wrapper called class FillAryOddFirstClass_t. The function is very much the same as your original, but pos is not static.
3) A simple Functor wrapper, called class FillAryOddFirstFunctor_t. Functors have a simpler invocation.
4) Because you have declared this post as a C++ question, item 4 uses a vector instead of an array -- BUT note that the code uses the same class to run the recursion as item 2, FillAryOddFirstClass_t, which expects an array! The vector data resides in dynamic memory, and by specifying "&iVec[0]' (instead of ary), the address passed is the beginning element of the vector data in heap.
5) This is item 2 with extras. class FillAryOddFirstClass2_t is internally complicated with 2 report functions. The report functions build strings to display progress of the recursion / decursion execution.
#include <iostream>
using std::cout, std::endl; // c++17
#include <iomanip>
using std::setw;
#include <string>
using std::string, std::to_string;
#include <vector>
using std::vector;
// original - with static
void fillAryOddFirst ( int ary[], int size )
{
static int pos; // <<<<<<<<<<<<<<< static
if (size <= 0) { return; }
if(size % 2 != 0) { ary[pos] = size; pos++; }
fillAryOddFirst(ary, size-1);
if(size % 2 == 0 ) { ary[pos] = size; pos++; }
return;
}
// class wrapper
class FillAryOddFirstClass_t // UDT - user defined type
{
int pos; // <<<<<<<<<<<<<<< not static, a simple attribute
public:
FillAryOddFirstClass_t() : pos (0) { }
~FillAryOddFirstClass_t() = default;
void fillAryOddFirst ( int ary[], int indx )
{
if (indx <= 0) { return; }
if(indx % 2 != 0) { ary[pos] = indx; pos++; }
fillAryOddFirst(ary, indx-1);
if(indx % 2 == 0 ) { ary[pos] = indx; pos++; }
return;
}
};
// Functor wrapper
class FillAryOddFirstFunctor_t // UDT (user defined type)
{
int pos; // <<<<<<<<<<<<<<< not static
public:
// default ctor and dtor do nothing, cost nothing
void operator()( int ary[], int indx) // functor entry
{
pos = 0; // init
fillAryOddFirst(ary, indx);
return;
}
private:
void fillAryOddFirst( int ary[], int indx)
{
if (indx <= 0) { return; }
if(indx % 2 != 0) { ary[pos] = indx; pos++; }
fillAryOddFirst(ary, indx-1);
if(indx % 2 == 0 ) { ary[pos] = indx; pos++; }
return;
}
};
// class wrapper, with cout progress indicator
class FillAryOddFirstClass2_t // UDT
{
int pos; // <<<<<<<<<<<<<<< no static
size_t sz = 10;
public:
FillAryOddFirstClass2_t() : pos (0) { }
~FillAryOddFirstClass2_t() = default;
void fillAryOddFirst ( size_t rLvl, int ary[], int indx )
{
if (indx <= 0) {
cout << "\n\n" << setw(11) << " " << "recurse end - decurse begins\n";
return;
}
if(indx % 2 != 0) { ary[pos] = indx; pos++; }
cout << rprtR (rLvl, ary); // recurse report
fillAryOddFirst (rLvl+1, ary, indx-1);
cout << rprtD (rLvl, ary); // decurse report
if(indx % 2 == 0 ) { ary[pos] = indx; pos++; }
return;
}
// report recurse
string rprtR ( size_t rLvl, int ary[])
{
std::stringstream ssOut;
ssOut << "\n " << setw(4) << rLvl
<< " " << show(ary) << ' ';
return ssOut.str();
}
// report decurse
string rprtD ( size_t rLvl, int ary[])
{
std::stringstream ssOut;
ssOut << "\n " << setw(4) << rLvl
<< " " << show(ary) << '_';
return ssOut.str();
}
string show(int ary[])
{
std::stringstream ssOut;
for (uint i=0; i<(sz-1); ++i)
if (ary[i])
ssOut << " " << ary[i];
return ssOut.str();
}
}; // class FillAryOddFirstClass2_t
Below is main(), which illustrates how each 'fill' function is used:
int main()
{
const size_t sz = 9;
{
cout << "\n\n Test1: original (function with static int pos) \n";
int ary[sz]; // automatic memory array
init(&ary[0], sz); // function to fill ary with 0's
show(&ary[0], sz);
// this function uses static int pos
fillAryOddFirst (&ary[0], sz);
show(&ary[0], sz);
}
{
cout << "\n\n Test2: class wrapper (no static)\n";
int ary[sz];
init(&ary[0], sz);
show(&ary[0], sz);
{
FillAryOddFirstClass_t faofObj;
faofObj.fillAryOddFirst(&ary[0], sz);
}
show(&ary[0], sz);
}
{
cout << "\n\n Test3: Functor Wrapper (no static)\n";
int ary[sz]; init(&ary[0], sz);
show(&ary[0], sz);
// no static int pos
FillAryOddFirstFunctor_t()(&ary[0], sz);
show(&ary[0], sz);
}
{
cout << "\n\n Test4: class, uses vector, not array (no static)\n";
vector<int> iVec;
for (uint i=0; i<sz; ++i) iVec.push_back(0); // vector grows
show(&iVec[0], sz);
{
FillAryOddFirstClass_t faof;
faof.fillAryOddFirst(&iVec[0], sz);
}
show(&iVec[0], sz);
}
{
cout << "\n\n Test5: class2 (no static) with graphic\n";
vector<int> iVec;
for (uint i=0; i<sz; ++i) iVec.push_back(0); // vector grows
show(&iVec[0], sz);
{
cout << "\n rlvl";
FillAryOddFirstClass2_t faof2;
faof2.fillAryOddFirst(1, &iVec[0], sz);
cout << "\n rlvl";
}
cout << "\n\n ";
show(&iVec[0], sz);
}
cout << endl;
return 0;
}
Output:
Test1: original (function with static int pos)
0 0 0 0 0 0 0 0 0
9 7 5 3 1 2 4 6 8
Test2: class wrapper (no static)
0 0 0 0 0 0 0 0 0
9 7 5 3 1 2 4 6 8
Test3: Functor Wrapper (no static)
0 0 0 0 0 0 0 0 0
9 7 5 3 1 2 4 6 8
Test4: class, uses vector, not array (no static)
0 0 0 0 0 0 0 0 0
9 7 5 3 1 2 4 6 8
Test5: class2 (no static) with graphic
0 0 0 0 0 0 0 0 0
rlvl
1 9
2 9
3 9 7
4 9 7
5 9 7 5
6 9 7 5
7 9 7 5 3
8 9 7 5 3
9 9 7 5 3 1
recurse end - decurse begins
9 9 7 5 3 1_
8 9 7 5 3 1_
7 9 7 5 3 1 2_
6 9 7 5 3 1 2_
5 9 7 5 3 1 2 4_
4 9 7 5 3 1 2 4_
3 9 7 5 3 1 2 4 6_
2 9 7 5 3 1 2 4 6_
1 9 7 5 3 1 2 4 6 8_
rlvl
9 7 5 3 1 2 4 6 8