No... not me
the guy who made this video: https://www.youtube.com/watch?v=443UNeGrFoM
It is awesome! You should watch. At least I think :)
If your code always writes one element outside the collection but you have lots of padding elements for speed, you will not notice the bug until the program reallocates. The array may even be inside of an arena allocator, in which most out-of-bound writes are valid according to the language and debugger. I use C++ pointer classes that are optimized into plain raw pointers in release mode, but have additional inner bounds for catching bugs early in debug mode. Throwing an error from a pointer class before the invalid action is performed, is more well defined for error handling than a segfault signal, that may or may not be caught by the program when turning off hardware and saving a crash report.
His argument against operator overloading didn't convince me to abandon C++. I just read the documentation before using an operator like with all other functions. When a math formula gets really complex, the neatness of infix operations with the same performance as handwritten SIMD intrinsics wins me over, even if I have to maintain the code a little more to use C++.
Instead of all this manual work or wrappers you could simply use modern compiler features like Address Sanitizer. It automatically will check that pointer dereference is to valid/allocated memory. And it will do that without any extra work from user - you can pass pointer through countless functions, store it in heap and get it back later, offset by some amount - and runtime will still check that it is valid once it is dereferenced. And error message it will produce will be way friendlier than any manual wrapper can do, as it will tell location of both - where the invalid dereference happens, and where the original allocation happened. It's super useful in both - C and C++.