Mercury13

cmake_minimum_required(VERSION 3.10.0)
project(Game VERSION 0.1.0 LANGUAGES C CXX)

if (MINGW)
    add_compile_options(-static-libgcc -static-libstdc++)
    add_link_options(-static -lpthread)	
    if (CMAKE_BUILD_TYPE STREQUAL "Release")
        add_compile_options(-O3)
        add_link_options(-s)
    endif()
endif()

add_executable(Game main.cpp)

char hello1[] = "hello";   // массив длины 6, в изменяемом сегменте или стеке,
                         // данные скопированы из литерала, который
                         // сидит в неизменяемом сегменте
const char* hello2 = "hello";   // указатель направлен прямо на литерал,
                         // и попытка изменить его под Windows — вылет

char* hello1 = const_cast<char*>("hello");
char* hello2 = const_cast<char*>("hello");
hello1[1] = 'U';   // hello2 = "hUllo" в системах вроде DOS, где не вылетит

BoxContainer::BoxContainer(NumberBox& nb) : nbox(nb) { ... }

class NumberBox {
	...
public:
	NumberBox();
	NumberBox(int i);
	...
};

#include <iostream>
#include <string>

struct T {
    int x;
    std::string y;
};

T Deserialize(std::istream& stream, auto T::*... properties)
{
    T object = {};
    auto FillObject = [&object, &stream] (auto property)
    {
        stream >> object.*property;
    };

    (FillObject(properties), ...);
    return object;
};

int main()
{
    T r = Deserialize(std::cin, &T::x, &T::y);
    std::cout << "<" << r.x << "> <" << r.y << ">" "\n";
    return 0;
}

const int& ref = 1;
const int* Number = &ref;

template <class T>
concept Printable = requires(T x) {
        std::cout << x;
};

struct Class {
    template<Printable Text>
    Class& operator<<(const Text& text) {
        cout << text << endl;
        return *this;
    }

template<uint8_t i>
struct Id {
    constexpr static uint8_t id = i;
    using SpecialPrint = void;
    // какие-то элементы класса с методами
};
. . . . .
template <class T>
concept SpecialPrintable = requires {
    typename T::SpecialPrint;
};

struct Class {
    template<class Text>
    Class& operator<<(const Text& text) {
        cout << text << endl;
        return *this;
    }
    
    template <SpecialPrintable Special>
    Class& operator<<(const Special& text) {
        specialPrint(text);        
        return *this;
    }
    
    template<uint8_t i>
    void specialPrint(const Id<i>& text) {
        cout << (int)i << endl;
    }
};

template<uint8_t i>
struct Id {
    constexpr static uint8_t id = i;
    using SpecialPrint = void;
    // какие-то элементы класса с методами
};
. . . . .

template<class T, class Dummy = void>
struct IsSpecPrintable { static constexpr bool value = false; };

template<class T>
struct IsSpecPrintable<T, typename T::SpecialPrint> { static constexpr bool value = true; };

struct Class {
    template <class T>
    Class& operator<<(const T& text)
    {
        if constexpr (IsSpecPrintable<T>::value) {
            specialPrint(text);
        } else {
            normalPrint(text);
        }
        return *this;
    }

    template<class Text>
    void normalPrint(const Text& text) {
        cout << text << endl;
    }

    template<uint8_t i>
    void specialPrint(const Id<i>& text) {
        cout << (int)i << endl;
    }
};