What is this statement doing?

[PredicateNormative]

int *myPtr = new int;

The right hand side of the above line dynamically allocates a single integer on the heap returns a pointer of type int*. The left hand side of the above line implicitly copy constructs a pointer on the stack using the pointer returned from the new expression. It is the equivalent of writing:

int *myPtr(new int);

The result is that myPtr now points to a dynamically allocated piece of memory. Incidently, this needs to be released using delete when you have finished with it else you will have a memory leak.

delete myPtr;

The above line deletes the allocation that myPtr points to, any attempt to access the address myPtr currently still points to will yeild undefined behaviour.

Now you might see the problem with the code you posted...

I previously tried something similar to this and the app kept crashing

int *myPtr;

cout....
cin>> *( myPtr );  //Store input into the value myPtr points to

The problem is that you have constructed an integer pointer myPtr but the pointer has not been initialised or assigned to point to a valid piece of memory. In effect, the pointer could be pointing anywhere. What you need to do is point it to a piece of memory that holds a valid integer. You can do this dynamically, or you can allocate a stack integer variable as follows.

int var = 0;
int *myPtr = &var; //now myPtr points somewhere valid.

//You can use myPtr from now on to access var

This aside, why on earth do you want to purposely use pointers to access everything? If you cannot access a single object directly, then the next best thing is accessing it by reference, but if that is not possible (through design constraints), then only as a last resort should you access by pointer. They should NOT be used when there is no need.