C++ 17：如何使用参数包来明确function中参数的顺序，都是相同的类型

Question

I'm using C++ 17 and want to use template parameters to specify the ordering of the function arguments which all have the same type. The function has a varying number of arguments and the sorting of these arguments varies too.

I have tried to use the following (simplified) code to which uses parameter packs to implement this.

• The struct TheInner is the type used for all function arguments.
• The Outer structs are used to specify the order of the passed parameters to the function.

// In .h file
struct TheInner {};
 
template<typename T> struct Outer
{
  using Inner = T;
};

struct OuterA : Outer<TheInner> {};
struct OuterB : Outer<TheInner> {};

template<class... Outers> void Method(Outers::Inner... inners);
template<> void Method<OuterA, OuterA, OuterB>(TheInner a, TheInner a2, TheInner b);
template<> void Method<OuterA, OuterB, OuterA>(TheInner a, TheInner b, TheInner a2);

// In .cpp file
template<> void Method<OuterA, OuterA, OuterB>(TheInner a, TheInner a2, TheInner b)
{
  ...
}

template<> void Method<OuterA, OuterB, OuterA>(TheInner a, TheInner b, TheInner a2)
{
  ...
}

int main(int argc, char** argv)
{
  Method<OuterA, OuterB, OuterA>(TheInner(), TheInner(), TheInner());
}

This currently results in the following error message on GCC:

main.cpp:15:32: error: variable or field 'Method' declared void
   15 | template<class... Outers> void Method(Outers::Inner... inners);
      |                                ^~~~~~
main.cpp:15:55: error: expected ')' before 'inners'
   15 | template<class... Outers> void Method(Outers::Inner... inners);
      |                                      ~                ^~~~~~~
      |                                                       )
main.cpp:17:23: error: expected initializer before '<' token
   17 | template<> void Method<OuterA, OuterA, OuterB>(TheInner a, TheInner a2, TheInner b)
      |                       ^

Answer 1

I have now discovered (after multiple hours) that I was simply missing a typename keyword before the Outers::Inner type.

A functional code is attached below in the hope that it might help somebody in the future:

// Example program
// In .hpp file
#include <iostream>
#include <string>

struct TheInner {};

template<typename T> struct Outer
{
    using Inner = T;
};

struct OuterA : Outer<TheInner> {};
struct OuterB : Outer<TheInner> {};

template<class... Outers> void Method(typename Outers::Inner... inners);
template<> void Method<OuterA, OuterA, OuterB>(TheInner a, TheInner a2, TheInner b);
template<> void Method<OuterA, OuterB, OuterA>(TheInner a, TheInner b, TheInner a2);

// In .cpp file
// #include <iostream>
// #include <string>

template<> void Method<OuterA, OuterA, OuterB>(TheInner a, TheInner a2, TheInner b)
{
    std::cout << "A" << std::endl;
}

template<> void Method<OuterA, OuterB, OuterA>(TheInner a, TheInner b, TheInner a2)
{
    std::cout << "B" << std::endl;
}

int main()
{
    Method<OuterA, OuterB, OuterA>(TheInner(), TheInner(), TheInner()); // Prints B
    Method<OuterA, OuterA, OuterB>(TheInner(), TheInner(), TheInner()); // Prints A

    // Unimplemented methods:

    // error: too many arguments to function 'void Method(typename Outers::Inner ...) [with Outers = {OuterA, OuterA}]'
    // Method<OuterA, OuterA>(TheInner(), TheInner(), TheInner());

    // undefined reference to `void Method<OuterA, OuterA>(OuterA::Inner, OuterA::Inner)'
    // Method<OuterA, OuterA>(TheInner(), TheInner());
}

The output of the program is:

B
A