If you feel you need to use pointers (first consider if you really do), you would normally want to use a smart pointer as this can alleviate many of the problems with raw pointers, mainly forgetting to delete the object and leaking memory. Smart pointers should be preferred over raw pointers. There is no single smart pointer type, but all of them try to abstract a raw pointer in a practical way. Hopefully raises some NULL pointer exception.Ī smart pointer is a class that wraps a 'raw' (or 'bare') C++ pointer, to manage the lifetime of the object being pointed to. Std::auto_ptr p2 = p1 // Copy and transfer ownership. It was deprecated in C++11 and removed in C++17, so you shouldn't use it. It was very much like a scoped pointer, except that it also had the "special" dangerous ability to be copied - which also unexpectedly transfers ownership. Since C++11, the standard library has provided sufficient smart pointers types, and so you should favour the use of std::unique_ptr, std::shared_ptr and std::weak_ptr. This answer is rather old, and so describes what was 'good' at the time, which was smart pointers provided by the Boost library. This makes const & more convenient to use in argument lists and so forth. Int *y = &int(12) // illegal to take the address of a temporary. Pointers cannot (not without some indirection): const int &x = int(12) // legal C++ References cannot be put into an array, whereas pointers can be (Mentioned by user references can be bound to temporaries. to access its members whereas a reference uses a. * differently, emit warnings, or outright refuse to compile it */
MULTIPLE INDIRECTION. CODE
* the code below is undefined your compiler may optimise it If you try hard enough, you can bind a reference to nullptr, but this is undefined and will not behave consistently.
int x = 0 Ī pointer can be assigned nullptr, whereas a reference must be bound to an existing object. References only offer one level of indirection. You can have arbitrarily nested pointers to pointers offering extra levels of indirection. Since the reference assumes the identity of the original variable in this way, it is convenient to think of a reference as another name for the same variable. Using those operators on a reference returns a value corresponding to whatever the reference is bound to the reference’s own address and size are invisible. A reference cannot be re-bound, and must be bound at initialization: int x = 5 Ī pointer variable has its own identity: a distinct, visible memory address that can be taken with the unary & operator and a certain amount of space that can be measured with the sizeof operator.
0 kommentar(er)
