Correct wrong name of the header file
Add include guards to the header files

Add include guards solving the problem of including the same header file
multiple times. They are realized using the #pragma once directive which
is supported by the majority of common C++ compilers.
Improve file opening

Add a new function dedicated to opening the output file to the
measurement class. It creates the output folder if it does not exist
and properly handles already existing files by renaming them, if the
passed 'overwrite' value is set to false. This functionality relies on
the filesystem headers available in the boost libraries. Also, change
the measureAndWrite function to only take the function name as an
argument and determine an appropriate suffix by itself. Rename the
output folder since "measures" and "measurements" do apparently not
mean the same.
Add .gitignore file

Add .gitignore file excluding all object files as well as the binary and
the measurements folder to prevent accidentally commiting them.
Add in place implementation of quicksort

Add an in place implementation of quicksort, which sorts the array
without allocating additional memory. Turn the file into a header file
and discard the previous one, so C++ will handle the template functions
right. Discard the implemented swap function in favor of the already
existing std::swap. Fix the implementation of insertionSort by
passing to it a reference instead of a value.
Test cases for the sorting algorithms

Create a test fixture testing the implementation of the sorting
algorithms. This fixture will prepare an amount of vectors with random
sizes containing random elements as well as some corner case vectors of
smaller sizes and sort them using the algorithms. The test cases below
then use the provided "isSorted" function to check if all the vectors
have been properly sorted.
Rename the files

Rename the file containing the unit tests and the main function giving
them more neutral names, since we are no longer just testing fibonacci
algorithms. Change the name of the executable as well and update
references to the renamed files where necessary.
Implement splitting functions directly

Move the implementation of the string splitting functions into the
header file and delete the old cpp file since splitting them up is not
really necessary.
Refactor measuring features

Discard ClockUtility as well as cpu_cycles.hpp in favor of the new
classes WallMeter and CycleMeter. Both of these are now subclasses of an
abstract class called Meter, implementing its virtual measurement taking
functions. They also hold a descriptor indicating whether a given meter
is a wall time meter, a cycle count meter, or an unspecified type. This
allows us to take measurements independently of whether we are measuring
wall time, cycle counts, or something completely else, in one and the
same function.
The Measurements class now becomes an abstract class called Measurement.
This class behaves roughly the same as its predecessor, however
measurements can be taken in a more generic way. It contains an
instance Meter object, set on construction time, which is used to take
measurements as well as to automatically determine appropriate file name
suffixes and headers. The new doMeasurements() function now allows us to
generate any number of output files for a set of measurements by
iterating over a string type vector called 'outputs'. This vector
defines the base names for the taken measurements. Measurement data are
obtained from the virtual function 'singlePointMeasure', which has to be
implemented in the subclasses. This function takes an index within
'outputs', as well as an argument to take the measurements for. Based on
the index, the appropriate function will be called (see FibMeasurement
for an example), and the measured data will be returned. This new
aproach allows us to do any kind of measurement by simply deriving a
subclass from Measurement, specifying the output names, and doing the
necessary setups (e.g. changing some of the configuration), within a
single step. Change the main function to use the new implementation,
and discard any unneeded files and other leftovers from the old one.
Update .gitignore to ignore .swp files

Some editors (like VIM) use .swp swap files while editing files.
Tell git to ignore them as well.
Implement Mergesort algorithm

Implement the Mergesort algorithm and add corresponding unit tests for
it.
Remove const keyword from Measurement

Make the configuration variables in Measurement non-constant in order to
be able to override them within the subclasses.
Change at() in mergeSort to []

Now that the element access within the functions work properly access
the elements using the [] operator instead. This gains us a bit of
efficiency since no bounds checking will be performed.
Implement measurements for the sorting algorithms

Add another measurement class SortMeasurement used for taking various
measurements of the sorting algorithms. It contains a vector of data on
whose subsets the measurement operations are performed, as well as
functions for setting specific arrangements (ascending, descending,
random, random with repeated elements) for it. It also holds a function
measureForAll() which can be used to perform measurements of all of the
available vector arrangements within a single step.
Add the functionality of SortMeasurement to the main function. Also,
change it to use numbers as input which is a bit easier to handle than
characters.