You keep using this word, variables. I don't think it means what you think it means.
At least in my book pointers are still variables (as in "a pointer variable"), and a variable is any named value, whether it's a scalar or a pointer or a nth-pointer, or what its storage is.
But you mean that in your example there is no way to affect the previous value, right?
>I just googled it... why the heck would you copy pointers? That's insane!
Well, copying values and passing them around would be too costly on memory (for larger structs especially), and would prohibit several techniques.
Variables can be varied... you can increment, decrement, do whatever you want with them. They keep track of things.
Pointers are used reference things allocated from the heap, and never anything else, unless you're insane. Pointers get
directly handled in linked lists, trees, etc.
If at all possible, pointers should be avoided otherwise.
Values passed to a procedure can be done by value (the default in Pascal), or by reference (VAR parameters).
I don't see why anyone wouldn't copy values by default... it is the only sane way to do things.
> Pointers are used reference things allocated from the heap, and never anything else, unless you're insane.
People routinely use pointers to things on the stack in several languages. Rust even makes it safe to do that, using lifetimes - a pointer to something on the stack can't outlive the stack frame it points into.
> I don't see why anyone wouldn't copy values by default...
Because not everything is safe to copy. In particular, Rust has a few kinds of pointers which come with special rules.
Firstly, it has boxes, which always point to something on the heap, and have a rule that that when the pointer dies, the thing it points to gets freed. If you copied a box, then when one of the copies died, the thing would be freed, and then the other copy would have a pointer to invalid memory, which would be bad.
Secondly, it has mutable references, which come with a guarantee that a mutable reference is the only pointer to a given thing. If you copied a mutable reference, you would break that guarantee.
Thirdly, it has reference-counting pointers (these are in the standard library, not the language). You can make duplicates of those, but they have to increment their reference count when you do so. Copying is always just a bitwise copy, so there is no chance to increment the reference count. Instead, duplication is an explicit operation.
There are a few other things it doesn't make sense to copy. Like, what would it mean to copy a mutex?
So, in Rust, you can't copy by default. However, it is really easy to mark a type as being copyable (the compiler will check that it really is, ie doesn't contain any non-copyable things), and then you can copy it.
> Variables can be varied... you can increment, decrement, do whatever you want with them.
Variables by themselves are not much. They inherit the properties of the type they are bound to. So what you can do with them can be as restrictive or as permissive as the type allows. That type can be a pointer/reference as well.
I just googled it... why the heck would you copy pointers? That's insane!
In my example, a, b, and c were variables, not pointers.