So, to answer your question of when/why...
Typically, nobody creates a pointer for an intrinsic type such as int, bool,float etc, unless there is a special reason (such as making an array later)
You typically use a pointer for interacting with functions that either return pointers or take pointers. When you are writing these functions, you should choose to pass arguments as pointers for two reasons: either because you need to modify the value (and not the copy) of the variable (such as a swap function), or because the object you are passing is larger than a pointer. When you pass parameters to a function, there is some overhead from making the copy of those objects that gets passed in, if you have a large class such as an image, you will pay a big penalty for copying that image when you call the function; however if you pass the object by pointer, you only copy it's address, which is a significantly smaller amount of memory.
As you start getting your feet wet in the WPI lib code, you'll start finding some functions require you to pass in pointers, such as when you are passing in an image. There is no magical advantage to making all your variables pointers (in fact you pay a penalty for it because you store the object and the pointer to it in memory).
to make some corrections on your snippet of example code:
Code:
int Number;
int *p_Number = new int; //you create an integer using new, which gives you a pointer to the int
*p_Number = Number; //you put a * (and this is where pointers get confusing)
//because you want to set the value at the address p_Number to be Number,
//the * when used this way dereferences the pointer.
int *p_Number2 = &Number; //this will set p_Number2 to point to Number.
delete p_Number; //This frees the memory allocated by the new int above, so you can reuse p_Number again below without making another pointer variable
p_Number = p_Number2; //this sets the address pointed to by p_Number to the same address pointed to by p_Number2
When you use &Number, you are referencing Number, this operation gets the address at which Number resides, that address has type (int *), so you can set p_Number2 which is also of type (int *).
As far as when to use new/delete. The above example is probably the simplest. You create p_Number, a pointer, and create an int to point it to. Later you want to point it to a different int, so you delete p_Number (which deletes the int it points to) and set p_Number to point somewhere else. Had you not deleted p_Number before changing it to point elsewhere, the int you new'd would no longer have any pointers referencing it, and it would live in memory forever (this is called a memory leak).
Alternatively, if you tried to delete p_Number2 (which points to Number), you would be deleting Number which you aren't responsible for managing, and cause your program to crash when it leaves your function. The reason it crashes is that when you declared Number, the compiler creates this memory location to be used within the function, and it knows that it needs to delete the memory location when it leaves; but if you have already deleted Number (by calling 'delete p_Number2;') then the compiler tries to delete memory it no longer owns.
In short. Don't lose hope, it will make sense eventually (hopefully my explanation helps), everyone pretty much has the same reaction to pointers/references/memory allocation/etc when they first encounter it; and the complexity is necessary, because these concepts are what give C/C++ a lot more power than many other languages. Just remember that you really are working with real memory (as in RAM in your PC, or on the cRIO), learning how memory allocation works is a good first step to a deeper understanding of how computers work.