Why is template<classTp> bool is_array<Tp[]> a partial specialization for template<class T> bool is_array<Tp>?

user_13611002 0
Viewed 118

How to comprehend that template<typename Tp> bool is_array<Tp[]> = true is a partial specialization for template<typename T> bool is_array<Tp> = true?

Here is the related code snippet:

#include<iostream>

template<typename T>
bool is_array = false;

template<typename Tp>
bool is_array<Tp[]> = true;

int main()
{
    std::cout << is_array<int> << std::endl;
    std::cout << is_array<int[]> << std::endl;
}

I've also noticed that generally speaking, the number of template parameters in the partial template specialization is less than the number of template parameters in the primary template.

The partial specializations often are seen like this:

#include<iostream>

template<typename T, typename U>
class add
{
public:
    add(T x, U y)
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;
    }
};

template<typename U>
class add<int, U>
{
    public:
    add(int x, U y)
    {
        std::cout << __PRETTY_FUNCTION__ << std::endl;       
    }
};

int main()
{
    add<int, double>(1, 5.0);
    add<char, int>('a', 9);
}
template-specialization templates c++
3 Answers

For a template to be a specialization of a primary, it needs to be more specialized than the primary. This basically means that the specialization must match a strict subset of types that the primary can match.

In your case, the specialization would match int[], char[], etc. The primary would also match these types, but the primary would additionally match types like int, char, std::vector<std::string> etc.

When specifying a template argument like this is_array<int[]>, the rules say that the specialization is tried first. In this case, Tp[] can be matched to int[] (basically by substituting int for Tp) and so the specialization is chosen.

When specifying a template argument like this is_array<int>, the specialization is tried first, but it fails to match. So then the primary is tried, and that matches, so the primary template is chosen.

As you've mentioned, it is often the case that the specialization has fewer template parameters. This is not necessary, so long as the rule I mentioned above is applicable, i.e. the specialization must match a strict subset of the types that can be matched by the primary.

In fact, the specialization can even have more template parameters than the primary. Again, the requirement is only that the specialization match a subset of types matched by the primary.

user_83728530

Here is intermediate output generated by compiler for your code (reference cppinsights)

Compiler is using the specialized template for arrays.

template<typename T>
bool is_array = false;

template<>
bool is_array<int> = false;
template<>
bool is_array<int []> = true;

template<typename Tp>
bool is_array<Tp[]> = true;

int main()
{
  std::cout.operator<<(is_array<int>).operator<<(std::endl);
  std::cout.operator<<(is_array<int []>).operator<<(std::endl);
}

Now if removed the below code

template<typename Tp>
bool is_array<Tp[]> = true;

compiler will generate

template<typename T>
bool is_array = false;

template<>
bool is_array<int> = false;
template<>
bool is_array<int []> = false;

int main()
{
  std::cout.operator<<(is_array<int>).operator<<(std::endl);
  std::cout.operator<<(is_array<int []>).operator<<(std::endl);
}

You can see that compiler simply replaced T with int[] which is nothing but the second template provided by you, a specialized one.

user_63393950

The specialization can even have more template parameters than the primary. Here is an example:

#include<iostream>

template<typename T>
bool is_array = false;
    
template <typename Tp, int N>
bool is_array<Tp[N]> = true;

int main()
{
    std::cout << is_array<int> << std::endl;
    std::cout << is_array<int[5]> << std::endl;
}
user_136110020
Related