C++ 中文周刊 第103期

#include <iostream>
#include <algorithm>
#include <memory>

namespace cwt {

class knight {
public:
    explicit knight(std::size_t strength) 
    : m_strength(strength) {}

    std::size_t get_strength() const  { 
        return m_strength; 
    }
    void who_am_i() const  { 
        std::cout << "i'm a knight\n"; 
    }
private:
    std::size_t m_strength;
};

class skeleton {
public:
    explicit skeleton(std::size_t strength) 
    : m_strength(strength) {}

    std::size_t get_strength() const  { 
        return m_strength; 
    }
    void who_am_i() const  { 
        std::cout << "i'm a skeleton\n"; 
    }
private:
    std::size_t m_strength;
};



class character {
public:
    template<typename T, typename Renderer> 
    character(T&& character, Renderer&& renderer) {
        m_character = std::make_unique<c_model<T, Renderer>>(std::move(character), std::move(renderer));
    }

    void who_am_i() const {
        m_character->who_am_i();
    }

    std::size_t get_strength() const {
        return m_character->get_strength();
    }

    void render() {
        m_character->render();
    }
private:   
    struct c_concept {
        virtual ~c_concept() {}
        virtual std::size_t get_strength() const = 0;
        virtual void who_am_i() const = 0;
        virtual void render() const = 0;
    };
    
    template<typename T, typename Renderer>
    struct c_model : public c_concept {
        c_model(T const& value, Renderer const& renderer) 
        : m_character(value), m_renderer(renderer) {};

        std::size_t get_strength() const override {
            return m_character.get_strength(); 
        }
        void who_am_i() const override {
            m_character.who_am_i();
        }

        void render() const override{
            m_renderer(m_character);
        }

        T m_character;
        Renderer m_renderer;
    };
private:
    std::unique_ptr<c_concept> m_character;
};
} // namespace cwt 


struct knight_renderer{
    void operator()(const cwt::knight& k) const {
        std::cout << "I'll take care of rendering" << std::endl;
    }
};

void knight_render_function(const cwt::knight& knight){
    std::cout << "I could also render a knight" << std::endl;
}

int main(){
    cwt::character character{cwt::knight(10), knight_renderer{}};
    character.render();

    character = cwt::character{cwt::knight(10), [](const cwt::knight& k){
        knight_render_function(k);
    }};
    character.render();

    character = cwt::character{cwt::skeleton(2), [](const cwt::skeleton& s){
        std::cout << "This might be another rendering technique" << std::endl;
    }};
    character.render();
}

#include <algorithm>
#include <ranges>
#include <iostream>

int main() {
    std::pair<int, std::string_view> pairs[] = {
        {2, "foo"}, {1, "bar"}, {0, "baz"}
    };

    // member access:
    std::ranges::sort(pairs, std::ranges::less{}, 
        &std::pair<int, std::string_view>::first);

    // a lambda:
    std::ranges::sort(pairs, std::ranges::less{}, 
        [](auto const& p) { return p.first; });
}

#include <algorithm>
#include <vector>
#include <iostream>
#include <ranges>

struct Product {
    std::string name_;
    double value_ { 0.0 };
};

int main() {
    std::vector<Product> prods{7, {"Box ", 1.0}};

    // standard version:  
    std::transform(begin(prods), end(prods), begin(prods), 
        [v = 0](const Product &p) mutable {
            return Product { p.name_ + std::to_string(v++), 1.0};
        }
    );
    for (auto &p : prods) std::cout << p.name_ << ", ";
    std::cout << '\n';

    // ranges version:  
    std::ranges::transform(prods, begin(prods), 
        [v = 0](const std::string &n) mutable {
            return Product { n + std::to_string(v++), 1.0};
        }, 
        &Product::name_);
    for (auto &p : prods) std::cout << p.name_ << ", ";
}

consteval auto foo(const auto (&value)[1]) { return value[0]; }
static_assert(42 == foo({42}));

double min = a[0];
for (int i = 1; i < n; i++) {
    if (a[i] < min) { min = a[i] };
}
double max = a[0];
for (int i = 1; i < n; i++) {
    if (a[i] > max) { max = a[i] };
}

     This site is open source. [Improve this page](https://github.com/wanghenshui/cppweeklynews/edit/dev/posts/103.md).