Question

我有下面的代码可以工作，但是我对它的工作方式感到困惑。

<div class="card-body">
          ...
          <p class="card-text read-more-wrap">nach ... einer Woche.<br>
             <span class="extra-text"> Fa...die 2. Phase</span>
          </p>
          <button data-show-more="Mehr Lesen" data-show-less="Weniger anzeigen" class="btn btn-secondary card-btn toggle">Mehr Lesen</button>
           ...
</div>

输出：

123

我的困惑：

我希望能印出321。

我要下订单：

template<typename ...Args>
void print(Args&&... args) {
    (std::cout << ... << std::forward<Args>(args)) << '\n';
}
int main()
{
    print(1,2.0,"3");
}

但是我无法编译...

Answer 1

...的位置指定左侧或右侧的关联性，但不更改参数的顺序-您可以在(std::cout << x) << y和std::cout << (x << y)之间进行选择。后者可能无法编译。

如果要以相反的顺序打印值，则需要使用一些技巧。这是示例：

#include <type_traits>
#include <iostream>

template <typename T>
struct ReversePrinter
{
    ReversePrinter(T val) : val(val) { }

    template <typename U>
    ReversePrinter<T> operator<<(const ReversePrinter<U>& other) const
    {
        std::cout << other.val;
        return *this;
    }

    T val;
};

template <typename T>
std::ostream& operator<<(std::ostream& stream, const ReversePrinter<T>& val)
{
    return stream << val.val;
}

template <typename... Args>
void print(Args... args)
{
    std::cout << (ReversePrinter(args) << ...);
}

int main()
{
    print(100, 200, 300.0); //prints 300200100
}

Answer 2

很少的诡计，（目前尚无更好的选择），您可以执行以下操作：

不确定是否有直接方法

// Your original function
template<typename ...Args>
void print(Args&&... args) {
    (std::cout << ... << std::forward<Args>(args)) << '\n';
}

template<typename ...Args>
struct changeorder;

template<>
struct changeorder<>
{
    template<typename ...OtherArgs>
    static void invoke(OtherArgs const&... otherargs)
    {
        print(otherargs...);
    }
};

template<typename T, typename ...Args>
struct changeorder<T, Args...> 
{
    template<typename ...OtherArgs>
    static void invoke(T const& t, Args const&... args, 
                      OtherArgs const&... otherargs)
    {
        // 1st parameter send first
        changeorder<Args...>::invoke(args..., t, otherargs...);
    }
};

template<typename A, typename ...Args>
void reverseprint(A const& a, Args const&... args)
{
    changeorder<Args...>::invoke(args..., a);
}

Excel-dialect

Answer 3

模板魔术师的标准入门解决方案是std::index_sequence。
为了使参数可索引，可以使用std::tuple。

template <std::size_t... N, class T>
void print_reverse_impl(std::index_sequence<N...>, std::ostream& os, T t) {
    (os << ... << std::get<std::tuple_size_v<T> - N - 1>(t));
}

template <class... T>
void print_reverse(std::ostream& os, T&&... t) {
    print_reverse_impl(std::make_index_sequence<sizeof...(t)>(), os, std::forward_as_tuple(t...));
}

不过，如果您的工具箱中有static_for()（您确实应该），这会更简单：

template <class... T>
void print_reverse(std::ostream& os, T&&... t) {
    static_for<sizeof...(t)>([&](auto n){
        os << std::get<sizeof...(t) - n - 1>(std::forward_as_tuple(t...));
    });
}

使用C ++ 20，也可以将其编写为：

void print_reverse(std::ostream& os, auto&&... t) {
    [&]<auto... N>(std::index_sequence<N...>, auto all){
        (os << ... std::get<sizeof...(t) - N - 1>(all));
    }(std::make_index_sequence<sizeof...(t)>(), std::forward_as_tuple(t...));
}

顺便说一句，我切断了对std::forward的所有调用，因为无论如何，标准库无论如何都会将这些右值引用缩减为左值引用。

Answer 4

折叠表达式尊重您使用的运算符的优先级和关联性。但是对于某些运营商，您可以做更多富有创意的左右折页。要考虑的唯一变量是操作数的顺序。 C ++ 17引入了赋值运算符左右之间的先于关系，因此它们的操作更加直观。右侧以及所有相关的副作用必须首先发生。

因此，一个完全独立的问题解决方案如下所示：

template <typename... Args>
void print(Args&& ...args) {
   int dum = 0;
   (... = (std::cout << args, dum));
}

这里是live。

它使用逗号打印，同时以强制执行我们想要的评估顺序的方式为其自身分配dum。

折叠表情和提示

4 个答案: