目录

一 题目三

二 代码答案抄写

三 成功运行

一 题目三

# 高性能并行编程与优化 - 第0x讲的回家作业

通过 pull request 提交作业。会批分数，但是：

没有结业证书，回家作业仅仅作为评估学习效果和巩固知识的手段，不必为分数感到紧张 :)
量力而行，只要能在本课中，学到昨天的自己不懂的知识，就是胜利，没必要和别人攀比。
注意不要偷看别人的作业哦！

- 课件：https://github.com/parallel101/course
- 录播：https://space.bilibili.com/263032155

作业提交时间不限 :) 即使完结了还想交的话我也会看的~ 不过最好在下一讲开播前完成。

- 如何开 pull request：https://zhuanlan.zhihu.com/p/51199833
- 如何设置 https 代理：https://www.jianshu.com/p/b481d2a42274

## 评分规则

- 完成作业基本要求 50 分（作业要求详见作业代码）
- 能够在 PR 描述中用自己的话解释 25 分
- 代码格式规范、能够跨平台 5 分
- 有自己独特的创新点 20 分
- 明显抄袭现象 -100 分

## 关于内卷

如果你把 variant 的 operator<< 改成了基于变长模板参数的，或是实现了其他运算符：
只要是在 **满足作业要求的基础** 上，这是件好事！
老师会酌情加分，视为“独特的创新点”，但最多不超过 20 分。

#include 
#include 
#include 

// 请修复这个函数的定义：10 分
std::ostream &operator<<(std::ostream &os, std::vector const &a) {
    os << "{";
    for (size_t i = 0; i < a.size(); i++) {
        os << a[i];
        if (i != a.size() - 1)
            os << ", ";
    }
    os << "}";
    return os;
}

// 请修复这个函数的定义：10 分
template 
std::vector operator+(std::vector const &a, std::vector const &b) {
    // 请实现列表的逐元素加法！10 分
    // 例如 {1, 2} + {3, 4} = {4, 6}
}

template 
std::variant operator+(std::variant const &a, std::variant const &b) {
    // 请实现自动匹配容器中具体类型的加法！10 分
}

template 
std::ostream &operator<<(std::ostream &os, std::variant const &a) {
    // 请实现自动匹配容器中具体类型的打印！10 分
}

int main() {
    std::vector a = {1, 4, 2, 8, 5, 7};
    std::cout << a << std::endl;
    std::vector b = {3.14, 2.718, 0.618};
    std::cout << b << std::endl;
    auto c = a + b;

    // 应该输出 1
    std::cout << std::is_same_v> << std::endl;

    // 应该输出 {4.14, 6.718, 2.618}
    std::cout << c << std::endl;

    std::variant, std::vector> d = c;
    std::variant, std::vector> e = a;
    d = d + c + e;

    // 应该输出 {9.28, 17.436, 7.236}
    std::cout << d << std::endl;

    return 0;
}

二 代码答案抄写

//参考代码：https://github.com/parallel101/hw03/pull/24/files

#include 
#include 
#include 
#include 

// 请修复这个函数的定义：10 分
template
std::ostream &operator<<(std::ostream &os, std::vector const &a) {
    os << "{";
    for (size_t i = 0; i < a.size(); ++i) {
    //for (size_t i = 0; i < a.size(); i++) {
        os << a[i];
        if (i != a.size() - 1)
            os << ", ";
    }
    os << "}";
    return os;
}

// 支持加减乘除
enum class Operator {
    Add,
    Sub,
    Mul,
    Div
};

template 
constexpr decltype(auto) cal_ops(const T1& a, const T2& b) noexcept {
    static_assert(ops == Operator::Add || ops == Operator::Sub || ops == Operator::Mul || ops == Operator::Div);
    if constexpr (ops == Operator::Add) return a + b;
    else if constexpr (ops == Operator::Sub) return a - b;
    else if constexpr (ops == Operator::Mul) return a * b;
    else if constexpr (ops == Operator::Div) return a / b; // RVO
}

template 
struct ops_result {
    using type = decltype(cal_ops(T1{}, T2{}));
};

template 
using ops_result_t = ops_result::type;

template 
constexpr decltype(auto) vector_operator(std::vector const& a, std::vector const& b) {
    std::vector> out;
    out.reserve(std::min(a.size(), b.size()));
    auto x = a.cbegin();
    auto y = b.cbegin();
    for (; x != a.cend() && y != b.cend(); ++x, ++y)
        out.push_back(std::move(cal_ops(*x, *y))); // NO RVO
    return out; //NRVO
}


// 请修复这个函数的定义：10 分
template 
//std::vector operator+(std::vector const &a, std::vector const &b) {
constexpr decltype(auto) operator+(std::vector const& a, std::vector const& b) noexcept {
    // 请实现列表的逐元素加法！10 分
    // 例如 {1, 2} + {3, 4} = {4, 6}
    return vector_operator(a, b);
}

template 
//std::variant operator+(std::variant const &a, std::variant const &b) {
constexpr decltype(auto) operator-(std::vector const& a, std::vector const& b) noexcept {
    return vector_operator(a, b);
}


template 
constexpr decltype(auto) operator*(std::vector const& a, std::vector const& b) noexcept {
    return vector_operator(a, b);
}


template 
//std::ostream& operator<<(std::ostream& os, std::variant const& a) {
    // 请实现自动匹配容器中具体类型的打印！10 分
constexpr decltype(auto) operator/(std::vector const& a, std::vector const& b) noexcept {
        return vector_operator(a, b);
}


template
constexpr decltype(auto) op_vector_v(O& o, V const& a, R const& b) noexcept {
    if (N == a.index()) {
        auto& e = std::get(a);
        if constexpr (ops == Operator::Add) o = e + b;
        else if constexpr (ops == Operator::Sub) o = e - b;
        else if constexpr (ops == Operator::Mul) o = e * b;
        else if constexpr (ops == Operator::Div) o = e / b;
    }
}

template
constexpr decltype(auto) unpack_n_vector(O& o, V const& a, R const& b, std::index_sequence) noexcept {
    static_cast(std::initializer_list{(op_vector_v(o, a, b), 0)...});
}

template 
constexpr decltype(auto) operator+(std::variant const& a, std::vector const& b) noexcept {
    // 请实现自动匹配容器中具体类型的加法！10 分
    std::variant out;
    unpack_n_vector(out, a, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator-(std::variant const& a, std::vector const& b) noexcept {
    std::variant out;
    unpack_n_vector(out, a, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator*(std::variant const& a, std::vector const& b) noexcept {
    std::variant out;
    unpack_n_vector(out, a, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator/(std::variant const& a, std::vector const& b) noexcept {
    std::variant out;
    unpack_n_vector(out, a, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator+(std::vector const& b, std::variant const& a) noexcept {
    // 请实现自动匹配容器中具体类型的加法！10 分
    return operator+(a, b);
}

template 
constexpr decltype(auto) operator-(std::vector const& b, std::variant const& a) noexcept {
    return operator-(a, b);
}

template 
constexpr decltype(auto) operator*(std::vector const& b, std::variant const& a) noexcept {
    return operator*(a, b);
}

template 
constexpr decltype(auto) operator/(std::vector const& b, std::variant const& a) noexcept {
    return operator/(a, b);
}

template
constexpr decltype(auto) op_variant_v(O& o, V const& a) noexcept {
    static_assert(ops == Operator::Add || ops == Operator::Sub || ops == Operator::Mul || ops == Operator::Div);
    if (N == a.index()) {
        auto& e = std::get(a);
        if constexpr (ops == Operator::Add) o = o + e;
        else if constexpr (ops == Operator::Sub) o = o - e;
        else if constexpr (ops == Operator::Mul) o = o * e;
        else if constexpr (ops == Operator::Div) o = o / e;
    }
}

template
constexpr decltype(auto) unpack_n_variant(O& o, V const& a, std::index_sequence) noexcept {
    static_cast(std::initializer_list{(op_variant_v(o, a), 0)...});
}

template 
constexpr decltype(auto) operator+(std::variant const& a, std::variant const& b) noexcept {
    // 请实现自动匹配容器中具体类型的加法！10 分
    auto out = a;
    unpack_n_variant(out, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator-(std::variant const& a, std::variant const& b) noexcept {
    auto out = a;
    unpack_n_variant(out, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator*(std::variant const& a, std::variant const& b) noexcept {
    auto out = a;
    unpack_n_variant(out, b, std::index_sequence_for{});
    return out;
}

template 
constexpr decltype(auto) operator/(std::variant const& a, std::variant const& b) noexcept {
    auto out = a;
    unpack_n_variant(out, b, std::index_sequence_for{});
    return out;
}

template
decltype(auto) print_v(std::ostream& os, V const& a) {
    if (N == a.index())
        os << std::get(a);
}

template
std::ostream& unpack_n_print(std::ostream& os, V const& a, std::index_sequence) {
    static_cast(std::initializer_list{(print_v(os, a), 0)... });
    return os;
}

template 
    requires (sizeof...(Args) > 0)  // no std::variant<>
std::ostream& operator<<(std::ostream& os, std::variant const& a) {
    // 请实现自动匹配容器中具体类型的打印！10 分
    return unpack_n_print(os, a, std::index_sequence_for{});
}

int main() {
    std::vector a = {1, 4, 2, 8, 5, 7};
    std::cout << a << std::endl;
    std::vector b = {3.14, 2.718, 0.618};
    std::cout << b << std::endl;
    auto c = a + b;

    // 应该输出 1
    std::cout << std::is_same_v> << std::endl;

    // 应该输出 {4.14, 6.718, 2.618}
    std::cout << c << std::endl;

    std::variant, std::vector> d = c;
    std::variant, std::vector> e = a;
    d = d + c + e;

    // 应该输出 {9.28, 17.436, 7.236}
    std::cout << d << std::endl;

    return 0;
}

三 成功运行