Recursive template parameter pack programming

Question

I'm pretty new to C++ template programming. I'd like to design a function element such as e.g.

element<3, 3, 3, 3, 3> will return 3

element<3, 3, 2> will fail an assertion

#include <iostream>
#include <cstdlib>

namespace meta
{       
  template<typename T>
  constexpr T element(T x)
  {
    return x;
  }

  template<typename T, typename... Ts>
  constexpr T element(T x, Ts... xs)
  {
    constexpr T oth = element(xs...);             // $C$
    static_assert(oth == x, "element Mismatch");
    return x;
  }

  template<int... DIMS>
  void get_elements()
  {
    std::cout << "elements " << element(DIMS...); // $A$
  }
}

int main(int argc, char ** argv)
{
  meta::get_elements<2, 3, 4>();                  // $B$

  static constexpr int D1 = 3, D2 = 3;

  meta::get_elements<D1, D2>();
}

But GCC with std=c++14 is failing with

In instantiation of ‘constexpr T meta::element(T, Ts ...) [with T = int; Ts = {int, int}]’:

$A$: required from ‘void meta::get_elements() [with int ...DIMS = {2, 3, 4}]’

$B$: required from here

$C$: error: ‘xs#0’ is not a constant expression

$C$: error: ‘xs#1’ is not a constant expression

I'd like to exploit recursion to perform an equality check on each template argument in the list, and return one of them if they're all equal.

Now the error message doesn't match the code. Take your time, no one is in a hurry ;) — Quentin, Apr 30 '18 at 08:48
Finally found a good [possible duplicate](https://stackoverflow.com/questions/23569309/c11-constexpr-function-pass-parameter). — Quentin, Apr 30 '18 at 08:56

score 2 · Answer 1 · answered Apr 30 '18 at 08:54

Here is a simple solution in C++17:

template <int Head, int... Tail> struct element
{
    static_assert((... && (Head == Tail)), "missmatch elements");
    static constexpr auto value = Head;
};

template <int... I> constexpr auto element_v = element<I...>::value;

auto test()
{
    // element_v<3, 3, 1>; // assert fail

    constexpr int A = 3, B = 3;
    return element_v<3, 3, A, B>;
}

See it on godbolt

W.F. · Answer 2 · 2018-04-30T09:07:03.667

Or pre-c++17 (no recursion):

#include <iostream>
#include <cstdlib>
#include <type_traits>


namespace meta
{     

  template <bool...>
  struct boolpack { };

  template <bool... Bs>
  struct all_of: std::is_same<boolpack<Bs..., true>, boolpack<true, Bs...>> { };


  template<int FIRST, int... DIMS>
  constexpr void get_elements()
  {
      static_assert(all_of<DIMS==FIRST...>::value, "!");
      std::cout << "elements " << FIRST;
  }
}

int main(int argc, char ** argv)
{
  static constexpr int D1 = 3, D2 = 3;

  meta::get_elements<D1, D2>();
  //meta::get_elements<D1, D2, 2>(); //fail
}

[see it live]

Edited: all_of inspired by Jarod42.

score 2 · Accepted Answer · answered Apr 30 '18 at 08:58

parameters are not constexpr.

You might use std::integral_constant to bypass that

namespace meta
{       
  template<typename T, T V>
  constexpr std::integral_constant<T, V> element(std::integral_constant<T, V>)
  {
    return {};
  }

  template<typename T, T V, typename... Ts>
  constexpr std::integral_constant<T, V> element(std::integral_constant<T, V> x, Ts... xs)
  {
    constexpr auto oth = element(xs...);             // $C$
    static_assert(oth() == x(), "element Mismatch");
    return {};
  }

  template<int... DIMS>
  void get_elements()
  {
    std::cout << "elements " << element(std::integral_constant<int, DIMS>{}...); // $A$
  }
}

Recursive template parameter pack programming

3 Answers3