• static storage
• thread-local storage
• automatic storage
• dynamic storage

• fixed address determined at compile time
• global static variables are
  • constructed before execution enters main
  • deleted after execution leaves main
• static variables in a scope are constructed before the execution of this scope.
• the order of construction is complex
• no runtime cost to create the storage

appropriate for data that will be used for the whole life of the program

• memory reserved by the compiler (stack)
• exists into their scope
• deleted when they leave the scope
• limit to the total amount of memory in the stack

• memory requested at runtime (heap)
• must be explicitly requested (new)
• must be explicitly destroyed (delete)
• the address is determined at runtime
• no limit to the total amount of memory

A pointer variable is a variable which stores a memory address.

A pointer variable must be assigned to be used.

                  
double d = 0.5;
double* p = &d;
float* p_f = nullptr;

std::cout << d << std::endl;
std::cout << *p << std::endl;
std::cout << p << std::endl;

std::cout << p_f << std::endl;
std::cout << *p_f << std::endl; // Error: segfault

int i = 4;
double* p2 = &i; // Error: cannot convert from int* to double*
                  
                

                  
int i = 4;
int* pi = &i;
// double* d = (double*)pi;
double* d = reinterpret_cast<double*>(pi);
std::cout << i << std::endl;
std::cout << pi << std::endl;
std::cout << d << std::endl;
std::cout << *pi << std::endl;
std::cout << *d << std::endl;
                  
                

                  
int* i = new int;     // allocates an uninitialized integer
int* i2 = new int(5); // allocates an integer initialized to 5
int* i3 = new int[5]; // allocates an array of 5 integers

delete[] i3;          // free the memory used by the array i3
delete i2;            // free the memory used by i2
delete i;             // free the memory used by i
                  
                

                  
struct A
{
  double x;
  double y;
};

A* a = new A;

std::cout << (*a).x << std::endl;
// or
std::cout << a->x << std::endl;

delete a;
                  
                

int* ar = new int[10];
// Or
std::vector<int> v(10);
int* ar = v.data();
                

int* ar2 = ar + 2;
std::cout << *ar2 << std::endl;
std::cout << ar[2] << std::endl;
std::cout << (ar2 - ar) << std::endl;

int* ar3 = ar2 - 1;
std::cout << *ar3 << std::endl;
std::cout << ar[1] << std::endl;
                

void mean(const std::vector<double>& param)
{
  if(param.size() == 0)
  {
    throw std::runtime_error("param size is 0")
  }
  else
  {
    // ...
  }
}
                

try
{
  std::vector<double> v(0);
  mean(v);
}
catch(std::exception& e)
{
  std::cout << "caught exception - " << e.what() << std::endl;
}
                

void test_resource()
{
  resource r;
  try
  {
    r.acquire();
    if (...)
    {
      r.release();
      return;
    }
    r.print_message();
    r.release();
  }
  catch(std::exception& e)
  {
    std::cout << "exception caught: " << e.what() << std::endl;
    r.release();
  }
}
                

What do you think about this code ?

void test_resource()
{
  resource r;
  resource_guard g(r);
  r.print_message();
}
                

Write what resource_guard should do.

class resource_guard
{
  public:

    resource_guard(resource& r);
    ~resource_guard();

  private:

    resource& m_r;
};
                

resource_guard::resource_guard(resource& r)
: m_r(r)
{
  m_r.acquire();
}

resource::~resource_guard()
{
  m_r.release();
}
                

void function() noexcept;
                

Who is the owner of this return type ?

Result* make_computation(class_A& a, class_B& b);
                

It could be

Result* make_computation(class_A& a, class_B& b)
{
  Result* r = new Result();
  ...
  return r;
}
                

or

Result* make_computation(class_A& a, class_B& b)
{
  ...
  return a.get_result(b);
}
                

The owner of a resource should be readable and obvious when you read the source code.

This makes it clear who is reponsible for the destruction of the data and to avoid potential memory leakage.

Smart pointers help to specify the ownership.

There are two versions:

• std::unique_ptr: unique ownership
• std::shared_ptr: shared ownership

class coord
{
  public:
    coord(double x, double y)
    : m_x(x), m_y(y)
    {}

    void print() const
    {
      std::cout << "coords(" << m_x << ", " << m_y << ")" << std::endl;
    }

  private:
    double m_x, m_y;
};
                

int main()
{
  auto p_1 = std::unique_ptr<double>(new double(4.));
  auto p_c = std::make_unique<coord>(4., 3.);
  auto p_a = std::unique_ptr<double[]>(new double[1000]);

  p_c->print();

  // auto p_2 = p_1; // Error: unique_ptr is not copyable
  auto p_2 = std::move(p_1);
  std::cout << *p_2 << std::endl;
  std::cout << p_1 << std::endl;
}
                

std::shared_ptr<int> p = new int;
std::shared_ptr<int> p2(new int);
auto p3 = std::make_shared<int>();
                

void function()
{
  auto p = std::make_shared<int>(); // ref_count = 1;
  {
    std::shared_ptr<int> p2 = p; // ref_count = 2;
    // ...
  } // p2 destructor is called, ref_count = 1
} // p destructor is called, ref_count = 0, deletes the internal pointer
                

to be used with caution because it is expensive !