MCBICK'S PROFILE

std::map<int, RPG::Image*> myImage;
...
namespace CBS
...
voidGetMonsterSelection(std::string loc [])
{
if(!myImage[1]) //This exists inside a function that is called when certain states of battle exist, ie monster/hero selection, action taken, etc
        {
            myImage[1] = RPG::Image::create();
            myImage[1]->loadFromFile(loc[1]);
            myImage[1]->useMaskColor = true;
        }
}

std::map<int, RPG::Image*> myText //Exists outside namespace.
//The following exists within its own function which is called from the callback onBattleStatusWindow when winMonTarget->choiceVisible == true
        for(int i=0; i<8; i++)
        {
            if(!myText[i]
               &&RPG::monsters[i]) //Checks is there is a valid Image object and associated Monster exists.
            {
                myText[i] = RPG::Image::create(320, 80);
                myText[i]->useMaskColor = true;
                int t = 0;
                bool isMultiple = false;
                for(int j=0; j<8; j++) //Check if multiple monsters with the same name exists.
                {
                    if(RPG::monsters[i]
                       &&RPG::monsters[j]
                       &&RPG::monsters[i]->getName() == RPG::monsters[j]->getName())
                    {
                        if(i >= j)
                            t++;
                        if(i != j)
                            isMultiple = true;
                    }
                }
                if(!isMultiple) //Adjusts variables if multiple monsters with the same name exists.
                    t = 0;
                myText[i]->drawString(0, 0, RPG::monsters[i]->getName(), 1);
                myText[i]->drawString(136, 0, monLtr[t], 1);
                myText[i]->setSystemPalette();
            }
            int x = 8;
            int y = 160;
            id = i; //Set to current monster being checked.
            for(int j=0; j<8; j++) //Cycle through all monsters to check if they exist and are still alive then adjust for the correct lettering if multiples of the same monster exists.
            {
                if(RPG::monsters[i]
                   &&RPG::monsters[j]
                   &&RPG::monsters[j]->conditions[1] > 0
                   &&RPG::monsters[i]->id > RPG::monsters[j]->id)
                {
                    id--;
                }
            }
            if(id == 1 ||id == 3 ||id == 5 ||id == 7)
            {
                x = 168;
            }
            if(id == 0 ||id == 1)
            {
                y = 168;
            }
            if(id == 2 ||id == 3)
            {
                y = 184;
            }
            if(id == 4 ||id == 5)
            {
                y = 200;
            }
            if(id == 6 ||id == 7)
            {
                y = 216;
            }
            if(myText[i]
               &&RPG::monsters[i]
               &&RPG::monsters[i]->conditions[1] == 0
               &&RPG::monsters[i]->notHidden) //Checks if monster exists, alive, and is not hidden then draws the text of their name and a letter from A-H if there are multiple of the same monsters.
               {
                   RPG::screen->canvas->draw(x, y, myText[i]);
               }

RPG::Image::destroy(myImage[0]);
...
myImage[0] = NULL; //Won't this crash?
...

if(myImage[i])
{
            RPG::Image::destroy(myImage[i]);
}
if(!myImage[i])
        {
            myImage[i] = RPG::Image::create();
            myImage[i]->loadFromFile(loc);
        }

// Store relevant pointer types here
enum ptr_types{
    INT,
    BOOL
};

// Define struct which contains arbitrary pointer type and what type it is
struct t_ptr{
   void* ptr;
   ptr_types ptr_type;
};

int a = 42;
bool b = True

t_ptr ptr_a;
t_ptr ptr_b;

ptr_a.ptr = reinterpret_cast<void*>(&a);
ptr_b.ptr = reinterpret_cast<void*>(&b);
ptr_a.ptr_type = ptr_types::INT;
ptr_b.ptr_type = ptr_types::BOOL;

std::vector<t_ptr> ptr_list;  // declares a common array for all your funky pointers
ptr_list.append(ptr_a);
ptr_list.append(ptr_b);
int a2;
bool b2;
for(int i = 0; i < ptr_list.size(); i++)
{
    switch(ptr_list[i].ptr_type)  // The switch statement tells the code to continue to execute
    {
        case ptr_types::INT  // If ptr_type is an int, convert the void* to an int*
            a2 = *reinterpret_cast<int*>(ptr_list[i]);  // a2 should now be set to 42
            break;  // tells the code to exit the switch. Code will break otherwise
        case ptr_types::BOOL
            b2 = *reinterpret_cast<bool*>(ptr_list[i]);  // b2 should now be set to true
            break;
        default
            break; // in case the ptr_list[i].ptr_type contains a ptr_type not listed
    }        
}

//For Example
int n = 8;
int* ptrA = &n;
bool b = true;
bool* ptrB = &b;
ptrA = &ptrB; //I would like to convert ptrA to the address of PtrB here. 

//Would the following do what I want?
reinterpret_cast<bool*>(ptrA);
ptrA = &ptrB;