Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

 

 

 

 

 

(C++) Answer of exercise #7: AddOne: source code

 

Source code of Answer of exercise #7: AddOne.

 

 

 

 

 

Technical facts

 

Application type(s)

Operating system(s) or programming environment(s)

IDE(s):

Project type:

C++ standard:

Compiler(s):

Libraries used:

 

 

 

 

 

Qt project file: CppAddOne.pro

 

#-------------------------------------------------
#
# Project created by QtCreator 2010-07-25T10:57:50
#
#-------------------------------------------------
QT       += core
QT       -= gui
TARGET = CppAddOne

#C++0x support
QMAKE_CXXFLAGS += -std=c++0x

#Needed for gprog
QMAKE_CXXFLAGS_DEBUG += -pg
QMAKE_LFLAGS_DEBUG += -pg

CONFIG   += console
CONFIG   -= app_bundle
TEMPLATE = app
SOURCES += main.cpp

 

 

 

 

 

main.cpp

 

//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppExerciseAddOneAnswer.htm
//---------------------------------------------------------------------------
#include <cassert>
#include <cmath>
#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <functional>
#include <boost/foreach.hpp>
#include <boost/timer.hpp>
#include <boost/lambda/lambda.hpp>
//#include <QObject>
//---------------------------------------------------------------------------
void AddForAssignment1stConstSize(std::vector<int>& v)
{
  const std::size_t size = v.size();
  for (std::size_t i=0; i!=size; ++i) v[i]=1+v[i];
}
//---------------------------------------------------------------------------
void AddForAssignment2ndConstSize(std::vector<int>& v)
{
  const std::size_t size = v.size();
  for (std::size_t i=0; i!=size; ++i) v[i]=v[i]+1;
}
//---------------------------------------------------------------------------
void AddForIncreaseConstSize(std::vector<int>& v)
{
  const std::size_t size = v.size();
  for (std::size_t i=0; i!=size; ++i) v[i]+=1;
}
//---------------------------------------------------------------------------
void AddForPostIncrementConstSize(std::vector<int>& v)
{
  const std::size_t size = v.size();
  for (std::size_t i=0; i!=size; ++i) v[i]++;
}
//---------------------------------------------------------------------------
void AddForPreIncrementConstSize(std::vector<int>& v)
{
  const std::size_t size = v.size();
  for (std::size_t i=0; i!=size; ++i) ++v[i];
}
//---------------------------------------------------------------------------
void AddForAssignment1stNonConstSize(std::vector<int>& v)
{
  for (std::size_t i=0; i!=v.size(); ++i) v[i]=1+v[i];
}
//---------------------------------------------------------------------------
void AddForAssignment2ndNonConstSize(std::vector<int>& v)
{
  for (std::size_t i=0; i!=v.size(); ++i) v[i]=v[i]+1;
}
//---------------------------------------------------------------------------
void AddForIncreaseNonConstSize(std::vector<int>& v)
{
  for (std::size_t i=0; i!=v.size(); ++i) v[i]+=1;
}
//---------------------------------------------------------------------------
void AddForPostIncrementNonConstSize(std::vector<int>& v)
{
  for (std::size_t i=0; i!=v.size(); ++i) v[i]++;
}
//---------------------------------------------------------------------------
void AddForPreIncrementNonConstSize(std::vector<int>& v)
{
  for (std::size_t i=0; i!=v.size(); ++i) ++v[i];
}
//---------------------------------------------------------------------------
void AddIteratorAssignment1stConstEnd(std::vector<int>& v)
{
  const std::vector<int>::iterator j = v.end();
  for (std::vector<int>::iterator i = v.begin(); i!=j; ++i) (*i) = 1 + (*i);
}
//---------------------------------------------------------------------------
void AddIteratorAssignment2ndConstEnd(std::vector<int>& v)
{
  const std::vector<int>::iterator j = v.end();
  for (std::vector<int>::iterator i = v.begin(); i!=j; ++i) (*i) = (*i) + 1;
}
//---------------------------------------------------------------------------
void AddIteratorIncreaseConstEnd(std::vector<int>& v)
{
  const std::vector<int>::iterator j = v.end();
  for (std::vector<int>::iterator i = v.begin(); i!=j; ++i) (*i)+=1;
}
//---------------------------------------------------------------------------
void AddIteratorPostIncrementConstEnd(std::vector<int>& v)
{
  const std::vector<int>::iterator j = v.end();
  for (std::vector<int>::iterator i = v.begin(); i!=j; ++i) (*i)++;
}
//---------------------------------------------------------------------------
void AddIteratorPreIncrementConstEnd(std::vector<int>& v)
{
  const std::vector<int>::iterator j = v.end();
  for (std::vector<int>::iterator i = v.begin(); i!=j; ++i) ++(*i);
}
//---------------------------------------------------------------------------
void AddIteratorAssignment1stNonConstEnd(std::vector<int>& v)
{
  for (std::vector<int>::iterator i = v.begin(); i!=v.end(); ++i) (*i) = 1 + (*i);
}
//---------------------------------------------------------------------------
void AddIteratorAssignment2ndNonConstEnd(std::vector<int>& v)
{
  for (std::vector<int>::iterator i = v.begin(); i!=v.end(); ++i) (*i) = (*i) + 1;
}
//---------------------------------------------------------------------------
void AddIteratorIncreaseNonConstEnd(std::vector<int>& v)
{
  for (std::vector<int>::iterator i = v.begin(); i!=v.end(); ++i) (*i)+=1;
}
//---------------------------------------------------------------------------
void AddIteratorPostIncrementNonConstEnd(std::vector<int>& v)
{
  for (std::vector<int>::iterator i = v.begin(); i!=v.end(); ++i) (*i)++;
}
//---------------------------------------------------------------------------
void AddIteratorPreIncrementNonConstEnd(std::vector<int>& v)
{
  for (std::vector<int>::iterator i = v.begin(); i!=v.end(); ++i) ++(*i);
}
//---------------------------------------------------------------------------
//non-inline functions
void AddOneAssignment1st(int& x) { x=1+x; }
void AddOneAssignment2nd(int& x) { x=x+1; }
void AddOneIncrease(int& x) { x+=1; }
void AddOnePostIncrement(int& x) { x++; }
void AddOnePreIncrement(int& x) { ++x; }
//---------------------------------------------------------------------------
void AddAlgorithmNonInlineFunctionAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneAssignment1st);
}
//---------------------------------------------------------------------------
void AddAlgorithmNonInlineFunctionAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneAssignment2nd);
}
//---------------------------------------------------------------------------
void AddAlgorithmNonInlineFunctionIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneIncrease);
}
//---------------------------------------------------------------------------
void AddAlgorithmNonInlineFunctionPostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOnePostIncrement);
}
//---------------------------------------------------------------------------
void AddAlgorithmNonInlineFunctionPreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOnePreIncrement);
}
//---------------------------------------------------------------------------
//inline functions
inline void AddOneAssignmentInline1st(int& x) { x=1+x; }
inline void AddOneAssignmentInline2nd(int& x) { x=x+1; }
inline void AddOneIncreaseInline(int& x) { x+=1; }
inline void AddOnePostIncrementInline(int& x) { x++; }
inline void AddOnePreIncrementInline(int& x) { ++x; }
//---------------------------------------------------------------------------
void AddAlgorithmInlineFunctionAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneAssignmentInline1st);
}
//---------------------------------------------------------------------------
void AddAlgorithmInlineFunctionAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneAssignmentInline2nd);
}
//---------------------------------------------------------------------------
void AddAlgorithmInlineFunctionIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOneIncreaseInline);
}
//---------------------------------------------------------------------------
void AddAlgorithmInlineFunctionPostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOnePostIncrementInline);
}
//---------------------------------------------------------------------------
void AddAlgorithmInlineFunctionPreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(),AddOnePreIncrementInline);
}
//---------------------------------------------------------------------------
//Non-inline-operator() structs
struct AddOnerNonInlineAssignment1st : public std::unary_function<int,void>
  { void operator()(int& x) { x=1+x; } };
struct AddOnerNonInlineAssignment2nd : public std::unary_function<int,void>
  { void operator()(int& x) { x=x+1; } };
struct AddOnerNonInlineIncrease : public std::unary_function<int,void>
  { void operator()(int& x) { x+=1; } };
struct AddOnerNonInlinePostIncrement : public std::unary_function<int,void>
  { void operator()(int& x) { x++; } };
struct AddOnerNonInlinePreIncrement : public std::unary_function<int,void>
  { void operator()(int& x) { ++x; } };
//---------------------------------------------------------------------------
void AddAlgorithmFunctorNonInlineAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerNonInlineAssignment1st() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorNonInlineAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerNonInlineAssignment2nd() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorNonInlineIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerNonInlineIncrease() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorNonInlinePostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerNonInlinePostIncrement() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorNonInlinePreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerNonInlinePreIncrement() );
}
//---------------------------------------------------------------------------
//Inline-operator() structs
struct AddOnerInlineAssignment1st : public std::unary_function<int,void>
  { inline void operator()(int& x) { x=1+x; } };
struct AddOnerInlineAssignment2nd : public std::unary_function<int,void>
  { inline void operator()(int& x) { x=x+1; } };
struct AddOnerInlineIncrease : public std::unary_function<int,void>
  { inline void operator()(int& x) { x+=1; } };
struct AddOnerInlinePostIncrement : public std::unary_function<int,void>
  { inline void operator()(int& x) { x++; } };
struct AddOnerInlinePreIncrement : public std::unary_function<int,void>
  { inline void operator()(int& x) { ++x; } };
//---------------------------------------------------------------------------
void AddAlgorithmFunctorInlineAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerInlineAssignment1st() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorInlineAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerInlineAssignment2nd() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorInlineIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerInlineIncrease() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorInlinePostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerInlinePostIncrement() );
}
//---------------------------------------------------------------------------
void AddAlgorithmFunctorInlinePreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), AddOnerInlinePreIncrement() );
}
//---------------------------------------------------------------------------
void AddAlgorithmBind1st(std::vector<int>& v)
{
  std::transform(v.begin(),v.end(),v.begin(),
    std::bind1st(std::plus<int>(),1));
}
//---------------------------------------------------------------------------
void AddAlgorithmBind2nd(std::vector<int>& v)
{
  std::transform(v.begin(),v.end(),v.begin(),
    std::bind2nd(std::plus<int>(),1));
}
//---------------------------------------------------------------------------
void AddBoostForeachPreIncrement(std::vector<int>& v)
{
  BOOST_FOREACH(int &i, v) { ++i; }
}
//---------------------------------------------------------------------------
void AddBoostForeachPostIncrement(std::vector<int>& v)
{
  BOOST_FOREACH(int &i, v) { i++; }
}
//---------------------------------------------------------------------------
void AddBoostForeachIncrease(std::vector<int>& v)
{
  BOOST_FOREACH(int &i, v) { i+=1; }
}
//---------------------------------------------------------------------------
void AddBoostForeachAssignment1st(std::vector<int>& v)
{
  BOOST_FOREACH(int &i, v) { i=1+i; }
}
//---------------------------------------------------------------------------
void AddBoostForeachAssignment2nd(std::vector<int>& v)
{
  BOOST_FOREACH(int &i, v) { i=i+1; }
}
//---------------------------------------------------------------------------
void AddBoostLambdaPreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), ++boost::lambda::_1);
}
//---------------------------------------------------------------------------
void AddBoostLambdaPostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), boost::lambda::_1++);
}
//---------------------------------------------------------------------------
void AddBoostLambdaIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), boost::lambda::_1+=1);
}
//---------------------------------------------------------------------------
void AddBoostLambdaAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), boost::lambda::_1 = boost::lambda::_1 + 1);
}
//---------------------------------------------------------------------------
void AddBoostLambdaAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), boost::lambda::_1 = 1 + boost::lambda::_1);
}
//---------------------------------------------------------------------------
#ifdef CPP0X_RANGED_FOR_LOOPS_ARE_SUPPORTED
void AddCpp0xForPreIncrement(std::vector<int>& v)
{
  for(int &i: v) { ++i; }
}
//---------------------------------------------------------------------------
void AddCpp0xForPostIncrement(std::vector<int>& v)
{
  for(int &i: v) { i++; }
}
//---------------------------------------------------------------------------
void AddCpp0xForIncrease(std::vector<int>& v)
{
  for(int &i: v) { i+=1; }
}
//---------------------------------------------------------------------------
void AddCpp0xForAssignment1st(std::vector<int>& v)
{
  for(int &i: v) { i=1+i; }
}
//---------------------------------------------------------------------------
void AddCpp0xForAssignment2nd(std::vector<int>& v)
{
  for(int &i: v) { i=i+1; }
}
//---------------------------------------------------------------------------
#endif //#ifdef CPP0X_RANGED_FOR_LOOPS_ARE_SUPPORTED
//---------------------------------------------------------------------------
void AddCpp0xLambdaPreIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), [](int&i) { ++i; } );
}
//---------------------------------------------------------------------------
void AddCpp0xLambdaPostIncrement(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), [](int&i) { i++; } );
}
//---------------------------------------------------------------------------
void AddCpp0xLambdaIncrease(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), [](int&i) { i+=1; } );
}
//---------------------------------------------------------------------------
void AddCpp0xLambdaAssignment1st(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), [](int&i) { i = i + 1; } );
}
//---------------------------------------------------------------------------
void AddCpp0xLambdaAssignment2nd(std::vector<int>& v)
{
  std::for_each(v.begin(),v.end(), [](int&i) { i = 1 + i; } );
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppExerciseAddOneAnswer.htm
struct Function
{
  typedef void (*FunctionPointer)(std::vector<int>&);
  Function(FunctionPointer anyFunction, const std::string& s)
    : function(anyFunction), name(s) {}
  FunctionPointer function;
  std::string name;
  void operator()(std::vector<int>& v)
  {
    function(v);
  }
};
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppExerciseAddOneAnswer.htm
std::vector<Function> GetFunctions()
{
  std::vector<Function> v;
  //For loop, const size
  v.push_back(Function(AddForAssignment1stConstSize,"For-loop, assignment 1st, const size"));
  v.push_back(Function(AddForAssignment2ndConstSize,"For-loop, assignment 2nd, const size"));
  v.push_back(Function(AddForIncreaseConstSize,"For-loop, increase, const size"));
  v.push_back(Function(AddForPostIncrementConstSize,"For-loop, post-increment, const size"));
  v.push_back(Function(AddForPreIncrementConstSize,"For-loop, pre-increment, const size"));
  //For loop, non-const size
  v.push_back(Function(AddForAssignment1stNonConstSize,"For-loop, assignment 1st, non-const size"));
  v.push_back(Function(AddForAssignment2ndNonConstSize,"For-loop, assignment 2nd, non-const size"));
  v.push_back(Function(AddForIncreaseNonConstSize,"For-loop, increase, non-const size"));
  v.push_back(Function(AddForPostIncrementNonConstSize,"For-loop, post-increment, non-const size"));
  v.push_back(Function(AddForPreIncrementNonConstSize,"For-loop, pre-increment, non-const size"));
  //Iterator, const end
  v.push_back(Function(AddIteratorAssignment1stConstEnd,"Iterator, assignment 1st, const end"));
  v.push_back(Function(AddIteratorAssignment2ndConstEnd,"Iterator, assignment 2nd, const end"));
  v.push_back(Function(AddIteratorIncreaseConstEnd,"Iterator, increase, const end"));
  v.push_back(Function(AddIteratorPostIncrementConstEnd,"Iterator, post-increment, const end"));
  v.push_back(Function(AddIteratorPreIncrementConstEnd,"Iterator, pre-increment, const end"));
  //Iterator, non-const end
  v.push_back(Function(AddIteratorAssignment1stNonConstEnd,"Iterator, assignment 1st, non-const end"));
  v.push_back(Function(AddIteratorAssignment2ndNonConstEnd,"Iterator, assignment 2nd, non-const end"));
  v.push_back(Function(AddIteratorIncreaseNonConstEnd,"Iterator, increase, non-const end"));
  v.push_back(Function(AddIteratorPostIncrementNonConstEnd,"Iterator, post-increment, non-const end"));
  v.push_back(Function(AddIteratorPreIncrementNonConstEnd,"Iterator, pre-increment, non-const end"));
  //Algorithm to non-inline function
  v.push_back(Function(AddAlgorithmNonInlineFunctionAssignment1st,
    "Algorithm, non-inline function, assignment 1st"));
  v.push_back(Function(AddAlgorithmNonInlineFunctionAssignment2nd,
    "Algorithm, non-inline function, assignment 2nd"));
  v.push_back(Function(AddAlgorithmNonInlineFunctionIncrease,
    "Algorithm, non-inline function, increase"));
  v.push_back(Function(AddAlgorithmNonInlineFunctionPostIncrement,
    "Algorithm, non-inline function, post-increment"));
  v.push_back(Function(AddAlgorithmNonInlineFunctionPreIncrement,
    "Algorithm, non-inline function, pre-increment"));
  //Algorithm to inline function
  v.push_back(Function(AddAlgorithmInlineFunctionAssignment1st,
    "Algorithm, inline function, assignment 1st"));
  v.push_back(Function(AddAlgorithmInlineFunctionAssignment2nd,
    "Algorithm, inline function, assignment 2nd"));
  v.push_back(Function(AddAlgorithmInlineFunctionIncrease,
    "Algorithm, inline function, increase"));
  v.push_back(Function(AddAlgorithmInlineFunctionPostIncrement,
    "Algorithm, inline function, post-increment"));
  v.push_back(Function(AddAlgorithmInlineFunctionPreIncrement,
    "Algorithm, inline function, pre-increment"));
  //Algorithm using non-inline-operator() functor
  v.push_back(Function(AddAlgorithmFunctorNonInlineAssignment1st,
    "Algorithm, functor, non-inline, assignment 1st"));
  v.push_back(Function(AddAlgorithmFunctorNonInlineAssignment2nd,
    "Algorithm, functor, non-inline, assignment 2nd"));
  v.push_back(Function(AddAlgorithmFunctorNonInlineIncrease,
    "Algorithm, functor, non-inline, increase"));
  v.push_back(Function(AddAlgorithmFunctorNonInlinePostIncrement,
    "Algorithm, functor, non-inline, post-increment"));
  v.push_back(Function(AddAlgorithmFunctorNonInlinePreIncrement,
    "Algorithm, functor, non-inline, pre-increment"));
  //Algorithm using inline-operator() functor
  v.push_back(Function(AddAlgorithmFunctorInlineAssignment1st,
    "Algorithm, functor, inline, assignment 1st"));
  v.push_back(Function(AddAlgorithmFunctorInlineAssignment2nd,
    "Algorithm, functor, inline, assignment 2nd"));
  v.push_back(Function(AddAlgorithmFunctorInlineIncrease,
    "Algorithm, functor, inline, increase"));
  v.push_back(Function(AddAlgorithmFunctorInlinePostIncrement,
    "Algorithm, functor, inline, post-increment"));
  v.push_back(Function(AddAlgorithmFunctorInlinePreIncrement,
    "Algorithm, functor, inline, pre-increment"));
  //Binders
  v.push_back(Function(AddAlgorithmBind1st,
    "Algorithm, std::plus, std::bind1st"));
  v.push_back(Function(AddAlgorithmBind2nd,
    "Algorithm, std::plus, std::bind2nd"));
  //BOOST_FOREACH
  v.push_back(Function(AddBoostForeachPreIncrement,
    "BOOST_FOREACH, pre-increment"));
  v.push_back(Function(AddBoostForeachPostIncrement,
    "BOOST_FOREACH, post-increment"));
  v.push_back(Function(AddBoostForeachIncrease,
    "BOOST_FOREACH, increase"));
  v.push_back(Function(AddBoostForeachAssignment1st,
    "BOOST_FOREACH, assignment 1st"));
  v.push_back(Function(AddBoostForeachAssignment2nd,
    "BOOST_FOREACH, assignment 2nd"));
  //Boost Lambda
  v.push_back(Function(AddBoostLambdaPreIncrement,
    "Boost.Lambda, pre-increment"));
  v.push_back(Function(AddBoostLambdaPostIncrement,
    "Boost.Lambda, post-increment"));
  v.push_back(Function(AddBoostLambdaIncrease,
    "Boost.Lambda, increase"));
  v.push_back(Function(AddBoostLambdaAssignment1st,
    "Boost.Lambda, assignment 1st"));
  v.push_back(Function(AddBoostLambdaAssignment2nd,
    "Boost.Lambda, assignment 2nd"));

  #ifdef CPP0X_RANGED_FOR_LOOPS_ARE_SUPPORTED
  //C++0x ranged for loop
  v.push_back(Function(AddCpp0xForPreIncrement,
    "C++0x ranged for loop, pre-increment"));
  v.push_back(Function(AddCpp0xForPostIncrement,
    "C++0x ranged for loop, post-increment"));
  v.push_back(Function(AddCpp0xForIncrease,
    "C++0x ranged for loop, increase"));
  v.push_back(Function(AddCpp0xForAssignment1st,
    "C++0x ranged for loop, assignment 1st"));
  v.push_back(Function(AddCpp0xForAssignment2nd,
    "C++0x ranged for loop, assignment 2nd"));
  #endif //#ifdef CPP0X_RANGED_FOR_LOOPS_ARE_SUPPORTED
  //C++0x Lambda
  v.push_back(Function(AddCpp0xLambdaPreIncrement,
    "C++0x lambda expression, pre-increment"));
  v.push_back(Function(AddCpp0xLambdaPostIncrement,
    "C++0x lambda expression, post-increment"));
  v.push_back(Function(AddCpp0xLambdaIncrease,
    "C++0x lambda expression, increase"));
  v.push_back(Function(AddCpp0xLambdaAssignment1st,
    "C++0x lambda expression, assignment 1st"));
  v.push_back(Function(AddCpp0xLambdaAssignment2nd,
    "C++0x lambda expression, assignment 2nd"));
  return v;
}
//---------------------------------------------------------------------------
void TestFunctions(const std::vector<Function>& functions)
{
  std::vector<int> v;
  int value = 0;
  v.push_back(value);

  BOOST_FOREACH(Function f, functions)
  {
    f.function(v);
    assert(v[0] == value + 1);
    ++value;
  }
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppExerciseAddOneAnswer.htm
int main()
{
  boost::timer t;

  const int size = 100000;
  const int nTimes = 100;
  std::vector<Function> functions = GetFunctions();
  TestFunctions(functions);

  std::vector<int> v(size,0);

  for (int i=0; i!=nTimes; ++i)
  {
    std::cout << i << " / " << nTimes << std::endl;
    std::random_shuffle(functions.begin(), functions.end());
    BOOST_FOREACH(Function &f, functions)
    {
      f.function(v);
    }
  }

  std::cout << "Done.\n";
  std::cout << "Size std::vector: " << size << '\n';
  std::cout << "Repeats: " << nTimes << '\n';
  std::cout << "Timer minimal interval: " << t.elapsed_min() << '\n';


  std::cout << "Total running time: " << t.elapsed() << " seconds." << std::endl;
}
//---------------------------------------------------------------------------

 

 

 

 

 

cachegrind.sh

 

#!/bin/sh
echo "Removing previous cachegrind files"
rm cachegrind.txt
rm cachegrind.out

echo "Start the application with cachegrind"
valgrind --tool=cachegrind --cachegrind-out-file=cachegrind.out --branch-sim=yes ../CppAddOne-build-desktop/./CppAddOne

echo "Converting cachegrind.out to cachegrind.txt using cg_annotate"
cg_annotate cachegrind.out > cachegrind.txt

echo "cachegrind done"

 

 

 

 

 

gprof.sh

 

#!/bin/sh
echo "Removing user file"
rm *.pro.user

echo "Creating profile executable"
qmake -config debug
make clean
make

echo "Removing makefile"
rm Makefile

echo "Removing object files"
rm *.o

echo "Start the application"
./CppAddOne

echo "Analyse the gprof results"
gprof CppAddOne > gprof.txt

echo "Remove temporary gprof file"
rm gmon.out

echo "gprof.sh done"

 

 

 

 

 

gprof_summary.txt

 

The gprof summary.

 

Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total          
time   seconds   seconds    calls  ms/call  ms/call  name    
  0.66     15.33     0.14      101     1.39     6.15  AddBoostForeachAssignment1st(std::vector<int, std::allocator<int> >&)
  0.47     16.64     0.10      101     0.99     5.76  AddBoostForeachPostIncrement(std::vector<int, std::allocator<int> >&)
  0.42     16.92     0.09      101     0.89     5.66  AddBoostForeachIncrease(std::vector<int, std::allocator<int> >&)
  0.42     17.01     0.09      101     0.89     1.39  AddForPreIncrementConstSize(std::vector<int, std::allocator<int> >&)
  0.42     17.10     0.09      101     0.89     2.52  AddForAssignment2ndNonConstSize(std::vector<int, std::allocator<int> >&)
  0.42     17.19     0.09      101     0.89     4.41  AddIteratorPostIncrementNonConstEnd(std::vector<int, std::allocator<int> >&)
  0.33     18.16     0.07      101     0.69     5.46  AddBoostForeachAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.33     18.23     0.07      101     0.69     1.19  AddForPostIncrementConstSize(std::vector<int, std::allocator<int> >&)
  0.28     18.65     0.06      101     0.59     1.09  AddForIncreaseConstSize(std::vector<int, std::allocator<int> >&)
  0.28     18.71     0.06      101     0.59     4.12  AddIteratorIncreaseNonConstEnd(std::vector<int, std::allocator<int> >&)
  0.28     18.77     0.06      101     0.59     2.23  AddForAssignment1stNonConstSize(std::vector<int, std::allocator<int> >&)
  0.28     18.83     0.06      101     0.59     4.51  AddIteratorAssignment2ndNonConstEnd(std::vector<int, std::allocator<int> >&)
  0.23     19.45     0.05      101     0.50     2.51  AddIteratorIncreaseConstEnd(std::vector<int, std::allocator<int> >&)
  0.23     19.50     0.05      101     0.50     1.49  AddForAssignment1stConstSize(std::vector<int, std::allocator<int> >&)
  0.23     19.55     0.05      101     0.50     2.90  AddIteratorAssignment2ndConstEnd(std::vector<int, std::allocator<int> >&)
  0.23     19.60     0.05      101     0.50     3.09  AddOnerInlineIncrease std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineIncrease>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineIncrease)
  0.19     20.07     0.04      101     0.40     5.16  AddBoostForeachPreIncrement(std::vector<int, std::allocator<int> >&)
  0.19     20.11     0.04      101     0.40     4.31  AddIteratorAssignment1stNonConstEnd(std::vector<int, std::allocator<int> >&)
  0.19     20.16     0.04      101     0.40     3.49  AddOnerInlineAssignment2nd std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineAssignment2nd>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineAssignment2nd)
  0.19     20.20     0.04      101     0.40     3.19  AddOnerNonInlineAssignment2nd std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineAssignment2nd>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineAssignment2nd)
  0.14     20.59     0.03      101     0.30     1.44  AddForIncreaseNonConstSize(std::vector<int, std::allocator<int> >&)
  0.14     20.62     0.03      101     0.30     2.31  AddIteratorPreIncrementConstEnd(std::vector<int, std::allocator<int> >&)
  0.14     20.65     0.03      101     0.30     2.31  AddIteratorPostIncrementConstEnd(std::vector<int, std::allocator<int> >&)
  0.14     20.68     0.03      101     0.30     3.82  AddIteratorPreIncrementNonConstEnd(std::vector<int, std::allocator<int> >&)
  0.14     20.71     0.03      101     0.30     3.29  AddOnerInlinePreIncrement std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlinePreIncrement>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlinePreIncrement)
  0.14     20.74     0.03      101     0.30     2.99  AddOnerNonInlineAssignment1st std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineAssignment1st>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineAssignment1st)
  0.14     20.80     0.03      101     0.30     2.89  AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1} std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}, AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1})
  0.14     20.83     0.03      101     0.30     3.09  AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1} std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}, AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1})
  0.14     20.86     0.03      101     0.30     3.29  AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1} std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}, AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1})
  0.09     21.02     0.02      101     0.20     1.34  AddForPreIncrementNonConstSize(std::vector<int, std::allocator<int> >&)
  0.09     21.04     0.02      101     0.20     1.34  AddForPostIncrementNonConstSize(std::vector<int, std::allocator<int> >&)
  0.09     21.05     0.02      101     0.20     2.61  AddIteratorAssignment1stConstEnd(std::vector<int, std::allocator<int> >&)
  0.09     21.07     0.02      101     0.20     3.29  AddOnerNonInlinePreIncrement std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlinePreIncrement>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlinePreIncrement)
  0.09     21.09     0.02      101     0.20     2.69  AddOnerNonInlinePostIncrement std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlinePostIncrement>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlinePostIncrement)
  0.09     21.14     0.02      101     0.20     2.55  AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1} std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}, AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1})
  0.09     21.16     0.02      101     0.20     2.79  AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1} std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}, AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1})
  0.05     21.21     0.01      101     0.10     1.09  AddForAssignment2ndConstSize(std::vector<int, std::allocator<int> >&)
  0.05     21.25     0.01      101     0.10     2.40  AddOnerInlineAssignment1st std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineAssignment1st>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlineAssignment1st)
  0.05     21.26     0.01      101     0.10     2.69  AddOnerInlinePostIncrement std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlinePostIncrement>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerInlinePostIncrement)
  0.02     21.29     0.01      101     0.05     3.35  AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     4.34  AddAlgorithmBind1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     4.83  AddAlgorithmBind2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     8.57  AddBoostLambdaIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.91  AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     5.71  AddBoostLambdaPreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.11  AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00    11.54  AddBoostLambdaAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00    12.61  AddBoostLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     5.12  AddBoostLambdaPostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.56  AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.81  AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.11  AddAlgorithmFunctorInlineIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmInlineFunctionIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.11  AddAlgorithmFunctorNonInlineIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.30  AddAlgorithmFunctorInlinePreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmNonInlineFunctionIncrease(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.41  AddAlgorithmFunctorInlineAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.50  AddAlgorithmFunctorInlineAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.71  AddAlgorithmFunctorInlinePostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmInlineFunctionPreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmInlineFunctionAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmInlineFunctionAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmInlineFunctionPostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.30  AddAlgorithmFunctorNonInlinePreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.01  AddAlgorithmFunctorNonInlineAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.21  AddAlgorithmFunctorNonInlineAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     2.71  AddAlgorithmFunctorNonInlinePostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmNonInlineFunctionPreIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmNonInlineFunctionAssignment1st(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmNonInlineFunctionAssignment2nd(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.59  AddAlgorithmNonInlineFunctionPostIncrement(std::vector<int, std::allocator<int> >&)
  0.00     21.32     0.00      101     0.00     3.09  AddOnerNonInlineIncrease std::for_each<__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineIncrease>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, AddOnerNonInlineIncrease)
  0.00     21.32     0.00      101     0.00     0.00  AddCpp0xLambdaIncrease(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}::vector({lambda(int&)#1}&&)
  0.00     21.32     0.00      101     0.00     0.00  AddCpp0xLambdaPreIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}::vector({lambda(int&)#1}&&)
  0.00     21.32     0.00      101     0.00     0.00  AddCpp0xLambdaAssignment1st(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}::vector({lambda(int&)#1}&&)
  0.00     21.32     0.00      101     0.00     0.00  AddCpp0xLambdaAssignment2nd(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}::vector({lambda(int&)#1}&&)
  0.00     21.32     0.00      101     0.00     0.00  AddCpp0xLambdaPostIncrement(std::vector<int, std::allocator<int> >&)::{lambda(int&)#1}::vector({lambda(int&)#1}&&)

%         the percentage of the total running time of the
time       program used by this function.

cumulative a running sum of the number of seconds accounted
seconds   for by this function and those listed above it.

self      the number of seconds accounted for by this
seconds    function alone.  This is the major sort for this
           listing.

calls      the number of times this function was invoked, if
           this function is profiled, else blank.

self      the average number of milliseconds spent in this
ms/call    function per call, if this function is profiled,
   else blank.

total     the average number of milliseconds spent in this
ms/call    function and its descendents per call, if this
   function is profiled, else blank.

name       the name of the function.  This is the minor sort
           for this listing. The index shows the location of
   the function in the gprof listing. If the index is
   in parenthesis it shows where it would appear in
   the gprof listing if it were to be printed.

 

 

 

 

 

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

 

Valid XHTML 1.0 Strict