Dlaczego ekspansja pakietu parametrów działa inaczej w przypadku różnych kompilatorów C++?

Question

Rozszerzenie pakietu parametrów jest odwracane przez kompilator VS2015.

Mam następujący kod:

#include <iostream> 
#include <vector> 


template <typename... T> 
void f_Swallow(T &&...) 
{ 
} 

template <typename... T> 
std::vector<int> f(T ...arg) 
{ 
    std::vector<int> result; 
    f_Swallow 
    (
     [&]() 
     { 

      result.push_back(arg); 
      return true; 
     } 
     ()... 
    ) ; 
    return result; 
} 


using namespace std; 
int main() 
{ 
    auto vec = f(1,2,3,4); 

    for (size_t i = 0; i < vec.size(); ++i) 
     cout << vec[i] << endl; 
} 

Kiedy uruchomić ten kod w Xcode (szczęk-700.1.81), otrzymuję ten wynik:

1 
2 
3 
4 

ale sam przebieg kodu w VS2015 generuje to wyjście:

4 
3 
2 
1 

Dlaczego pakiety parametrów są różnie rozwijane w zależności od kompilatora? Czy istnieje sposób, aby to naprawić bez sprawdzania platformy i wersji kompilatora? Czy standard nie gwarantuje niczego w zamówieniu ekspansji?

Answer 1

Nie jest to kolejność rozwijania pakietu parametrów, która jest inna, jest to kolejność analizowania argumentów funkcji.

f_Swallow 
(
    [&]() 
    { 

     result.push_back(arg); 
     return true; 
    } 
    ()... 
) ; 

Dla zwięzłości, pozwala tylko podać, że lambda nazwę funcN gdzie N jest numer parametru. Biorąc pod uwagę cztery argumenty, paczka parametr zostanie poszerzona dowolnym zgodnego kompilatora w tym:

f_Swallow(func1(), func2(), func3, func4()) ; 

Kolejność oceny argumentów funkcji jest nieokreślone w C++. Kompilator może je ocenić w kolejności (np. Twoja wersja Clang), w odwrotnej kolejności (jak twoja wersja MSVC) lub w dowolnej kolejności, którą lubi. Nie możesz liczyć na kolejność oceny.

Aby uzyskać to, co chcesz, możesz umieścić wyrażenia w kontekście, w którym określona jest kolejność oceny. Na przykład:

template <typename... T> 
std::vector<int> f(T ...arg) 
{ 
    std::vector<int> result; 
    (void)std::initializer_list<int> { (result.push_back(arg), 0)... }; 
    return result; 
} 

---

w C++ 17, będzie można wykonać następujące czynności z fold expressions:

template <typename... T> 
std::vector<int> f(T ...arg) 
{ 
    std::vector<int> result; 
    (result.push_back(arg), ...); 
    return result; 
} 

Answer 2

Pomyślałem, że może to być również napisany tak jak poniżej:

template <typename... T> 
std::vector<int> f(T ...arg) 
{ 
    std::vector<int> result{ arg... }; 
    return result; 
} 

Nie ma potrzeby, aby utworzyć std :: obojętne initializer_list