28

I want to check if a type is instantiation of a particular template during compilation.

For example:

  1. std::vector<int> is instantiation of std::vector
  2. std::array<int, 5> is instantiation of std::array

I can make a test that works for case 1 but does not work for case 2.

#include <iostream>
#include <type_traits>
#include <string>
#include <vector>
#include <array>
#include <queue>
template<template<typename...> class, typename...>
struct is_instantiation : public std::false_type {};

template<template<typename...> class U, typename... T>
struct is_instantiation<U, U<T...>> : public std::true_type {};

int main() {
    using A = std::vector<int>;
    std::cout << is_instantiation<std::vector, A>::value << "\n";
    std::cout << is_instantiation<std::queue, A>::value << "\n";
    // std::cout << is_instantiation<std::array, A>::value << "\n";
}

How to make it work for both cases?

I tried auto, but can't make it work.

Advantages of auto in template parameters in C++17

SergeyA
  • 61,605
  • 5
  • 78
  • 137
R zu
  • 2,034
  • 12
  • 30
  • 16
    If you are only interested in STL container types, you will have to make a special case for array - as far as I can remember, it's the only template container which accepts non-type template parameters. If you are interested in **any** templates, I do not see a way to make it work, as there is no common syntax for type and non-type templates. – SergeyA May 11 '18 at 05:09
  • https://stackoverflow.com/questions/17390605/doing-a-static-assert-that-a-template-type-is-another-template – ecatmur Mar 04 '21 at 10:15

1 Answers1

3

Spezialized std::array size

The only way I see is to make specialized Array classes with pre-defined array sizes. Something like this:

#include <iostream>
#include <type_traits>
#include <string>
#include <vector>
#include <array>
#include <queue>
template<template<typename...> class, typename...>
struct is_instantiation : public std::false_type {};

template<template<typename...> class U, typename... T>
struct is_instantiation<U, U<T...>> : public std::true_type {};

template <class T> class My5Array {
    public:
    My5Array() { }
    private:
    std::array<T, 5> arr;
};

template <class T> class My10Array {
    public:
    My10Array() { }
    private:
    std::array<T, 10> arr;
};

int main() {
    using A = std::vector<int>;
    using B = My5Array<int>;
    std::cout << is_instantiation<std::vector, A>::value << "\n";
    std::cout << is_instantiation<std::queue, A>::value << "\n";
    std::cout << is_instantiation<My5Array, A>::value << "\n";
    std::cout << is_instantiation<My5Array, B>::value << "\n";
    std::cout << is_instantiation<My10Array, B>::value << "\n";
}

prints

1
0
0
1
0

Of course, there are disadvantages:

  • possibly waste of memory due to fixed array size
  • multiple classes needed for desired array sizes
  • usage of non-standard type MyXArray
  • obviously an instance of My5Array cannot be an instance of My10Array at the same time (see var B in code above)

1st possible alternative: std::dynarray

I have also found std::dynarray, which could work instead of std::array, but I think that it is not yet included in the latest C++ standards. Maybe worth keeping an eye on it.

2nd possible alternative: just let it drop

The standard container available are possibly sufficient for most applications.

tangoal
  • 724
  • 1
  • 9
  • 28