C++/ROOT Memory Allocation?

Hello,
I am new to C++ programming, so I'm still getting a feel for things. I recently wrote a simple C++ program (to be used as a ROOT Macro) to conduct a statistical analysis of a varied version of the Monty Hall problem (code below). Basically, the programs runs a few simple calculations to decide the winner, nothing too complex, and is designed to be run many times for a statistical analysis. What I have noticed is the program uses memory VERY inefficiently. Using Mac Activity Monitor, I notice that when I just loop through 10,000 times my free memory loses ~0.5 gigabytes. This is a program that I want to be able to run at least a million times if not more. Is there some basic error in my code that is causing this? Thanks in advance.

#include "stdint.h"
#include "TMath.h"
#include <cmath>
#include <TRandom1.h>
#include <iostream>

//Varied Monty Hall Program!

//Function to return a random number to serve as a pointer in the 'door_array' array
int RandomDoor(int& doors)
{
    TRandom1 *myran=new TRandom1(0,389);
    int returnVal=myran->Rndm()*doors;
    return returnVal;
}

//Function to Search for an available door
int Search(int* array,int& doors,int& choosedoor,int& host_doors)
{
    int returnVal;
    if ((doors-host_doors)==1) {
        returnVal=choosedoor;
    }
    
    int rNum=RandomDoor(doors);
    if ((array[rNum]==2)||(rNum==choosedoor)) {
        rNum=RandomDoor(doors);
        while ((array[rNum]==2)||(rNum==choosedoor)) {
            if ((rNum==(doors-1))&&(array[rNum]==2)) {
                rNum=0;
            }
            if ((rNum==(doors-1))&&(rNum==choosedoor)) {
                rNum=0;
            }
            else
            {
                rNum++;
            }
        }
        returnVal=rNum;
    }
    returnVal=RandomDoor(doors);
    return returnVal;
}

void MontyHall2(int doors, long iterations, int host_doors)
{
    double host_wins=0;
    double wins=0;
    double winpct=0;
    //generate array
    int* door_array=new int[doors];
    
    //loop through game 'iteratons' times
    for (long i=0; i<iterations; i++) {
        
        //populate array with 0's
        
        for (int j=0; j<doors; j++) {
            door_array[j]=0;
        }
        
        //choose winning door
        door_array[RandomDoor(doors)]=1;
        
        //player randomly chooses
        
        int choosedoor=RandomDoor(doors);
        
        //Host randomly chooses doors and turns them to "2"
        
        bool rightVal=false;
        for (int k=0; k<host_doors; k++) {
            int temp=Search(door_array,doors,choosedoor,host_doors);
            door_array[temp]=2;
            if (door_array[temp]==1) {
                rightVal=true;
            }
        }
        
        //If host chooses correctly, host_wins++ and game over
        if (rightVal==true) {
            host_wins++;
        }
        
        else {
            
            //Player switches doors
            int limit;
            if (host_doors>3) {
                limit=host_doors/3;
            }
            else {
                limit=1;
            }
            
            bool playerwins=false;
            for (int n=0; n<limit; n++) {
                if (door_array[Search(door_array,doors,choosedoor,host_doors)]==1) {
                    playerwins=true;
                }
            }
            if (playerwins==true) {
                wins++;
            }
        }
    }
    winpct=(100*wins)/iterations;
    cout<<winpct<<" %"<<endl;
    delete[] door_array;
}

Where is main? MontyHall2 never seems to get called.

The most likely cause is you are allocating memory somewhere and not freeing it.

Are you sure RandomDoor () always returns a value between 0 and doors - 1? You can use assertions to help with such reality checks.

I should have clarified, this program was written for ROOT, which uses CINT ( a c++ interpreter). In this case, "MontyHall2(parameters)" acts as the traditional c++ main function.
I googled "malloc" "calloc" and "free" statements. Should I be manually allocating and freeing memory? I'm wondering if the program is using free memory to store the array for each iteration rather than dumping the old array and using that memory space. Or something of that nature.

What do you mean by "loop through" here? Do you mean you invoke the program from the command line 10,000 times? Or is there another function that calls MontyHall2 () function 10,000 times. Or do you mean that iterations is 10,000?

What is 389? Ever heard of a "magic number"?

Yes, by "loop through" I mean that

iterations

is 10,000. 389 is the lux factor passed to the TRandom1 class constructor. It determines the quality and time required to generate the random numbers.

There is no memory being allocated within the iterations loop, so the number of times in that loop should have no effect on memory usage, AFAIK. You could do a test to verify that, as a reality check. Set iterations to 1000, 5000, 10000, 20000 and compare memory usage. At this point, no idea why your program might be using more memory than expected.

Ah, I think I may have identified the problem. I pulled the instantiation of the TRandom1 class out of RandomDoor() and set it outside of the loop. The program still takes a very long time, but the memory usage is much more reasonable now.

Should have seen that. :o I'm glad you found it.