Template working with std::string and char []

I wrote a function to trim strings. I want to use it with std::string and char[] type. I used template. When I use my function with string type everything is good, but I can't use it with char []. My code is below:

template<typename T, typename Predicate>
T trimString(const T& str, Predicate pred) {
    auto left = std::find_if_not(str.begin(), str.end(), pred);
    auto right = std::find_if_not(str.rbegin(), str.rend(), pred);
    return T(left, right.base());
}


int main() {
    std::string text = "      123 example      ";
    //char text[] = "      123 example      ";
    std::cout << text << std::endl;
    std::cout << trimString(text, isspace) << std::endl;
    return 0;
}

When I use it with char [] I have this errors:

Severity	Code	Description	Project	File	Line
Error (active)	E0304	no instance of function template "trimString" matches the argument list	Task3.exe

Severity	Code	Description	Project	File	Line
Error	C2672	'trimString': no matching overloaded function found

Severity	Code	Description	Project	File	Line
Error (active)	E0304	no instance of function template "trimString" matches the argument list	Task3.exe

Disregarding why your code doesn't compile, your actual design problem is here:

return T(...

If you take a type char[10] and trim 2 off the front, do you want to return a char[10]? No, you do not. You want to return eight chars.

That is to say, it doesn't matter whether you are called with a std::string, a std::string_view, a std::array<char,N>, a std::span<char,-1>, a std::vector<char> or a char[N], you always want to return a char buffer whose size can only be determined at runtime when you actually know how much was trimmed away.

Conveniently, C++ has a dynamically sized char buffer, it's called std::string.

So it would be best to change

template <typename T, typename Predicate>
T trimString(const T &str, Predicate pred)
{
    auto left = std::find_if_not(str.begin(), str.end(), pred);
    auto right = std::find_if_not(str.rbegin(), str.rend(), pred);
    return T(left, right.base());
}

into

template <typename T, typename Predicate>
std::string trimString(const T &str, Predicate pred)
{
    auto left = std::find_if_not(str.begin(), str.end(), pred);
    auto right = std::find_if_not(str.rbegin(), str.rend(), pred);
    return std::string(left, right.base());
}

...except.

Except - you're writing this as a template, so your code can work on multiple types of char buffers. And then, you are immediately calling .begin, so it only works on char buffers that implement .begin.

Thankfully, this is a solved problem - you are not the first person who thought that we could generalize over different types of char buffer:

template<typename Predicate>
std::string trimString(std::string_view str, Predicate pred)
{
    auto left = std::find_if_not(str.begin(), str.end(), pred);
    auto right = std::find_if_not(str.rbegin(), str.rend(), pred);
    return std::string(left, right.base());
}

That should solve the whole of the design problem. (Whether the internals of the function work, I haven't checked.)