Detecting different string literals using templates in C++ - c++

Question

I was playing with templates to detect different string literals and I came to following code (try it with C++20):
#include <iostream>
#include <type_traits>
template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, const char*>, int> = 0>
void print_str(T) {
std::cout << "char* print_str\n";
}
template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, const char8_t*>, int> = 0>
void print_str(T) {
std::cout << "char8_t* print_str\n";
}
template <typename T, std::enable_if_t<std::is_same_v<std::decay_t<T>, const wchar_t*>, int> = 0>
void print_str(T) {
std::cout << "wchar_t* print_str\n";
}
int main() {
auto a = "hello"; // prints "char* print_str"
print_str(a);
auto b = L"hello"; // prints "wchar_t* print_str"
print_str(b);
auto c = u8"hello"; // prints "char8_t* print_str"
print_str(c);
}
I use the fact that in C++20, the u8 prefix declares char8_t type. But here are my questions:
Even though u8 prefix is from C++11, it uses char8_t only starting C++20. So how I can detect UTF-8 strings which is prefixed with u8 between C++11 and C++20?
How I can change my templates to detect both for example const char* and char* which same function? I tried to use remove_const<> but it does not work because it won't remove const from const char*.

Answer 1

You can't detect char8_t in languages like C++17 that did not have it. So you have to have constexpr function that detects if it is UTF-8 by examining contents of the string. Such function makes sense with char8_t also. It is simple to construct illegal UTF-8 strings using char8_t. C++17 or less did not contain such functions.
Use or? std::is_same_v<std::decay_t<T>, const char*> || std::is_same_v<std::decay_t<T>, char*>

Answer 2

So how I can detect UTF-8 strings which is prefixed with u8 between C++11 and C++20?
Type of string doesn't ensure encoding.
const char* can be used for utf-8 but also for LATIN-1
In the same way const wchar* is not necessary utf-16.
There is some heuristic to detect encoding.
How I can change my templates to detect both for example const char* and char* which same function? I tried to use remove_const<> but it does not work because it won't remove const from const char*.
const char * != char* const.
You can remove const from the later to obtain char*
You might do
std::is_same_v<std::remove_const_t<std::remove_pointer_t<T>>, char> && std::is_pointer_v<T>
but simply change to:
void print_str(const char*) { std::cout << "char* print_str\n"; }
void print_str(const char8_t*) { std::cout << "char8_t* print_str\n"; }
void print_str(const wchar_t*) { std::cout << "wchar_t* print_str\n"; }
If you insist with template:
template <typename T>
void print_str(const T*) {
if constexpr (std::is_same_v<char, T>) {
std::cout << "char* print_str\n";
} else if constexpr (std::is_same_v<char8_t, T>) {
std::cout << "char8_t* print_str\n";
} else if constexpr (std::is_same_v<wchar_t, T>) {
std::cout << "wchar_t* print_str\n";
}
}