Package Managers¶

1. Create the following file:

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Install the package:

   brew install nlohmann-json
   

3. Compile the code and pass the Homebrew prefix to the include path such that the library can be found:

   c++ example.cpp -I$(brew --prefix nlohmann-json)/include -std=c++11 -o example
   

1. Create the following files:

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json CONFIG REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

2. Install the package:

   brew install nlohmann-json
   

3. Compile the code and pass the Homebrew prefix to CMake to find installed packages via find_package:

   CMAKE_PREFIX_PATH=$(brew --prefix) cmake -S . -B build
   cmake --build build
   

1. Create the following files:

   meson.build

   project('json_example', 'cpp',
     version: '1.0',
     default_options: ['cpp_std=c++11']
   )
   
   dependency_json = dependency('nlohmann_json', required: true)
   
   executable('json_example',
     sources: ['example.cpp'],
     dependencies: [dependency_json],
     install: true
   )
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Use the Meson WrapDB to fetch the nlohmann/json wrap:

   mkdir subprojects
   meson wrap install nlohmann_json
   

3. Build:

   meson setup build
   meson compile -C build
   

1. Create the following files:

   BUILD

   cc_binary(
       name = "main",
       srcs = ["example.cpp"],
       deps = ["@nlohmann_json//:json"],
   )
   

   WORKSPACE

   load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
   
   http_archive(
       name = "nlohmann_json",
       urls = ["https://github.com/nlohmann/json/archive/refs/tags/v3.11.3.tar.gz"],
       strip_prefix = "json-3.11.3",
   )
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Build and run:

   bazel build //:main
   bazel run //:main
   

1. Create the following files:

   Conanfile.txt

   [requires]
   nlohmann_json/3.11.3
   
   [generators]
   CMakeToolchain
   CMakeDeps
   

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Call Conan:

   conan install . --output-folder=build --build=missing
   

3. Build:

   cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE="conan_toolchain.cmake" -DCMAKE_BUILD_TYPE=Release
   cmake --build build
   

1. Create the following files:

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Install the library:

   spack install nlohmann-json
   

3. Load the environment for your Spack-installed packages:

   spack load nlohmann-json
   

4. Build the project with CMake:

   cmake -S . -B build -DCMAKE_PREFIX_PATH=$(spack location -i nlohmann-json)
   cmake --build build
   

1. Create the following files:

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   
   include("cmake/HunterGate.cmake")
   HunterGate(
       URL "https://github.com/cpp-pm/hunter/archive/v0.23.297.tar.gz"
       SHA1 "3319fe6a3b08090df7df98dee75134d68e2ef5a3"
   )
   
   project(json_example)
   
   hunter_add_package(nlohmann_json)
   find_package(nlohmann_json CONFIG REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Download required files

   mkdir cmake
   wget https://raw.githubusercontent.com/cpp-pm/gate/master/cmake/HunterGate.cmake -O cmake/HunterGate.cmake
   

3. Build the project with CMake:

   cmake -S . -B build
   cmake --build build
   

1. Create the following files:

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json CONFIG REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Install package:

   vcpkg install nlohmann-json
   

3. Build:

   cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
   cmake --build build
   

1. Create the following files:

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json CONFIG REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Initialize cget

   cget init
   

3. Install the library

   cget install nlohmann/json
   

4. Build

   cmake -S . -B build -DCMAKE_TOOLCHAIN_FILE=cget/cget/cget.cmake
   cmake --build build
   

Probably the easiest way to use NuGet packages is through Visual Studio graphical interface. Just right-click on a project (any C++ project would do) in “Solution Explorer” and select “Manage NuGet Packages…”

Now you can click on “Browse” tab and find the package you like to install.

Most of the packages in NuGet gallery are .NET packages and would not be useful in a C++ project. Microsoft recommends adding “native” and “nativepackage” tags to C++ NuGet packages to distinguish them, but even adding “native” to search query would still show many .NET-only packages in the list.

Nevertheless, after finding the package you want, just click on “Install” button and accept confirmation dialogs. After the package is successfully added to the projects, you should be able to just build and execute the project without the need for making any more changes to build settings.

What happens behind the scenes

After you add a NuGet package, three changes occur in the project source directory. Of course, we could make these changes manually instead of using GUI:

1. A packages.config file will be created (or updated to include the package name if one such file already exists). This file contains a list of the packages required by this project (name and minimum version) and must be added to the project source code repository, so if you move the source code to a new machine, MSBuild/NuGet knows which packages it has to restore (which it does automatically before each build).

   <?xml version="1.0" encoding="utf-8"?>
   <packages>
     <package id="nlohmann.json" version="3.5.0" targetFramework="native" />
   </packages>
   

2. A packages folder which contains actual files in the packages (these are header and binary files required for a successful build, plus a few metadata files). In case of this library for example, it contains json.hpp:

   

   Note

   This directory should not be added to the project source code repository, as it will be restored before each build by MSBuild/NuGet. If you go ahead and delete this folder, then build the project again, it will magically re-appear!

3. Project MSBuild makefile (which for Visual C++ projects has a .vcxproj extension) will be updated to include settings from the package.

   

   The important bit for us here is line 170, which tells MSBuild to import settings from packages\nlohmann.json.3.5.0\build\native\nlohmann.json.targets file. This is a file the package creator created and added to the package (you can see it is one of the two files I created in this repository, the other just contains package attributes like name and version number). What does it contain?

   For our header-only repository, the only setting we need is to add our include directory to the list of AdditionalIncludeDirectories:

   <?xml version="1.0" encoding="utf-8"?>
   <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
       <ItemDefinitionGroup>
           <ClCompile>
               <AdditionalIncludeDirectories>$(MSBuildThisFileDirectory)include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
           </ClCompile>
       </ItemDefinitionGroup>
   </Project>
   

   For libraries with binary files, we will need to add .lib files to linker inputs and add settings to copy .dll and other redistributable files to output directory, if needed.

   There are other changes to the makefile as well:

   • Lines 165-167 add the packages.config as one of project files (so it is shown in Solution Explorer tree view). It is added as None (no build action) and removing it wouldn’t affect build.

   • Lines 172-177 check to ensure the required packages are present. This will display a build error if package directory is empty (for example when NuGet cannot restore packages because Internet connection is down). Again, if you omit this section, the only change in build would be a more cryptic error message if build fails.

   Note

   Changes to .vcxproj makefile should also be added to project source code repository.

As you can see, the mechanism NuGet uses to modify project settings is through MSBuild makefiles, so using NuGet with other build systems and compilers (like CMake) as a dependency manager is either impossible or more problematic than useful.

1. Create the following file:

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

2. Install the package:

   sudo port install nlohmann-json
   

3. Compile the code and pass the Homebrew prefix to the include path such that the library can be found:

   c++ example.cpp -I/opt/local/include -std=c++11 -o example
   

1. Create the following files:

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   find_package(nlohmann_json CONFIG REQUIRED)
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

2. Install the package:

   sudo port install nlohmann-json
   

3. Compile the code:

   cmake -S . -B build
   cmake --build build
   

1. Create the following files:

   example.cpp

   #include <nlohmann/json.hpp>
   #include <iostream>
   #include <iomanip>
   
   using json = nlohmann::json;
   
   int main()
   {
       std::cout << std::setw(4) << json::meta() << std::endl;
   }
   

   CMakeLists.txt

   cmake_minimum_required(VERSION 3.15)
   project(json_example)
   
   include(${CMAKE_SOURCE_DIR}/cmake/CPM.cmake)
   
   CPMAddPackage("gh:nlohmann/json@3.11.3")
   
   add_executable(json_example example.cpp)
   target_link_libraries(json_example PRIVATE nlohmann_json::nlohmann_json)
   

2. Download CPM.cmake

   mkdir -p cmake
   wget -O cmake/CPM.cmake https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake
   

3. Build

   cmake -S . -B build
   cmake --build build