Creating & Using C++ Libraries

#include <iostream>   // standard library: input/output
#include <vector>     // standard library: a growable array
#include <string>     // standard library: text
#include <algorithm>  // standard library: sort, max, min...
using namespace std;

// The STANDARD library ships with every compiler. You only
// #include it — no download, no extra link flags.
//
// A THIRD-PARTY library would look like:
//     #include <nlohmann/json.hpp>   // you must install it first
// and might need a link flag 
...

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

// HEADER-ONLY library: all the code lives in the header, so you
// just #include it. No separate compile step, no link flag.
// Real examples: nlohmann/json, Catch2, fmt (header mode).
//
// Imagine this block is the file  math_utils.hpp  that you
// would normally pull in with  #include "math_utils.hpp"
namespace mathlib {
    // 'inline' lets a function live in a header without causing a
    // 
...

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

// 🎯 YOUR TURN — replace each ___ then press "Try it Yourself".
// Pretend this namespace is your header-only file  text_utils.hpp

namespace textlib {
    // 1) Mark this helper 'inline' so it is safe in a header
    ___ string shout(string s) {        // 👉 the keyword is  inline
        transform(s.begin(), s.end(), s.begin(), ::toupper);
        return s + "!";
    }
}

int main() {
    // 2) Call your header-o
...

#include <iostream>
#include <cmath>
using namespace std;

// STATIC library (.a on Linux/macOS, .lib on Windows).
// The linker copies the library's code straight INTO your .exe,
// so the program is self-contained but larger.
//
// If this namespace lived in geometry.cpp, you would build it like:
//   1) compile to an object file:   g++ -c geometry.cpp -o geometry.o
//   2) archive into a static lib:   ar rcs libgeometry.a geometry.o
//   3) link it into your program:   g++ main.cpp -L. -lgeom
...

#include <iostream>
#include <string>
using namespace std;

// DYNAMIC / SHARED library (.so Linux, .dll Windows, .dylib macOS).
// It stays a SEPARATE file, loaded when the program runs. The .exe
// is small, and many programs can share one copy — but the file
// must be found at run time or you get a "cannot open shared object".
//
// Build a shared lib and link against it:
//   g++ -shared -fPIC logger.cpp -o liblogger.so   // -fPIC = position-independent code
//   g++ main.cpp -L. -llogger -
...

#include <iostream>
#include <string>
using namespace std;

// 🎯 YOUR TURN — these are the flags, not C++. Fill the ___ in the
// comment so the build command would actually find and link a
// third-party library called  libcurl  installed under /opt/curl.

//   Headers live in /opt/curl/include, the .so in /opt/curl/lib.
//
//   g++ main.cpp \
//       -I/opt/curl/include \   // 👉 -I = where to find HEADERS
//       ___/opt/curl/lib \      // 👉 the flag for the LIBRARY folder is  -L
//      
...

#include <iostream>
#include <string>
using namespace std;

// PACKAGE MANAGERS install third-party libraries for you and wire
// them into your build, so you stop hand-writing -I/-L/-l flags.
//
// vcpkg:
//   vcpkg install fmt
//   (CMake)  find_package(fmt CONFIG REQUIRED)
//            target_link_libraries(app PRIVATE fmt::fmt)
//
// Conan:
//   conanfile.txt ->  [requires]  fmt/10.2.1
//   conan install .
//
// To CONSUME any library you always do the same two things:
//   1) INCLUDE its h
...