11 emplace_back() 的问题

日期：2023/8/20 出题人：jacky

思考：以下代码为什么在 C++20 以下的版本中无法成功编译，而在 C++20 及以后却可以？

#include <vector>

struct Pos {
    int x;
    int y;
};

int main(){
    std::vector<Pos> vec;
    vec.emplace_back(1, 5);
}

• 难度:★★☆☆☆

12 实现make_vector()

日期：2023/8/28 出题人：jacky

请实现函数 make_vector(...)，使以下代码编译通过（C++20）：

#include <cstdio>
#include <vector>

inline void dbg(const char* msg)
{
    std::puts(msg);
    std::fflush(stdout);
}

struct X {
    X() noexcept
    {
        dbg("X()");
    };

    ~X() noexcept
    {
        dbg("~X()");
    };

    X(const X&)
    {
        dbg("X(const X&)");
    }

    X(X&&) noexcept
    {
        dbg("X(X&&)");
    }
};

void test()
{
    static_assert(requires {
        {
            make_vector(std::vector{1, 2, 3})
        } -> std::same_as<std::vector<std::vector<int>>>;
        {
            make_vector(1, 2, 3)
        } -> std::same_as<std::vector<int>>;
        make_vector(1, 2, 3).size() == 3;
    });
    X    x1;
    X    x2;
    auto vec = make_vector(x1, std::move(x2));
}

int main()
{
    test();
    dbg("test end");
}

运行结果

X()
X()
X(const X&)
X(X&&)
X(const X&)
X(const X&)
~X()
~X()
~X()
~X()
~X()
~X()
test end

• 难度:★★★☆☆

13 关于 return std::move

日期：2023/9/6 出题人：mq白

我们会给出三段使用到了 return std::move 代码。

解释说明这些代码是否有问题，问题在哪，或者没问题，那么为什么要这样使用。

1. 全局函数，返回局部对象，使用 std::move。

   #include<iostream>
   
   struct X{//后续代码不再重复X类
       X() { puts("X()"); }
       X(const X&) { puts("X(const X&)"); }
       X(X&&)noexcept { puts("X(X&&)"); }
       ~X() { puts("~X()"); }
   };
   
   X f(){
       X x;
       return std::move(x);
   }
   
   int main(){
       X x = f();
   }

2. 全局函数，返回局部的引用，使用 std::move。

   X&& f(){
       X x;
       return std::move(x);
   }

3. 类中成员函数，返回数据成员，使用 std::move。

   struct Test {
       X x;
       X f() {
           return std::move(x);
       }
   };

• 难度:★★★☆☆

14 以特殊方法修改命名空间中声明的对象

日期：2023/12/5 出题人：mq白

给出以下代码，不得修改，要求不得以

• ss::a

• using namespace ss

• namespace x = ss，x::a

• using ss::a

• 直接在 ss 命名空间中通过声明引用或指针指向 a，然后再去修改 a

这些方式去修改命名空间 ss 中的对象 a，并且满足运行结果。

需要真的修改了 a，而不是别的东西，诸如更改入口函数等。

不要求你的做法完全符合标准。

#include<iostream>

namespace ss {
    int a = 0;
}

int main() {
    // todo..
    std::cout << ss::a << '\n'; 
}

运行结果

100

• 难度: ★★★★☆

本题其实是“魔法”题，并不是常规的那些，你可能会对本题的存在一些质疑，认为这种东西毫无价值，但这恰恰考察的是别的基础知识，如符号修饰、链接、内存布局。 越是写的奇特，诡异，往往令人印象深刻，这也正是教学的方式。 举个例子，别人和你说“C/C++ 的 #include 的本质是复制”，你可能没什么感觉，但是如果直接写一段代码呢？

int arr[] = {
#include"1.txt"
};

即使这种形式基本上没有任何的实际用途和价值，但是它能教会各位，让各位印象深刻，那也足够了。

15 表达式模板

日期：2024/1/7 出题人：Matrix-A（#159）

1. 使用表达式模板补全下面的代码，实现表达式计算；
2. 指出表达式模板和 STL Ranges 库中哪些视图类似，并指出它们的异同和优缺点。

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

// 为std::vector增加一个自定义的赋值函数
template <typename T>
    requires std::disjunction_v<std::is_integral<T>, std::is_floating_point<T>>
class vector : public std::vector<T> {
public:
    using std::vector<T>::vector;
    using std::vector<T>::size;
    using std::vector<T>::operator[];
    template <typename E>
    vector<T>& operator=(const E& e)
    {
        const auto count = std::min(size(), e.size());
        this->resize(count);
        for (std::size_t idx { 0 }; idx < count; ++idx) {
            this->operator[](idx) = e[idx];
        }
        return *this;
    }
};

/*
// 实现表达式模板类及相关函数
template<...>
struct vector_expr {

};

// operator+
// operator-
// operator*
// operator/
*/

int main()
{
    auto print = [](const auto& v) {
        std::ranges::copy(v, std::ostream_iterator<std::ranges::range_value_t<decltype(v)>> { std::cout, ", " });
        std::cout << std::endl;
    };
    const vector<double> a { 1.2764, 1.3536, 1.2806, 1.9124, 1.8871, 1.7455 };
    const vector<double> b { 2.1258, 2.9679, 2.7635, 2.3796, 2.4820, 2.4195 };
    const vector<double> c { 3.9064, 3.7327, 3.4760, 3.5705, 3.8394, 3.8993 };
    const vector<double> d { 4.7337, 4.5371, 4.5517, 4.2110, 4.6760, 4.3139 };
    const vector<double> e { 5.2126, 5.1452, 5.8678, 5.1879, 5.8816, 5.6282 };

    {
        vector<double> result(6);
        for (std::size_t idx = 0; idx < 6; idx++) {
            result[idx] = a[idx] - b[idx] * c[idx] / d[idx] + e[idx];
        }
        print(result);
    }
    {
        vector<double> result(6);
        result = a - b * c / d + e; // 使用表达式模板计算
        print(result);
    }
    return 0;
}

运行结果

4.73472, 4.05709, 5.038, 5.08264, 5.73076, 5.18673,
4.73472, 4.05709, 5.038, 5.08264, 5.73076, 5.18673,

• 难度: ★★★☆☆

学习链接：

• Wikipedia - Expression templates
• 我们不需要臭名昭著的表达式模板（英文）
• C++语言的表达式模板：表达式模板的入门性介绍
• std::valarray 在一些 STL 实现中使用了表达式模板

16 制造传递函数模板的宏

日期：2024/2/6 出题人：mq白

函数模板不是函数，所以如果要传递，必须实例化，指明模板参数，比如以下代码无法通过编译：

template< class T >
const T& min(const T& a, const T& b) {
    return a < b ? a : b;
}

template<typename F,class...Args>
auto foo(F f,Args&&...args) {
    return f(std::forward<Args>(args)...);
}

int main() {
    const auto result = foo(::min, 2, 3);
    std::cout << result << '\n';
}

除非我们把里面的 ::min 换成 ::min<int>。这显然很麻烦，而且很多时候依然会有问题，比如这个函数模板有多个类型模板参数，又或者它有多个重载：

template< class T >
const T& min(const T& a, const T& b) {
    return a < b ? a : b;
}
template< class T >
T min(std::initializer_list<T> ilist) {
    return std::min(ilist, std::less<>{});
}

template<typename F, class...Args>
auto foo(F f, Args&&...args) {
    return f(std::forward<Args>(args)...);
}

int main() {
    const auto result = foo(::min<int>, 2, 3);
    std::cout << result << '\n';
}

重载决议根本没有任何办法处理。因此，通透函数对象（Transparent function objects）应运而生。

我们要解决以上问题，实现 BY_NAME 宏，从函数模板名创造通透函数对象，使以下代码能够成功编译：

template<typename F, class...Args>
auto foo(F f, Args&&...args) {
    return f(std::forward<Args>(args)...);
}

int main() {
    const auto result = foo(BY_NAME(std::min), 2, 3);
    std::cout << result << '\n';
}

• 难度：★★☆☆☆