Сложить выражения и cout

Question

У меня есть следующий код, который работает, но я не совсем понимаю, как он работает.

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

выход:

123

Мое замешательство:

Я бы ожидал печатать 321.

Я хотел бы получить этот заказ:

cout << forward(args) << ... 

но я не могу заставить это скомпилировать ...

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

В выражениях сгиба учитывается приоритет и ассоциативность используемого вами оператора.Но для определенных операторов вы можете делать более креативные левые и правые сгибы.Единственная переменная для учета - это последовательность операндов.В C ++ 17 введено отношение «происходит раньше» между правой и левой сторонами операторов присваивания, поэтому они действуют более интуитивно.Правая сторона и все связанные с ней побочные эффекты должны произойти первыми.

Так что полностью автономное решение вашего вопроса может выглядеть так:

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

Вот оно, live.

Он использует запятую для печати, присваивая dum себе таким образом, чтобы заставить требуемый порядок оценки.

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, потому что эти ссылки на rvalue были бы просто уменьшены до ссылок на lvalue посредством стандартной библиотеки в любом случае.

Answer 4

С несколькими хитростями (в данный момент ничего лучше не получается) вы можете сделать следующее:

Не уверен, что есть прямой путь

// 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);
}

Demo Here