如何在可变参数模板中检查非原生类型？实现通用print工具函数

Hey there! Let's figure out how to build that flexible print() function you want—this is totally achievable in C++. The key is using function overloading with templates to handle both native types and vectors of native types seamlessly. Here's a step-by-step solution:

First, the Core Idea #

We'll create two template functions:

1. One to print any native (fundamental) type directly.
2. Another to iterate over a std::vector of native types and print each element using the first function.

Option 1: Strictly Restrict to Native Types #

If you want to make sure the function only works with true native types (int, float, char, bool, etc.), we can use std::is_fundamental from the <type_traits> header to enforce this:

#include <iostream>
#include <vector>
#include <type_traits>

// Print a single native type value
template <typename T>
typename std::enable_if<std::is_fundamental<T>::value>::type
print(const T& value) {
    std::cout << value << " ";
}

// Print a vector of native types
template <typename T>
typename std::enable_if<std::is_fundamental<T>::value>::type
print(const std::vector<T>& vec) {
    std::cout << "[ ";
    for (const auto& elem : vec) {
        print(elem); // Reuse the single-value print function
    }
    std::cout << "]\n";
}

Option 2: Simplified (More Flexible) #

If you don't need strict enforcement (and trust that you'll only pass vectors of printable types), you can skip the type trait check for a simpler implementation:

#include <iostream>
#include <vector>

// Print any single value that can be output to std::cout
template <typename T>
void print(const T& value) {
    std::cout << value << " ";
}

// Print a vector by iterating and printing each element
template <typename T>
void print(const std::vector<T>& vec) {
    std::cout << "[ ";
    for (const auto& elem : vec) {
        print(elem);
    }
    std::cout << "]\n";
}

How to Use It #

Here's a quick test to verify it works with different types:

int main() {
    // Test native types
    print(42);          // int
    std::cout << "\n";
    print(3.14159);     // double
    std::cout << "\n";
    print('Z');         // char
    std::cout << "\n";
    print(true);        // bool
    std::cout << "\n";

    // Test vectors of native types
    std::vector<int> ints = {1, 2, 3, 4, 5};
    print(ints);

    std::vector<float> floats = {1.1f, 2.2f, 3.3f};
    print(floats);

    std::vector<char> chars = {'a', 'b', 'c'};
    print(chars);

    return 0;
}

Why Your Earlier std::vector<int> Version Might Have Failed #

If you only wrote a function for std::vector<int>, it would only work for integer vectors. By using a template parameter T for the vector's element type, we generalize the function to work with any native type vector. Common pitfalls include:

• Forgetting to use templates and trying to manually write overloads for every vector type (tedious and error-prone).
• Not properly overloading the print() function, leading to ambiguous calls or no matching function errors.

If you hit specific compile errors, feel free to share them and we can troubleshoot further!

内容的提问来源于stack exchange，提问作者Raghu