char* is a mutable pointer to a mutable character/string. const char* is a mutable pointer to an immutable character/string. You cannot change the contents of the location(s) this pointer points to. Also, compilers are required to give error messages when you try to do so. For the same reason, conversion from const char * to … Read more
They are EXACTLY equivalent. However, in int *myVariable, myVariable2; It seems obvious that myVariable has type int*, while myVariable2 has type int. In int* myVariable, myVariable2; it may seem obvious that both are of type int*, but that is not correct as myVariable2 has type int. Therefore, the first programming style is more intuitive.
const int* ptr; declares ptr a pointer to const int type. You can modify ptr itself but the object pointed to by ptr shall not be modified. const int a = 10; const int* ptr = &a; *ptr = 5; // wrong ptr++; // right While int * const ptr; declares ptr a const pointer … Read more
Because you’re passing the value of the pointer to the method and then dereferencing it to get the integer that is pointed to.
The guarantee you get is that sizeof(char) == 1. There are no other guarantees, including no guarantee that sizeof(int *) == sizeof(double *). In practice, pointers will be size 2 on a 16-bit system (if you can find one), 4 on a 32-bit system, and 8 on a 64-bit system, but there’s nothing to be … Read more
The simplest answer, assuming you don’t mind the vagaries and variations in format between different platforms, is the standard %p notation. The C99 standard (ISO/IEC 9899:1999) says in §7.19.6.1 ¶8: p The argument shall be a pointer to void. The value of the pointer is converted to a sequence of printing characters, in an implementation-defined … Read more
An array is an array and a pointer is a pointer, but in most cases array names are converted to pointers. A term often used is that they decay to pointers. Here is an array: int a[7]; a contains space for seven integers, and you can put a value in one of them with an … Read more
size_t is a type that can hold any array index. This means that, logically, size_t should be able to hold any pointer type Not necessarily! Hark back to the days of segmented 16-bit architectures for example: an array might be limited to a single segment (so a 16-bit size_t would do) BUT you could have … Read more
Rules of thumb for C++11: Pass by value, except when you do not need ownership of the object and a simple alias will do, in which case you pass by const reference, you must mutate the object, in which case, use pass by a non-const lvalue reference, you pass objects of derived classes as base … Read more
Passing by pointer Caller has to take the address -> not transparent A 0 value can be provided to mean nothing. This can be used to provide optional arguments. Pass by reference Caller just passes the object -> transparent. Has to be used for operator overloading, since overloading for pointer types is not possible (pointers … Read more