foo = &myvar;

This would assign the address of variable myvar to foo; by preceding the name of the variable myvar with the address-of operator (&), we are no longer assigning the content of the variable itself to foo, but its address.

The actual address of a variable in memory cannot be known before runtime, but let's assume, in order to help clarify some concepts, that myvar is placed during runtime in the memory address 1776.

In this case, consider the following code fragment:

myvar = 25;
foo = &myvar;
bar = myvar;

baz = *foo;

baz = foo;   // baz equal to foo (1776)
baz = *foo;  // baz equal to value pointed to by foo (25)

*foo == myvar

type* name;

where type is the data type pointed to by the pointer. This type is not the type of the pointer itself, but the type of the data the pointer points to. For example:

int* number;
char* character;
double* decimals;

int myarray [20];
int* mypointer;

The following assignment operation would be valid:

mypointer = myarray;

Pointers and arrays support the same set of operations, with the same meaning for both. The main difference being that pointers can be assigned new addresses, while arrays cannot.

In the lesson about arrays, brackets ([]) were explained as specifying the index of an element of the array. In fact these brackets are a dereferencing operator known as offset operator. They dereference the variable they follow just as * does, but they also add the number between brackets to the address being dereferenced. For example:

a[5] = 0;       // a [offset of 5] = 0
*(a+5) = 0;     // pointed to by (a+5) = 0

These two expressions are equivalent and valid, not only if a is a pointer, but also if a is an array. Remember that if an array, its name can be used just like a pointer to its first element.

Suppose now that we define three pointers in this compiler:

char* mychar;
short* myshort;
int* mylong;

and that we know that they point to the memory locations 1000, 2000, and 3000, respectively.

Therefore, if we write:

++mychar;
++myshort;
++mylong;

int x;
int* p1 = &x;  // non-const pointer to non-const int
const int* p2 = &x;  // non-const pointer to const int
int* const p3 = &x;  // const pointer to non-const int
const int* const p4 = &x;  // const pointer to const int

The syntax with const and pointers is definitely tricky, and recognising the cases that best suit each use tends to require some experience. In any case, it is important to get const’ness with pointers (and references) right sooner rather than later, but you should not worry too much about grasping everything if this is the first time you are exposed to the mix of const and pointers.

To add a little bit more confusion to the syntax of const with pointers, the const qualifier can either precede or follow the pointed type, with the exact same meaning:

const int* p2a = &x;  // non-const pointer to const int
int const* p2b = &x;  // also non-const pointer to const int

const char* foo = "hello";

*(foo+4)
foo[4]

char a;
char* b;
char** c;
a = 'z';
b = &a;
c = &b;

#include <iostream>

void increase( void* data, int psize )
{
  if ( psize == sizeof(char) ) { char* pchar; pchar=(char*)data; ++(*pchar); }
  else if (psize == sizeof(int) ) { int* pint; pint=(int*)data; ++(*pint); }
}

int main ()
{
  char a = 'x';
  int b = 1602;
  increase (&a,sizeof(a));
  increase (&b,sizeof(b));
  std::cout << a << ", " << b << std::endl;
  return 0;
}

int* p;               // uninitialised pointer (local variable)
int myarray[10];
int* q = myarray+20;  // element out of bounds

int* p = 0;
int* q = nullptr;

Here, both p and q are null pointers, meaning that they explicitly point to nowhere, and they both actually compare equal: all null pointers compare equal to other null pointers. It is also quite usual to see the defined constant NULL be used in older code to refer to the null pointer value:

int* r = NULL;

NULL is defined in several headers of the standard library, and is defined as an alias of some null pointer constant value (such as 0 or nullptr).

#include <iostream>

int addition( int a, int b ) { return a+b; }

int subtraction( int a, int b ) { return a-b; }

int operation( int x, int y, int (*functocall)( int, int ) )
{
  int g;
  g = (*functocall)( x, y );
  return g;
}

int main()
{
  int m, n;
  int (*minus)( int, int ) = subtraction;

  m = operation( 7, 5, addition );
  n = operation( 20, m, minus );
  std::cout << n << std::endl;
  return 0;
}

In the example above, minus is a pointer to a function that has two parameters of type int. It is directly initialised to point to the function subtraction:

int (* minus)(int,int) = subtraction;

Rectangle* prect;

is a pointer to an object of class Rectangle.

The members of an object can be accessed directly from a pointer by using the arrow operator (->). c++ prect->length; prect->area();

pointer = new type
pointer = new type [number_of_elements]

The first expression is used to allocate memory to contain one single element of type type. The second one is used to allocate a block (an array) of elements of type type, where number_of_elements is an integer value representing the amount of these. For example:

int* foo = new int [5];

foo = new int [5];  // if allocation fails, an exception is thrown

The other method is known as nothrow, when a memory allocation fails, instead of throwing a bad_alloc exception or terminating the program, the pointer returned by new is a null pointer, and the program continues its execution normally.

This method can be specified by using a special object called nothrow, declared in header <new>, as argument for new:

foo = new (nothrow) int [5];

In this case, if the allocation of this block of memory fails, the failure can be detected by checking if foo is a null pointer:

int* foo = new (nothrow) int [5];
if (foo == nullptr) { // error assigning memory. Take measures. }

delete pointer;
delete[] pointer;

  std::unique_ptr<int> iptr{ new int{ 1 } };
  std::unique_ptr<int[]> iaptr{ new int[5]{ 1, 2, 3, 4, 5 } };

#include <iostream>
#include <memory>

int main ()
{
  std::shared_ptr<int> sp1,sp2;
  std::weak_ptr<int> wp;
                                       // sharing group:
                                       // --------------
  sp1 = std::make_shared<int>( 20 );   // sp1
  wp = sp1;                            // sp1, wp

  sp2 = wp.lock();                     // sp1, wp, sp2
  sp1.reset();                         //      wp, sp2

  sp1 = wp.lock();                     // sp1, wp, sp2

  std::cout << "*sp1: " << *sp1 << '\n';
  std::cout << "*sp2: " << *sp2 << '\n';

  return 0;
}