How can I store the fibonacci sequence in a vector during each recursive call? [closed]

Its normal to put parameter names even in the declarations:

void getUserNum(int &);

We use this to help us identify what the function is doing.

In C++ the '*' and the '&' are part of the type information. So it is usual to push these left towards the type rather than the name. Note this is basically the opposite of C conventions. But C++ is much more rigorous on types and safety than C.

void dispSeq(std::vector<int> &vRef);

// Normally in C++ code I would expect this:
void dispSeq(std::vector<int>& vRef);

Be careful with your use of out parameters.

void getUserNum(int &refVal)

It seems more natural to return a value from a function then get sombody inside to set an external value via a reference (not unheard of and it will depend a lot on the context). But in this situation I would return a value. It will then make using the code eaiser.

 int userNum   = getUserNum();

Error Checking (especially input from a human) needs to be more rigorous.

void getUserNum(int &refVal)
{
    std::cout << "Enter a positive integer:\n";
    std::cin >> refVal;
}

If a user enters a non positive value things will go bad. If the user inputs a string the value of refVal I believe is left unaltered (which leaves your code with an uninitialized variable).

int getUserNum()
{
    int result;

    // user input is done by the line.
    // so read a line at a time and validate it.
    std::string  line;
    std::getline(std::cin, line);

    std::stringstream  linestream(line);

    int result;
    if (linestream >> result)
    {
         // The read worked.
         // Lets check the user did not type ofther crap on the line.
         //
         char x;
         if (!(linestream >> x))
         {
               // Reading more data worked. This means the input was good.
               // As the user typed a number followed by some other stuff
               // like  56.4   (the .4 is illegal)
               //       5Plop  (the Plop is illegal)
               //
               // The the above would have successfully read a value into
               // `x` this with the ! it would have failded and this
               // this condition would not have been entered.

               // We only return if:
               //    1. We read an integer. 
               //    2. There is no other data on the line except white space.
               return result;
         }
    }
    // invalid input
    std::cout << "Stupid user input aborting\n";
    exit(1); // Reading failed.
             // Leave as an exercise on how to repeat the question.
             // You can also compress that very verbose if statement into a single
             // line without it looking too bad.
}

// Single line if
if ((linestream >> result) && !(linestream >> x))
{   return result;
}

In Fib() you should probably not use recursion. Prefer a while loop. Loop from 0 upto the point you want to reach. This makes using a vector easy. You can also start from where you left off last time rather than 0.

int fib(int n)
{
     static std::vector<int>   values = {1,1};
     if (n < values.size()-1) }return values[n];

     int start = values.size();
     for(int loop = start; loop < n; ++loop)
     {
          values[loop] = values[loop-2] + values[loop-1];
     }
     return values[n];
}

@Loki Astari has covered the important points, so I won't repeat those. I'll just address recommended integer and size types:

• For getUserNum(), you're specifically asking the user for a positive number. So, instead of reading into an int, use an unsigned int. You should still include validation. This also better reveals your intent to the reader.

  You could also instead have main() get this input. That way, if you don't want to hound the user for proper input, you could just return EXIT_FAILURE if the first attempt fails.

• size_t is not quite close enough for std::vector (and std::size_t is more C++-like anyway). Although it is an STL container, it's best not to assume that each one is of this type. For all STL containers, prefer size_type as it's more portable:

  standardContainerType::size_type;
  

  For your vector:

  std::vector<int>::size_type;
  

  In fib()'s for-loop, use this type for i:

  // this could go before the loop
  //   if it looks too long to go inside
  std::vector<int>::size_type i;
  
  // since this is an integer type,
  //   post-increment is okay here
  for (i = 0; i < v.size(); i++)
  {
      // ...
  }