Create and Manage c++ Project with b2 build

Jump in this page:
Start
c++ executable project
c++ library project

Back: c++ Build System

B2 build is a perfect build system to create, manage, upgrade c++ project.

Read first: Build and Install B2 Build .

Create, manage c++ executable project

Start: create project directory

mkdir my-prj
cd my-prj

Write Jamfile

File: jamroot

exe hello : hello.cpp : <define>cpp_hot : <cxxstd>26 ;

exe is a rule to define an executable target: hello

In b2 jamfiles, many rules have five parameters, splitted by a colon keyword : , (A colon is a keyword in b2 jamfiles.)

Note that both the left side and right side of : and ; must be blank characters.

First parameter: hello
First parameter is commonly the target name .
Second parameter: hello.cpp
Second parameter is commonly the source list: c++ source file list; and also, another target can be put to the source list too.
Third parameter: <define>cpp_hot
Third parameter commonly lists some requirements that are required to build current target, these requirements can not be overrided on commandline. These requirements can be named as requirements .
Fourth parameter: <cxxstd>26
4th parameter commonly lists some preferences that are used to build current target, these preferences can be overrided on commandline. There preferences can be named as default-build
5th parameter: none in this example
5th parameter lists some requirements required by another target that depends on current target: If another target depends on current target, these requirements will be applied to another target. It is named usage-requirements .

Write c++

File: hello.cpp

#include <iostream>

int main()
{
	std::cout << "Hello, c++!" << std::endl;
}

Build project

Just run command b2:

> b2

Run program:

The compiled program is generated at folder bin, you have to find it.

> ./bin/gcc-16/debug/cxxstd-26-iso/hello
Hello, c++!

Create, manage c++ library project

Init project folders:

mkdir myprj
cd myprj
mkdir include src

File: jamroot

lib foo : src/foo.cpp : <cxxstd>26 <include>./include : : <include>./include ;

exe prog : prog.cpp : <library>foo ;

rule lib defines a target foo.

Because foo is a lib target, the b2 build will generate libfoo.so by default on linux, or related shared library on windows.

<cxxstd>26 in the requirements list: it can not be overrided on commandline (in the 3rd paramter);

<include>./include in the requirements list of third parameter: building current library requires using ./inlcude as include path,
which is translated to -I./include
;

The 4th parameter is empty;

<include>./include in the list of 5th parameter: if another target depends on this target, <include>./include will be applied to another target;

File: include/foo.hpp

#pragma once

namespace dir
{
	class foo
	{
	public:
		void print() const;
	};
};

File: src/foo.cpp

#include <foo.hpp>
#include <iostream>

void dir::foo::print() const
{
	std::cout << "Hello, c++ world!" << std::endl;
}

File: prog.cpp

#include <foo.hpp>

int main()
{
	dir::foo object;
	object.print();
}

Build project:

Just run command b2

b2

Run program:

The program prog is generated in bin folder, you have to find where it is.

> ./bin/gcc-16/debug/prog
Hello, c++ world!
>