Тип аргумента template<typename .Args>

template<typename ...Args>
void Foo()(Args && ...args)
{
    using dummy = char[];
    (void)dummy
    {
        (std::is_same<Args, тут некоторый тип>() && (abort(), 0))...
    };

typeid(Args).name()

//g++  5.4.0
 
#include <iostream>
 
namespace detail
{
 
    template<typename T, typename ... Args> struct CountOfImpl { enum { value = CountOfImpl<T, Args...>::value }; };
    
    template<typename T1, typename T2, typename ... Args> struct CountOfImpl<T1, T2, Args...> { enum { value = std::is_same<T1, T2>::value + CountOfImpl<T1, Args...>::value }; };
    
    template<typename T1, typename T2> struct CountOfImpl<T1, T2> { enum { value = std::is_same<T1, T2>::value }; };
 
} //namespace detail
 
template<typename T, typename ... Args>
constexpr size_t countOf(const T &, Args &&...)
{
    return detail::CountOfImpl<T, Args...>::value + 1;
}
 
int main()
{
    std::cout << countOf(1, 2, 3, 4u);
}

#include <iostream>
#include <limits>
 
template<typename Banned, typename T>
void check(T&&)
{
    static_assert(
        !std::is_same<T,Banned>::value,
        "type of T was banned"
    );
}
 
 
 
template<typename Banned, typename ...Args>
void example(Args&& ...args)
{
    using dummy = char[];
    (void)dummy
    {
        (check<Banned>( std::forward<Args>(args) ), '\0' )...
    };
}
 
int main()
{
    //ok
    example<int>(true,true,'f'); 
    
    //error: static assertion failed: type of T was banned
    example<int>(1,true,'f'); 
}

example<???>("test");

template<typename Banned, size_t size>
void check(const char (&)[size])
{
    static_assert(
        !std::is_convertible<const char (&)[size],Banned>::value,
        "type of T was banned"
    );
}

( std::is_convertible<Args, const char*>() && (func(), 0) )...

Foo(42);
int8_t sbytes[] { 42, 42 };
uint8_t ubytes[]{ 42, 42 };
Foo(sbytes);
Foo(ubytes);
Foo(L"test");
wchar_t *test = L"test";
Foo(test);
const char *test2 = "test";
Foo(test2); //func()
Foo("test"); //func()
char *test3 = (char*)test2;
Foo(test3); //func()

template<typename ...Args>
void Foo(Args && ...args)
{
    using dummy = char[];
    (void)dummy
    {
        std::is_convertible<Args, const char*>() && (AddMbArg(args), 1) || (AddArg(args), 1)...
    };  
}