In C++, pointers generally have a lot more functionality associated with them than is really necessary. A class template that wraps a pointer and removes most of the less-used features (arithmetic, indexing, deletion). Each function could then decide how powerful a pointer it requires and take the appropriate type.
Would using such types make sense in an actual project, though? Are errors caused by unintentional arithmetic/deletion common enough to justify the additional effort?
To clarify: I am considering this as a system alongside existing weak_ptr, shared_ptr, unique_ptr — those three are great when ownership is involved, but sometimes non-owning nullable or reseatable references are useful.
7
For me “non-owning pointers” are nearly non-existant. If I will be storing a pointer to an object in a member variable, then there is some kind of ownership in play, even if it is weak ownership. If this is for passing arguments to a method, then there are references (which have none of the problems you mention).
The only exception I can think of is when iterating through a raw array, maybe serializing/deserializing binary data. In that case I want to be able to do pointer math, but not deletion. But it would be incredibly difficult to accidently delete a pointer, especially when I hardly use delete anyways!
Not sure about arithmetic, but pointer ownership(who deletes it?) is a major source of bugs.
You might be interested in learning about smart pointers. They definitely change some of the pointer semantics, which makes them very useful.
As for nullable types, they might be useful. See Boost.Optional.
1
Wrapping a pointer is close to the right idea. Explore value classes. Build your classes so that the pointer is an implementation detail of the actual behavior. std::string and std::vector are good examples of value classes. You can copy them, assign them. They work like you expect an object to work.
This talk given by Sean Parent explores how to make polymorphism an implementation detail. I’ve used this pattern several times. I find it quite wonderful.
Value semantics are how to avoid pointer mistakes. No pointers, no mistakes.