Music: “Stigmata” published


I have just published my second album: “Stigmata“. It is already available through several streaming services such as Spotify, iTunes, CD Baby, Amazon, etc.

Some info:

Hardware used:

  • MacBook Pro 13″ mid-2012
  • Yamaha PSR-213e
  • Casio CDP-220R
  • Audio Technica ATH-M50x

Software used:

Cover artwork:

  • Zdenka Kristel Johnson-Kirigin Orías

Dedicated to:

  • Zdenka, my beautiful wife; Ariana, my little daughter; and Salomé, my mother.

In memoriam:

  • Stephen Johnson (1927-2017), a wise owl. I am pretty sure he would have liked this work.

C++11: std::tuple

A tuple is a C++11 construction and it is built heavily on variadic templates.

A tuple is a variadic class template that stores an unlimited set of values of different types, defined when instantiating the tuple; for example:

tuple<int, int> x;

will store 2 integers.

tuple<string, int, bool> y;

will store one string, one integer and one boolean and so on.

Continue reading “C++11: std::tuple”

C++: Smart pointers, part 5: weak_ptr

This is the last of several posts I wrote related to smart pointers:

  1. Smart pointers
  2. unique_ptr
  3. More on unique_ptr
  4. shared_ptr
  5. weak_ptr

In modern C++ applications (C++11 and later), you can replace almost all your naked pointers to shared_ptr and unique_ptr in order to have automatic resource administration in a deterministic way so you will not need (almost, again) to release the memory manually.

The “almost” means that there is one scenario where the smart pointers, specifically, the shared_ptr instances, will not work: When you have circular references. In this scenario, since every shared_ptr is pointing to the other one, the memory will never be released.

Continue reading “C++: Smart pointers, part 5: weak_ptr”

C++11: Perfect forwarding

Consider this function template invoke that invokes the function/functor/lambda expression passed as argument passing it the two extra arguments given:

#include <iostream>
#include <string>

using namespace std;

void sum(int a, int b)
    cout << a + b << endl;

void concat(const string& a, const string& b)
    cout << a + b << endl;

template <typename PROC, typename A, typename B>
void invoke(PROC p, const A& a, const B& b)
    p(a, b);

int main()
    invoke(sum, 10, 20);
    invoke(concat, "Hello ", "world");
    return 0;

Nice, it works as expected and the result is:

Hello world

Continue reading “C++11: Perfect forwarding”

C++: Smart pointers, part 4: shared_ptr

This is the fourth post of several posts I wrote related to smart pointers:

  1. Smart pointers
  2. unique_ptr
  3. More on unique_ptr
  4. shared_ptr
  5. weak_ptr

As I mentioned in other posts, C++11 brings a new set of smart pointers into C++. The most useful smart pointer is shared_ptr: Its memory management policy consists in counting the number of shared_ptr instances that refer to the same object in the heap.

Continue reading “C++: Smart pointers, part 4: shared_ptr”