Skip to content

Latest commit

 

History

History
177 lines (131 loc) · 4.35 KB

README.md

File metadata and controls

177 lines (131 loc) · 4.35 KB

C++ project template

A template for a modern C++ project that follows good practices such as:

  • checking for memory leaks (valgrind)
  • static analysis (clang-tidy)
  • code formatting (clang-format)
  • unit testing (googletest)
  • code coverage statistics (gcov/lcov)
  • build visualization (graphviz)

Continuous integration is handled automatically by:

  • Github actions (upon pushing to the repo), or
  • Jenkins automation server (running locally)

Documentation is generated using doxygen, hosted by Github pages.

Tested on Ubuntu.

Getting started

  • Configure, build and run executable:
cd build
cmake ..
cmake --build . --target main
./app/main
  • Unit testing (googletest)
cd build 
rm CMakeCache.txt
cmake -DENABLE_TESTING=ON ..
cmake --build . --target unit_tests
./tests/unit_tests
  • Code coverage (gcov)
cd build
rm CMakeCache.txt
cmake -DENABLE_TESTING=ON -DENABLE_COVERAGE=ON -DCMAKE_BUILD_TYPE=Debug ..
cmake --build . --target coverage
  • Check for memory leaks (valgrind)
cd build/app
valgrind --tool=memcheck ./main 6 3
  • Static analysis (clang-tidy)
cd build
rm CMakeCache.txt
cmake -DENABLE_CLANG_TIDY=ON ..
cmake --build . --target main
  • Formatting code (clang-format)
cd build
rm CMakeCache.txt
cmake -DENABLE_CLANG_FORMAT=ON ..
cmake --build . --target clang-format

In case you want to preserve the special formatting of a particular code block such as a matrix initialization, add the following directives around the block:

// clang-format off
Mat4<Scalar> m;
m(0, 0) = x[0]; m(0, 1) = x[1]; m(0, 2) = x[2]; m(0, 3) = -dot(x, eye);
m(1, 0) = y[0]; m(1, 1) = y[1]; m(1, 2) = y[2]; m(1, 3) = -dot(y, eye);
m(2, 0) = z[0]; m(2, 1) = z[1]; m(2, 2) = z[2]; m(2, 3) = -dot(z, eye);
m(3, 0) = 0.0;  m(3, 1) = 0.0;  m(3, 2) = 0.0;  m(3, 3) = 1.0;
// clang-format on
  • Build visualization (graphviz)
cd build
rm CMakeCache.txt
cmake --graphviz=build.dot ..
cmake --build . --target main
dot -Tpng -o build.png build.dot #convert to png image

GraphViz: additional info

Additional useful commands

  • Valgrind
    • Memory profiling: collect information about how your program uses memory
    valgrind --tool=massif program_name
    • Threading errors: detect and diagnose errors related to the use of threads
    valgrind --tool=helgrind program_name
    • IO errors: detect and diagnose errors related to input/output operations
    valgrind --tool=lackey program_name
    • Cachegrind: collect detailed information about the use of the cache memory
    valgrind --tool=cachegrind program_name
    • Massif: collect detailed information about the memory usage of your program over time
    valgrind --tool=massif --time-unit=ms program_name

Jenkins

Upon installing Jenkins (inside a Docker container):

  1. Install Docker plugin
  2. Dashboard -> Manage Jenkins -> Configure Clouds
    • Add a new cloud: Docker
    • Docker cloud details
      • Docker Host URL: tcp://172.18.0.3:2375
      • Enabled: Turn on
  3. Create a job
    • Pipeline
    • General
      • GitHub project: https://github.com/maksimdrachov/cpp-project-template
      • Build Triggers - Poll SCM: * * * * * (Poll every minute)
    • Pipeline
      • Definition: Pipeline script from SCM
      • SCM: Git
        • Repository URL: https://github.com/maksimdrachov/cpp-project-template
      • Script Path: Jenkinsfile

Github actions

Sources

kigster/cmake-project-template

An Introduction to Modern CMake

A very clean example of a C++ library

Another C++ project template

Code Coverage Testing for C++

Using clang-tidy with CMake

TODO

  • Add doc/doxygen
  • Add GitHub actions
  • Add badges

Docker

docker build -t ubuntu-cpp .

docker run -v ~/cpp-project-template:/root/cpp-project-template -it ubuntu-cpp

Jenkins

Install and run Jenkins (inside Docker)