CPP / C++ - Building Systems and Build Automation

CFLAGS  = -DUSE_STDPERIPH_DRIVER
CFLAGS += -c -fmessage-length=0 -g3 -gdwarf-2 -O0 -Wall -Wa,-adhlns="$@.lst"
CFLAGS += -mthumb -mcpu=cortex-m4
CFLAGS += -MMD -MP -MF"$@.d" -MT"$@.d"
CFLAGS += -Iinc -Iinc/cmsis -Iinc/peripherals -Iinc/stm32f4xx

   #---------------------------------------------------#
   #     Compilation and Linker Settings               #
   #---------------------------------------------------#

CXX = g++   # C++ Compiler
CC  = gcc   # C Compiler

CCFLAGS  =                          # C compiler flags
CXXFLAGS = -std=c++1z -pedantic -Wall -Wextra # C++ Compiler flags

LDFLAGS   =   # C Linker Flags
LDXXFLAGS =   # C++ Linker flags

# DEBUG = 1 => Enables debug building
# DEBUG = 0 => Enable release building
DEBUG ?= 0
ifeq ($(DEBUG), 1)
    # (-g)  => Enable debug symbols
    # (-O0) => Disable optimizations
    # -DNDEBUG => Enable assertions
    CXXFLAGS  += -g -O0  -DNDEBUG
else
     # Release mode =>> Enable optimization
     CXXFLAGS += -O3
     # Enable Link-time optimiztion
     LDXXFLAGS += # -flto -ffunction-sections -fdata-sections
endif

APP2_OBJS = app2.o stats.o

   #---------------------------------------------------#
   #     Makefile Rules                                #
   #---------------------------------------------------#

# Main rule executed when use runs '$ make' without
# any argument.
#---------------------------------------------------
all: app1.bin app2.bin

# This rule builds the executable 'app1.bin'
#----------------------------------------------------
#  $^ => Refers to all dependencies (app1.o, app1.o)
#  $@ => Refers to the target name, 'app1.bin'
app1.bin : app1.o stats.o
        @echo -e "\n [INFO] Building executable 'app1.bin'"
        $(CXX) -o $@ $^ $(LDXXFLAGS)

# This rule builds the executable 'app2.bin'
#----------------------------------------------------
#  $^ => Refers to all dependencies (app1.o, app1.o)
#  $@ => Refers to the target name, 'app1.bin'
app2.bin : $(APP2_OBJS)
        @echo -e "\n [INFO] Building executable 'app2.bin'"
        $(CXX) -o $@ $^ $(LDXXFLAGS)

# Compiles all *.cpp files to *.o (object-code files) which
# are inputs to the linker.
#
#--------------------------------------------------
#  $< => Name of dependency (on right-hand size, example: someFile.cpp)
#  $@ => Name of target (on the left-hand side)
#
%.o : %.cpp
        @echo -e "\n [INFO] Building object code: $<"
        $(CXX) -c $< -o $@  $(CXXFLAGS)

# This rule runs the executable app1.bin, the dependency is 'app1.bin'
#------------------------------------------------------------
app1_run: app1.bin
        ./app1.bin

# This rule deletes all object-codes (*.o, *.bin, *.so, *.dll, *.exe ...)
#-------------------------------------------------------
clean:
        @echo -e "\n [INFO] Cleaning compilation output."
        rm -rf -v *.o *.bin

install: app1.bin app2.bin
        @echo -e "\n [INFO] Installing application to: $(INSTALL_PATH)"
        mkdir -p $(INSTALL_PATH)
        cp -rv $^ $(INSTALL_PATH)

#include <iostream>
#ifndef _STATS_HPP_
#define _STATS_HPP_

class Stats
{
public:
        Stats();
        ~Stats();
        Stats(const Stats&) = delete;
        Stats& operator=(const Stats&) = delete;
        void   add(double x);
        void   clear();
        double mean() const;
        double sum()  const;
        size_t count() const;   
private:
        struct pimpl;
        pimpl* m_pimpl;
};

#endif 

#include <iostream>
#include <cmath>
#include <algorithm> 
#include <vector>
#include <numeric>

#include <stats.hpp>

struct Stats::pimpl {
   std::vector<double> dataset = {};
};

Stats::Stats(): m_pimpl(new Stats::pimpl)
{ }

Stats::~Stats() {
    std::puts(" [INFO] ~Stats() destructor called. Ok. ");
    delete m_pimpl;
    m_pimpl = nullptr;
}

void Stats::add(double x) 
{
    m_pimpl->dataset.push_back(x);
}

void Stats::clear()
{
   m_pimpl->dataset.clear();
}

double Stats::sum() const
{
    return std::accumulate( m_pimpl->dataset.begin()
                          , m_pimpl->dataset.end(), 0.0);
}

double Stats::mean() const 
{
    return this->sum() / m_pimpl->dataset.size();
}

size_t Stats::count() const {
    return m_pimpl->dataset.size();
}

#include <iostream>
#include <stats.hpp> 

int main()
{
      std::cout << " [TRACE] Running application 'app1' - OK" << "\n";

      Stats st;
      st.add(10.0); st.add(20.6354); st.add(-5.62); st.add(8.623);
      st.add(20.0); st.add(20.6354); st.add(-5.62); st.add(8.623);

      std::cout << "  => st.count() = " << st.count() << "\n";
      std::cout << "  =>   st.sum() = " << st.sum() << "\n";
      std::cout << "  =>  st.mean() = " << st.mean() << "\n";

      return 0;
}

#include <iostream>
#include <string>

#include "stats.hpp"

int main(int argc, char** argv)
{
     std::cout << " [INFO] Running application: 'app2' - OK" << "\n";

     if(argc < 2){
         return EXIT_FAILURE;
     }

     Stats st;

     for(int i = 1; i < argc; i++)
        try {
           st.add( std::stod(argv[i]) );
        } catch(std::invalid_argument const& ex)
        {
           std::cerr << " Error: invalid input <" << argv[i] << std::endl;
           return EXIT_FAILURE; 
        }

     std::cout << "  => st.count() = " << st.count() << "\n";
     std::cout << "  =>   st.sum() = " << st.sum() << "\n";
     std::cout << "  =>  st.mean() = " << st.mean() << "\n";    

     return EXIT_SUCCESS;
}

$ make

 [INFO] Building object code: app1.cpp
g++    -c app1.cpp -o app1.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building object code: stats.cpp
g++    -c stats.cpp -o stats.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building executable 'app1.bin'
g++    -o app1.bin app1.o stats.o  

 [INFO] Building object code: app2.cpp
g++    -c app2.cpp -o app2.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building executable 'app2.bin'
g++    -o app2.bin app2.o stats.o  

$ make DEBUG=1

 [INFO] Building object code: app1.cpp
g++    -c app1.cpp -o app1.o  -std=c++1z -pedantic -Wall -Wextra  -g -O0  -DNDEBUG

 [INFO] Building object code: stats.cpp
g++    -c stats.cpp -o stats.o  -std=c++1z -pedantic -Wall -Wextra  -g -O0  -DNDEBUG

 [INFO] Building executable 'app1.bin'
g++    -o app1.bin app1.o stats.o 

 [INFO] Building object code: app2.cpp
g++    -c app2.cpp -o app2.o  -std=c++1z -pedantic -Wall -Wextra  -g -O0  -DNDEBUG

 [INFO] Building executable 'app2.bin'
g++    -o app2.bin app2.o stats.o 

 $ gdb --silent app1.bin 
 Printing of typedefs defined in a class in on
 Reading symbols from app1.bin...done.

 (gdb) list
 1      #include <iostream>
 2      
 3      #include <stats.hpp> 
 ... ... ... ... 

 # Set breaking point at main() 
 (gdb) b main

 # Run program app1.bin 
 (gdb) r

 gdb) n
  [TRACE] Running application 'app1' - OK
 9              Stats st;

 (gdb) p st
 $1 = {
   m_pimpl = 0x616280
 }

 ... ...    ... ...    ... ...    ... ... 

(gdb) p st->m_pimpl->dataset
$5 = std::vector of length 8, capacity 8 = {10, 20.635400000000001, -5.6200000000000001, 
  8.6229999999999993, 20, 20.635400000000001, -5.6200000000000001, 8.6229999999999993}
(gdb) 

$ make clean

 [INFO] Cleaning compilation output.
rm -rf -v *.o *.bin
removed 'app1.o'
removed 'app2.o'
removed 'stats.o'
removed 'app1.bin'
removed 'app2.bin'

$ make app1.bin

 [INFO] Building object code: app1.cpp
g++    -c app1.cpp -o app1.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building object code: stats.cpp
g++    -c stats.cpp -o stats.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building executable 'app1.bin'
g++    -o app1.bin app1.o stats.o  

$ make app2.bin

 [INFO] Building object code: app2.cpp
g++    -c app2.cpp -o app2.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building executable 'app2.bin'
g++    -o app2.bin app2.o stats.o  

$ make app1_run

 [INFO] Building object code: app1.cpp
g++    -c app1.cpp -o app1.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building object code: stats.cpp
g++    -c stats.cpp -o stats.o  -std=c++1z -pedantic -Wall -Wextra  -O3

 [INFO] Building executable 'app1.bin'
g++    -o app1.bin app1.o stats.o  
./app1.bin
 [TRACE] Running application 'app1' - OK
  => st.count() = 8
  =>   st.sum() = 77.2768
  =>  st.mean() = 9.6596
 [INFO] ~Stats() destructor called. Ok. 

$ make app1_run
./app1.bin
 [TRACE] Running application 'app1' - OK
  => st.count() = 8
  =>   st.sum() = 77.2768
  =>  st.mean() = 9.6596
 [INFO] ~Stats() destructor called. Ok. 

$ make install INSTALL_PATH=/tmp/bin DEBUG=1

 [INFO] Building object code: app1.cpp
g++    -c app1.cpp -o app1.o  -std=c++1z -pedantic -Wall -Wextra  -g -O0  -DNDEBUG

  ... ... ...   ... ... ...   ... ... ...   ... ... ...   ... ... ... 

 [INFO] Installing application to: /tmp/bin
mkdir -p /tmp/bin
cp -rv app1.bin app2.bin /tmp/bin
'app1.bin' -> '/tmp/bin/app1.bin'
'app2.bin' -> '/tmp/bin/app2.bin'

$ /tmp/bin/app2.bin 10.354 -9.243  100.523 5.6154
 [INFO] Running application: 'app2' - OK
  => st.count() = 4
  =>   st.sum() = 107.249
  =>  st.mean() = 26.8123
 [INFO] ~Stats() destructor called. Ok. 

$ sudo dnf install autoconf automake

$ apt-get install autoconf automake 

$ ./configure --help 

# ---- Example 1 --------------------#
# Install to /usr, /usr/bin, /usr/include, /usr/lib, /usr/lib64 on Linux 
$ ./configure  
$ make 
$ make install 

# ---- Example 2 --------------------#
$ ./configure  --with-feature1 --without-feature2 --eanable-option1 --enable-option2=no 
$ make 
$ make install 

# ---- Example 3 --------------------#
# Install to custom location (directory)
$ ./configure --prefix=/my/custom/location  --with-feature1 \
     --without-feature2 --eanable-option1 --enable-option2=no --disable-option3

$ make -j4 # Build using 4 threads (faster)
$ make install 

# Install application in default directory
$ ./configure

# Install the application in another directory 
$ ./configure --prefix=/home/user/juliuscaesar/opt

$ make 

# Run GNY make with 4 threads 
$ make -j4 

# Run $ make and $ make install in a single step 
$ make -j4 && sudo make install 

$ make install 

# If permission is needed 
$ sudo make install 

$ cd /path/to/project-root/dir
$ tree .
.
├── app1
│   ├── app1.cpp
│   ├── app1.pro
│   ├── dataset.cpp
│   └── dataset.hpp
├── app2
│   ├── app2.cpp
│   └── app2.pro
├── apptest.pro

TEMPLATE = subdirs
SUBDIRS = app1 app2

TEMPLATE = app
CONFIG += console c++11
CONFIG -= app_bundle
CONFIG -= qt

SOURCES += \
        dataset.cpp \
        app1.cpp

HEADERS += \
    dataset.hpp

#include <iostream>
#include "dataset.hpp"

int main()
{
    Dataset ds;
    ds.add_data(10.34);
    ds.add_data(100.23);
    ds.add_data(-100.0);

    std::cout << "Hello World!" << std::endl;
    std::cout << " ds[0] = " << ds.get_data(0) << std::endl;
    std::cout << " ds[1] = " << ds.get_data(0) << std::endl;
    std::cout << " ds[2] = " << ds.get_data(0) << std::endl;

    return 0;
}

#ifndef DATASET_HPP
#define DATASET_HPP

#include <cstddef>

class Dataset{
    struct pimpl;
    pimpl* m_pimpl;
public:
    Dataset();
    ~Dataset();
    Dataset(Dataset cosnt&) = delete;
    Dataset& operator=(Dataset const&) = delete;
    void   add_data(double x);
    double get_data(size_t idx) const;
};

#endif // DATASET_HPP

#include "dataset.hpp"

#include <memory>
#include <vector>
#include <iostream>

struct Dataset::pimpl
{
    std::vector<double> data;
};


Dataset::Dataset(): m_pimpl(new pimpl)
{
    std::cout << " [INFO] Constructor called. OK" << std::endl;
}

Dataset::~Dataset(){
    delete m_pimpl;
}

void Dataset::add_data(double x)
{
    m_pimpl->data.push_back(x);
}

double Dataset::get_data(size_t i) const
{
    return m_pimpl->data[i];
}

QT       += core gui widgets
TEMPLATE  = app
CONFIG   += c++1z
# CONFIG  += console c++1z
# CONFIG  -= app_bundle

# Change
TARGET   = app2_linux_x64.bin
SOURCES += app2.cpp 

#include <iostream>

#include <QApplication>
#include <QtWidgets>

int main(int argc, char* argv[])
{
    std::cout << " [INFO] Starting Application 2 OK" << std::endl;

    QApplication app(argc, argv);

    QPushButton button("Click me");
    button.setVisible(true);

    QObject::connect(&button, &QPushButton::clicked,
                     []{
                         std::cout << " [INFO] I Was clicked OK" << std::endl;
                     });

    return app.exec();
}

$ mkdir build && cd build

$ qmake ../

$ ls
Makefile

$ make

$ tree .
.
├── app1
│   ├── app1
│   ├── app1.o
│   ├── dataset.o
│   └── Makefile
├── app2
│   ├── app2_linux_x64.bin
│   ├── app2.o
│   └── Makefile
└── Makefile

2 directories, 8 files

# Run executable app1 
#--------------------------------------
$ app1/app1 
 [INFO] Constructor called. OK
Hello World!
 ds[0] = 10.34
 ds[1] = 10.34
 ds[2] = 10.34

# Run executable app2 
#--------------------------------------
$ app2/app2_linux_x64.bin 
 [INFO] Starting Application 2 OK