#include <stdio.h>
 
int main(void)
{
    printf("Hello World!\n");
    return 0;
}

#include <iostream>
 
int main(int argc, char *argv[])
{
    std::cout << "Hello World!" << std::endl;
    return 0;
}

#include <iostream>
#include <format>
 
int main(int argc, char *argv[])
{
    std::cout << std::format("Hello World!\n");
    return 0;
}

#include <print>
 
int main(int argc, char *argv[])
{
    std::println("Hello World!");
    return 0;
}

// chaostreff.cppm -> Module Interface File
export module chaostreff;
 
namespace ChaosTreff {
auto getChaotischeViertelstunde() { 
    return "Neue C++ Features - von Gromit";
}
export auto printWelcome() {
    std::println("{}", getChaotischeViertelstunde);
}
} // namespace Chaostreff

// chaostreff.cppm -> Module Interface File
export module chaostreff;
 
namespace ChaosTreff {
auto getChaotischeViertelstunde() { 
    return "Neue C++ Features - von Gromit";
}
export auto printWelcome() {
    std::println("{}", getChaotischeViertelstunde);
}
} // namespace Chaostreff
 
// main.cpp
import chaostreff;
 
int main() {
    ChaosTreff::printWelcome();
    return 0;
}

#include <vector>
#include <algorithm>
#include <fmt/ranges.h>
 
int main(int argc, char *argv[]) {
    std::vector<int> v{3,2,4,1};
    fmt::print("{}\n", v);
    
    std::sort(v.begin(), v.end());
    
    fmt::print("{}\n", v);
    return 0;
}

#include <vector>
#include <algorithm>
#include <fmt/ranges.h>
 
int main(int argc, char *argv[]) {
    std::vector<int> v{3,2,4,1};
    fmt::print("{}\n", v);
    
    std::ranges::sort(v);
    
    fmt::print("{}\n", v);
    return 0;
}

std::vector<int> v{6, 3, 2, 4, 1};
auto result{ data 
    // [6, 2, 4]
    | views::filter([](const auto& a){ return a % 2 == 0; })
    
    
    
    
    
    
    
    

std::vector<int> v{6, 3, 2, 4, 1};
auto result{ data 
    // [6, 2, 4]
    | views::filter([](const auto& a){ return a % 2 == 0; })
    // [12, 4, 8]
    | views::transform([](const auto& a){ return a * 2.0; })
    
    
    
    
    
    

std::vector<int> v{6, 3, 2, 4, 1};
auto result{ data 
    // [6, 2, 4]
    | views::filter([](const auto& a){ return a % 2 == 0; })
    // [12, 4, 8]
    | views::transform([](const auto& a){ return a * 2.0; })
    // [4, 8]
    | views::drop(1)
    
    
    
    

std::vector<int> v{6, 3, 2, 4, 1};
auto result{ data 
    // [6, 2, 4]
    | views::filter([](const auto& a){ return a % 2 == 0; })
    // [12, 4, 8]
    | views::transform([](const auto& a){ return a * 2.0; })
    // [4, 8]
    | views::drop(1)
    // [8, 4]
    | views::reverse
    
    

std::vector<int> v{6, 3, 2, 4, 1};
auto result{ data 
    // [6, 2, 4]
    | views::filter([](const auto& a){ return a % 2 == 0; })
    // [12, 4, 8]
    | views::transform([](const auto& a){ return a * 2.0; })
    // [4, 8]
    | views::drop(1)
    // [8, 4]
    | views::reverse
    // ["4", "8"]
    | views::transform(
        [](const auto& i){ return std::to_string(i); }) };

 
int add(int a, int b) {
    return a + b;
}
 
 
 
 
 
 
 
 

 
int add(int a, int b) {
    return a + b;
}
 
float add(float a, float b) {
    return a + b;
}
 
 
 
 

 
int add(int a, int b) {
    return a + b;
}
 
float add(float a, float b) {
    return a + b;
}
 
std::string add(const std::string& a,
                const std::string& b) {
    return a + b;
}

template<typename T>
T add(const T& a, const T& b) {
    return a + b;
}
 
 
 
 
 
 
 
 
 

template<typename T>
concept Addable = requires(T a, T b) { a + b; };
 
template<Addable T>
T add(const T& a, const T& b) {
    return a + b;
}

template<typename T>
concept Addable = requires(T a, T b) { a + b; };
 
auto add(Addable const auto& a,
         Addable const auto& b) {
    return a + b;
}

// compiler will generate functions
auto X::operator<=>(const Y&) const = default;

 
class Point {
    int x; int y;
public:
    friend bool operator==(const Point& a, const Point& b) { ... };
    friend bool operator< (const Point& a, const Point& b) { ... };
    friend bool operator!=(const Point& a, const Point& b) { ... };
    friend bool operator<=(const Point& a, const Point& b) { ... };
    friend bool operator> (const Point& a, const Point& b) { ... };
    friend bool operator>=(const Point& a, const Point& b) { ... };
    // other functions
};

#include <compare>
class Point {
    int x; int y;
public:
    auto operator<=>(const Point&) = default;
    // other functions
};
 
 
 
 
 

#include <format>
#include <print>
 
int main(int argc, char *argv[]) {
    std::println("Read {0} bytes from {1}!",
                 256, "file.txt");
    return 0;
}

#include <iostream>
#include <stacktrace>
 
int nested_func(int c)
{
    std::cout << std::stacktrace::current() << '\n';
    return c + 1;
}
 
int func(int b)
{
    return nested_func(b + 1);
}
 
int main()
{
    std::cout << func(777);
}

 
// compile-time pow for uints
consteval std::uint64_t ipow_ct(std::uint64_t base,
                                std::uint8_t exp) {...}
 
constexpr std::uint64_t ipow(std::uint64_t base, std::uint8_t exp) {
    // use a compile-time friendly algorithm
    if consteval {
        return ipow_ct(base, exp);
    }
    // use runtime evaluation 
    else {
        return std::pow(base, exp);
    }
}
 
int main(int, const char* argv[]) {
    static_assert(ipow(0,10) == 0 && ipow(2,10) == 1024);
    std::cout << ipow(std::strlen(argv[0]), 3) << '\n';
}