delete performs the check anyway, so checking it on your side adds overhead and looks uglier. A very good practice is setting the pointer to NULL after delete (helps avoiding double deletion and other similar memory corruption problems). I’d also love if delete by default was setting the parameter to NULL like in #define my_delete(x) … Read more
This compile-time error arises when you try to assign or pass (or convert) a concrete type to an interface type; and the type itself does not implement the interface, only a pointer to the type. Short summary: An assignment to a variable of interface type is valid if the value being assigned implements the interface … Read more
Method 1 (using new) Allocates memory for the object on the free store (This is frequently the same thing as the heap) Requires you to explicitly delete your object later. (If you don’t delete it, you could create a memory leak) Memory stays allocated until you delete it. (i.e. you could return an object that … Read more
The difference is that const char * is a pointer to a const char, while char * const is a constant pointer to a char. The first, the value being pointed to can’t be changed but the pointer can be. The second, the value being pointed at can change but the pointer can’t (similar to … Read more
Note: This answer applies to the C language, not C++. Null Pointers The integer constant literal 0 has different meanings depending upon the context in which it’s used. In all cases, it is still an integer constant with the value 0, it is just described in different ways. If a pointer is being compared to … Read more
No, you can’t. The compiler doesn’t know what the pointer is pointing to. There are tricks, like ending the array with a known out-of-band value and then counting the size up until that value, but that’s not using sizeof(). Another trick is the one mentioned by Zan, which is to stash the size somewhere. For … Read more
You have pointers and values: int* p; // variable p is pointer to integer type int i; // integer value You turn a pointer into a value with *: int i2 = *p; // integer i2 is assigned with integer value that pointer p is pointing to You turn a value into a pointer with … Read more
The delete operator deletes only a reference, never an object itself. If it did delete the object itself, other remaining references would be dangling, like a C++ delete. (And accessing one of them would cause a crash. To make them all turn null would mean having extra work when deleting or extra memory for each … Read more
Why use pointers over normal variables? Short answer is: Don’t. 😉 Pointers are to be used where you can’t use anything else. It is either because the lack of appropriate functionality, missing data types or for pure perfomance. More below… When and where should I use pointers? Short answer here is: Where you cannot use … Read more
Use reference wherever you can, pointers wherever you must. Avoid pointers until you can’t. The reason is that pointers make things harder to follow/read, less safe and far more dangerous manipulations than any other constructs. So the rule of thumb is to use pointers only if there is no other choice. For example, returning a … Read more