**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** C++ Libraries and Real-World Applications **Topic:** Build a small C++ project using CMake and deploy it using Docker.(Lab topic) ### Overview In this lab, you'll learn how to build and deploy a C++ project using CMake and Docker. You'll create a simple calculator application, write CMake build files to compile and link the project, and then deploy it using Docker containers. This lab aims to help you understand the practical aspects of using CMake and Docker for modern C++ development. ### Prerequisites * Familiarity with C++11/C++14/C++17/C++20 syntax and features * Basic understanding of build systems and package management * Docker installed on your machine (optional but recommended for deployment) ### Step 1: Create the Project Structure Create a new directory for your project and navigate into it: ```bash mkdir calculator cd calculator ``` Create the following subdirectories: ```bash mkdir src mkdir build mkdir cmake ``` The `src` directory will hold your source files, `build` will hold the compiled artifacts, and `cmake` will hold the CMake configuration files. ### Step 2: Write the Calculator Application Create a new file called `calculator.cpp` in the `src` directory: ```cpp // calculator.cpp #include <iostream> double calculate(double operand1, double operand2, char operator_) { switch (operator_) { case '+': return operand1 + operand2; case '-': return operand1 - operand2; case '*': return operand1 * operand2; case '/': if (operand2 != 0) { return operand1 / operand2; } else { throw std::runtime_error("Division by zero"); } default: throw std::runtime_error("Invalid operator"); } } int main() { double operand1, operand2; char operator_; std::cout << "Enter operand 1: "; std::cin >> operand1; std::cout << "Enter operator (+, -, *, /): "; std::cin >> operator_; std::cout << "Enter operand 2: "; std::cin >> operand2; try { double result = calculate(operand1, operand2, operator_); std::cout << "Result: " << result << std::endl; } catch (const std::exception& e) { std::cerr << "Error: " << e.what() << std::endl; } return 0; } ``` This is a simple calculator application that takes two operands and an operator as input and performs the corresponding operation. ### Step 3: Write the CMake Configuration Create a new file called `CMakeLists.txt` in the `cmake` directory: ```cmake # CMakeLists.txt cmake_minimum_required(VERSION 3.10) project(Calculator) set(CMAKE_CXX_STANDARD 14) set(CMAKE_CXX_STANDARD_REQUIRED ON) add_executable(${PROJECT_NAME} "${CMAKE_SOURCE_DIR}/src/calculator.cpp") target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/src") ``` This CMake configuration sets the minimum required version, defines the project name, and sets the C++ standard to C++14. It then adds an executable target with the `add_executable` command and specifies the source file. ### Step 4: Build the Project using CMake Create a new file called `build.sh` (or `build.bat` on Windows): ```bash #!/bin/bash # build.sh cmake -S . -B build cd build cmake --build . ``` This script generates the build files using `cmake` and then builds the executable using `cmake --build`. ### Step 5: Deploy using Docker Create a new file called `Dockerfile`: ```dockerfile # Dockerfile FROM ubuntu:20.04 # Set working directory to /app WORKDIR /app # Copy source files to /app COPY src/ /app/src/ # Copy CMake configuration to /app COPY cmake/CMakeLists.txt /app/CMakeLists.txt # Install dependencies RUN apt update && apt install -y cmake build-essential # Build the project RUN cmake -S . -B build RUN cmake --build build # Set executable permission RUN chmod +x /app/build/Calculator # Expose port EXPOSE 8080 # Run the application CMD ["sh", "-c", "cd /app/build && ./Calculator"] ``` This Dockerfile sets up an Ubuntu 20.04 image, copies the source files and CMake configuration to `/app`, installs dependencies, builds the project, and sets up the executable permission. It then exposes port 8080 and runs the application. ### Step 6: Build the Docker Image Create a new file called `docker.sh` (or `docker.bat` on Windows): ```bash #!/bin/bash # docker.sh docker build -t calculator . ``` This script builds the Docker image using the `docker build` command. ### Step 7: Run the Docker Container Create a new file called `run.sh` (or `run.bat` on Windows): ```bash #!/bin/bash # run.sh docker run -it calculator ``` This script runs the Docker container using the `docker run` command. **How to Use:** 1. Follow the steps above to create the project structure, write the calculator application, write the CMake configuration, build the project using CMake, deploy using Docker, build the Docker image, and run the Docker container. 2. To run the application, execute the `run.sh` script (or `run.bat` on Windows). 3. To exit the container, press `Ctrl+C`. **Best Practices:** * Use meaningful directory and file names. * Follow proper coding standards for C++11/C++14/C++17/C++20 syntax. * Keep the CMake configuration files up-to-date. * Use Docker images and containers to isolate and deploy the application. * Follow proper Dockerfile best practices. **External Links:** * CMake official documentation: <https://cmake.org/documentation/> * Docker official documentation: <https://docs.docker.com/> **Ask for Help:** If you have any questions or need help with this lab, feel free to ask in the comments below.