KAZESUI'S PROFILE

RPG::Image* img;  // at this point, img contains random numbers
img = NULL;  // Sets the address in img to NULL, meaning it is not pointing at anything
img = RPG::Image::create();  // create() allocates memory for an image, and returns the address to that memory
RPG::Image::destroy(img);  // destroy() goes to the address stored in img, and deallocates the memory. Probably does not remove address at this point
img = NULL;  // Manually sets the address to NULL to reaffirm that the pointer is not pointing at anything.

RPG::Image* img = NULL;
if(img)  // img is NULL, which evaluates as false, so this branch will never be entered
    RPG::screen->canvas->draw(x, y, img);  // This would normally crash, but here will never be executed
img = RPG::Image::create();
RPG::Image::destroy(img);
if(img)  //img is likely not NULL, which evaluates as true, so this branch will be entered
    RPG::screen->canvas->draw(x, y, img);  // This will likely crash

myImage[i] = NULL;

// 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
    }        
}

const int a = 42;
int* ptr_a = &a;
int* ptr_b = ptr_a;
*ptr_a = 1337; // This is not allowed
*ptr_b = 1337; // This is also not allowed for the same reason

int c = a; // This sets 'c' to 42
int* ptr_c = &c;
*ptr_c = 1337; // This is allowed and sets 'c' to 1337. 'a' remains 42

RPG::Battler* battler_ptr_a; // this should work
RPG::Battler* battler_ptr_b = battler_ptr_a; // this should also work
RPG::Battler* battler_ptr_c = &RPG::Battler  // this does not work
int* battler_ptr_d = &battle_ptr_a  // this does also not work
int* battler_ptr_e = battle_ptr_a  // nor should this

bool onBattlerDrawn(RPG::Battler *battler, bool isMonster, int id)
{
    RPG::Battler* actor;
    actor = battler;
    int hp = actor->hp;
}

RPG::Battler* battler;
RPG::Battler *battler;

int n = 8;
int* ptrA = &n;  // Again, these are variables, so they should start with a lowercase letter
int* ptrB = ptrA; //This this copies the address of ptrA into ptrB