How do you correctly pass arrays with pointers to a function?

Question

I have to dynamically allocate an array and pass it to a function to calculate odds of a weighted die being rolled. Whenever I run through my code the function doesn't remember the values added to my array and returns random values, what's wrong about the way I'm passing *weight into the roll function? I added print statements after adding weights in and the weight is entered fine up until it's passed to the function via pointer.

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
using namespace std;

int roll (int sides, double *weight) {
int total[sides + 1];
total[0] = 0;

for (int i = 1; i <= sides; i++) {
    total[i] = total[i - 1] + weight[i]; 

}


int current = (rand() % total[sides + 1] - 1 + 1);
//cout << current << " ";

for (int i = 1; i <= sides; i++) { // 1 to weight 1,,,,, weight 1 to weight 
2
    if (current <= total [i] && current > total[i - 1]) {
        current = i;
    }
}



return current;
}

Function that is supposed to retrieve the random number rolled. ^

int main () {

int sides = 0;
int rolls = 0;
int answer = 0;
int currentRoll = 0;
bool done = false;
double* weight;
double totalWeight;
srand(time(NULL));

cout << "Dice Roll Menu: " << endl << "1. Specify an output file" << endl << 
"2. Enter sides and weight for a die" << endl << "3. Simulate a specified 
number of rolls of the weighted die" << endl << "4. Exit" << endl;

while (done != true) {
    cout << endl << "Enter a number that corresponds to you choice: ";
    cin >> answer;


    while (answer == 2) { //SIDES
        cout << "Please enter the number of sides on the die (must be 
greater than two): ";
        cin >> sides;
        if (sides < 2) {
            cout << "Invalid input, try again." << endl;
        }
        else {
            weight = new double[sides + 1];
            for (int i = 0; i < sides + 1; i++) {
                weight[i] = 0;
            }
            break;
        }
    }


    while (answer == 2) {
        totalWeight = 0;
        for (int i = 1; i <= sides; i++) { //WEIGHT 
            cout << "Enter a weight for side " << i << ": ";
            cin >> weight[i];
            cout << "TEST: " << weight[i] << endl;
            totalWeight = weight[i] + totalWeight;

        if (weight[i] < 0) {
            cout << "Invalid input. Try again.";
            totalWeight -= weight[i];
            i--;
            }
        }
        break;
    }

Loop that determines sides and weight and dynamically allocates the array. ^

    while (answer == 3) {
        cout << "Enter the amount of rolls you would like to perform: ";
        cin >> rolls;
        if (rolls < 0) {
            cout << "Invalid input. Try again.";
        }
        else {
            else if (totalWeight == 0) {
                cout << "Please enter weights of the dice first!" << endl;
                answer = 1;
            }
            else {
                done = true;
                break;
            }
        }
    }

//ACTUAL CODE HERE
for (int i = 1; i <= rolls; i++) { //CALCULATES
    currentRoll = roll(sides, &weight[i]);
    cout << currentRoll << " ";
}


}

Answer 1

Perhaps many of the misunderstandings that dominate the comments have to do with simply using C++ (and yet without using std::containers).

My out-of-the-box idea (or just plain crazy) is that there really is no conflict between:

• "I have to be able to complete this program using 'dynamically allocated arrays', sadly I am not allowed to use vectors

• yet all concerned seemed to agree that this is a C++ class assignment.

---

So, we need think of a way to create an array dynamically (I consider this part easy, not sure why). We want something with compile time fixed size. The array must exist in dynamic memory. (And no std containers.)

The goal has also been stated more simply

I have to dynamically allocate an array and pass it to a function to calculate odds of a ...

I propose the following. (This code compiles and runs. )

#include <iostream>
using std::cout, std::flush, std::endl;

// Step 1 - wrap an array inside a class
class Array_t
{
   const int  m_sz;
   int64_t*   m_arr;
public:
   Array_t()
      : m_sz(128)
      , m_arr (new int64_t[m_sz]) // allocate array in dynamic memory
      {
         // init for easy sum ... -------------v
         for (int j=0; j<m_sz; j+=1) m_arr[j] = 1; // easy sum
      }
   ~Array_t() = default;

   int64_t sum() {
      int64_t retVal = 0;
      for (int i=0; i<m_sz; i+=1)
         retVal += m_arr[i];  // direct access to the data!
      return retVal;
   }
};

// If your C++ 'Hello World' has no class ... why bother?

// Step 2 - auto var the above
class DUMY999_t
{
public:
   DUMY999_t() = default;
   ~DUMY999_t() = default;

   int operator()(int argc, char* argv[]) { return exec(argc, argv); }

private:

   int exec(int , char** )
      {
         // here is the array wrapped in a class, an automatic var!
         // the array is dynamically allocated in the class (see ctor)
         Array_t  arr;  
         // ctor provides the compile time constant

         // Step 3 
         // pass the array (in the class) to some function foo()
         cout << "\n  foo(arr) :" << foo(arr) << endl;

         // Step 4 - can we solve the 'how pass' question?
         // It should be obvious that foo is redundant ...
         // the following is both more direct
         // and object-oriented (a good thing)
         // >>> put the function in the object that has the data <<<    
         cout << "\n  arr.sum() :" << arr.sum() << endl;
         // invoke an object method which has
         // direct access to the data!

         return 0;
      }

   // why pass the data to the function? (c-style?)
   int64_t foo(Array_t& arr)
      {
         return arr.sum();
      }
   // why not install the function into the object? (c++?)

}; // class DUMY999_t

int main(int argc, char* argv[]) { return DUMY999_t()(argc, argv); }

Typical output:

  foo(arr) :128

  arr.sum() :128