一 题目三
# 高性能并行编程与优化 - 第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 <iostream>
#include <vector>
#include <variant>
// 请修复这个函数的定义：10 分
std::ostream &operator<<(std::ostream &os, std::vector<T> 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 <class T1, class T2>
std::vector<T0> operator+(std::vector<T1> const &a, std::vector<T2> const &b) {
// 请实现列表的逐元素加法！10 分
// 例如 {1, 2} + {3, 4} = {4, 6}
}
template <class T1, class T2>
std::variant<T1, T2> operator+(std::variant<T1, T2> const &a, std::variant<T1, T2> const &b) {
// 请实现自动匹配容器中具体类型的加法！10 分
}
template <class T1, class T2>
std::ostream &operator<<(std::ostream &os, std::variant<T1, T2> const &a) {
// 请实现自动匹配容器中具体类型的打印！10 分
}
int main() {
std::vector<int> a = {
1, 4, 2, 8, 5, 7};
std::cout << a << std::endl;
std::vector<double> b = {
3.14, 2.718, 0.618};
std::cout << b << std::endl;
auto c = a + b;
// 应该输出 1
std::cout << std::is_same_v<decltype(c), std::vector<double>> << std::endl;
// 应该输出 {4.14, 6.718, 2.618}
std::cout << c << std::endl;
std::variant<std::vector<int>, std::vector<double>> d = c;
std::variant<std::vector<int>, std::vector<double>> 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 <iostream>
#include <vector>
#include <variant>
#include <utility>
// 请修复这个函数的定义：10 分
template<class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> 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 <class T1, class T2, Operator ops>
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 <class T1, class T2, Operator ops>
struct ops_result {
using type = decltype(cal_ops<T1, T2, ops>(T1{
}, T2{
}));
};
template <class T1, class T2, Operator ops>
using ops_result_t = ops_result<T1, T2, ops>::type;
template <class T1, class T2, Operator ops>
constexpr decltype(auto) vector_operator(std::vector<T1> const& a, std::vector<T2> const& b) {
std::vector<ops_result_t<T1, T2, ops>> 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<T1, T2, ops>(*x, *y))); // NO RVO
return out; //NRVO
}
// 请修复这个函数的定义：10 分
template <class T1, class T2>
//std::vector<T0> operator+(std::vector<T1> const &a, std::vector<T2> const &b) {
constexpr decltype(auto) operator+(std::vector<T1> const& a, std::vector<T2> const& b) noexcept {
// 请实现列表的逐元素加法！10 分
// 例如 {1, 2} + {3, 4} = {4, 6}
return vector_operator<T1, T2, Operator::Add>(a, b);
}
template <class T1, class T2>
//std::variant<T1, T2> operator+(std::variant<T1, T2> const &a, std::variant<T1, T2> const &b) {
constexpr decltype(auto) operator-(std::vector<T1> const& a, std::vector<T2> const& b) noexcept {
return vector_operator<T1, T2, Operator::Sub>(a, b);
}
template <class T1, class T2>
constexpr decltype(auto) operator*(std::vector<T1> const& a, std::vector<T2> const& b) noexcept {
return vector_operator<T1, T2, Operator::Mul>(a, b);
}
template <class T1, class T2>
//std::ostream& operator<<(std::ostream& os, std::variant<T1, T2> const& a) {
// 请实现自动匹配容器中具体类型的打印！10 分
constexpr decltype(auto) operator/(std::vector<T1> const& a, std::vector<T2> const& b) noexcept {
return vector_operator<T1, T2, Operator::Div>(a, b);
}
template<class O, class V, class R, Operator ops, size_t N>
constexpr decltype(auto) op_vector_v(O& o, V const& a, R const& b) noexcept {
if (N == a.index()) {
auto& e = std::get<N>(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<class O, class V, class R, Operator ops, size_t...N>
constexpr decltype(auto) unpack_n_vector(O& o, V const& a, R const& b, std::index_sequence<N...>) noexcept {
static_cast<void>(std::initializer_list<int>{
(op_vector_v<O, V, R, ops, N>(o, a, b), 0)...});
}
template <class... Args, class T>
constexpr decltype(auto) operator+(std::variant<Args...> const& a, std::vector<T> const& b) noexcept {
// 请实现自动匹配容器中具体类型的加法！10 分
std::variant<Args...> out;
unpack_n_vector<decltype(out), decltype(a), decltype(b), Operator::Add>(out, a, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args, class T>
constexpr decltype(auto) operator-(std::variant<Args...> const& a, std::vector<T> const& b) noexcept {
std::variant<Args...> out;
unpack_n_vector<decltype(out), decltype(a), decltype(b), Operator::Sub>(out, a, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args, class T>
constexpr decltype(auto) operator*(std::variant<Args...> const& a, std::vector<T> const& b) noexcept {
std::variant<Args...> out;
unpack_n_vector<decltype(out), decltype(a), decltype(b), Operator::Mul>(out, a, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args, class T>
constexpr decltype(auto) operator/(std::variant<Args...> const& a, std::vector<T> const& b) noexcept {
std::variant<Args...> out;
unpack_n_vector<decltype(out), decltype(a), decltype(b), Operator::Div>(out, a, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args, class T>
constexpr decltype(auto) operator+(std::vector<T> const& b, std::variant<Args...> const& a) noexcept {
// 请实现自动匹配容器中具体类型的加法！10 分
return operator+(a, b);
}
template <class... Args, class T>
constexpr decltype(auto) operator-(std::vector<T> const& b, std::variant<Args...> const& a) noexcept {
return operator-(a, b);
}
template <class... Args, class T>
constexpr decltype(auto) operator*(std::vector<T> const& b, std::variant<Args...> const& a) noexcept {
return operator*(a, b);
}
template <class... Args, class T>
constexpr decltype(auto) operator/(std::vector<T> const& b, std::variant<Args...> const& a) noexcept {
return operator/(a, b);
}
template<class O, class V, Operator ops, size_t N>
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<N>(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<class O, class V, Operator ops, size_t...N>
constexpr decltype(auto) unpack_n_variant(O& o, V const& a, std::index_sequence<N...>) noexcept {
static_cast<void>(std::initializer_list<int>{
(op_variant_v<O, V, ops, N>(o, a), 0)...});
}
template <class... Args>
constexpr decltype(auto) operator+(std::variant<Args...> const& a, std::variant<Args...> const& b) noexcept {
// 请实现自动匹配容器中具体类型的加法！10 分
auto out = a;
unpack_n_variant<decltype(out), decltype(a), Operator::Add>(out, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args>
constexpr decltype(auto) operator-(std::variant<Args...> const& a, std::variant<Args...> const& b) noexcept {
auto out = a;
unpack_n_variant<decltype(out), decltype(a), Operator::Sub>(out, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args>
constexpr decltype(auto) operator*(std::variant<Args...> const& a, std::variant<Args...> const& b) noexcept {
auto out = a;
unpack_n_variant<decltype(out), decltype(a), Operator::Mul>(out, b, std::index_sequence_for<Args...>{
});
return out;
}
template <class... Args>
constexpr decltype(auto) operator/(std::variant<Args...> const& a, std::variant<Args...> const& b) noexcept {
auto out = a;
unpack_n_variant<decltype(out), decltype(a), Operator::Div>(out, b, std::index_sequence_for<Args...>{
});
return out;
}
template<class V, size_t N>
decltype(auto) print_v(std::ostream& os, V const& a) {
if (N == a.index())
os << std::get<N>(a);
}
template<class V, size_t...N>
std::ostream& unpack_n_print(std::ostream& os, V const& a, std::index_sequence<N...>) {
static_cast<void>(std::initializer_list<int>{
(print_v<V, N>(os, a), 0)... });
return os;
}
template <class... Args>
requires (sizeof...(Args) > 0) // no std::variant<>
std::ostream& operator<<(std::ostream& os, std::variant<Args...> const& a) {
// 请实现自动匹配容器中具体类型的打印！10 分
return unpack_n_print(os, a, std::index_sequence_for<Args...>{
});
}
int main() {
std::vector<int> a = {
1, 4, 2, 8, 5, 7};
std::cout << a << std::endl;
std::vector<double> b = {
3.14, 2.718, 0.618};
std::cout << b << std::endl;
auto c = a + b;
// 应该输出 1
std::cout << std::is_same_v<decltype(c), std::vector<double>> << std::endl;
// 应该输出 {4.14, 6.718, 2.618}
std::cout << c << std::endl;
std::variant<std::vector<int>, std::vector<double>> d = c;
std::variant<std::vector<int>, std::vector<double>> e = a;
d = d + c + e;
// 应该输出 {9.28, 17.436, 7.236}
std::cout << d << std::endl;
return 0;
}
三 成功运行
