Originally Posted by Corona688

Changing its contents won't cause a crash.

You actually can't typecast things in the way you show in your example, which leaves me more and more curious to what you're actually doing.

That it's passed as a * & gives it the ability to reach in and mangle p1 itself - the pointer.

What I mean is this:

Code:

#include <iostream>
using namespace std;

void mangle_pointer(char * & x) {
        // Set the pointer to a blatantly wrong value
        x = (char *)123456789;
}

int main(void) {
        char *mem=new char;

        cerr << "mem is " << (unsigned long)mem << endl;

        mangle_pointer(mem);

        cerr << "mem is now "<< (unsigned long)mem <<
          " and will crash when deleted" << endl;

        delete mem; // Deleting any value that you didn't get from new is bad
}

This is a trivial example. Tracking down memory crashes is usually a lot harder, the crash is generally a side-effect of an overrun which stomped on the values of your variables or some important hidden values inside the heap itself. An overrun can leap straight through rational boundaries and stomp on whatever happens to be next to it in memory, with no regard for the line order of your program. If the overrun happened to something in a local variable, this can corrupt other local variables, or corrupt your return vector and cause a crash next time you return from any function. If it happened in the heap, it can corrupt other things you have stored in the heap, or corrupt the heap itself, causing delete to mess up in strange ways the next time you delete anything.

This is to say, "delete myvariable" crashing often has nothing to do with "myvariable". Debris can land far away from an explosion.