C++中的std::is_compound模板

在C++的标准库中，std::is_compound模板定义于头文件中。该模板可以用于判断一个给定类型是否是复合类型（compound type），即除了内建类型（built-in type）外所有类型。

复合类型是由多种数据类型组合而成的类型，包括数组、函数、指针、引用以及结构体等。内建类型则是由C++语言定义的基本数据类型，如int、char、bool等。

使用示例

下面是一个简单的示例代码，用于判断给定类型是否是复合类型：

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << std::is_compound<int>::value << std::endl; // 输出false
  std::cout << std::is_compound<int*>::value << std::endl; // 输出true
  std::cout << std::is_compound<int&>::value << std::endl; // 输出true
  std::cout << std::is_compound<double[]>::value << std::endl; // 输出true
  std::cout << std::is_compound<void(int)>::value << std::endl; // 输出true
  std::cout << std::is_compound<class MyClass>::value << std::endl; // 输出true
  return 0;
}

这里使用了std::boolalpha来打印bool类型的值，使其在输出为true时显示为”true”，输出为false时显示为”false”。

在上述示例代码中，通过std::is_compound模板分别判断了int、int*、int&、double[]、void(int)和class MyClass这些类型是否为复合类型。其中，int是内建类型，因此返回结果为false；其余类型均由多种数据类型组合而成，因此返回结果均为true。

如何判断是否为内建类型

除了std::is_compound之外，C++标准库还提供了std::is_fundamental模板用于判断一个类型是否为内建类型。

在下面的示例代码中，使用std::is_fundamental模板来判断int、int*、int&、double[]、void(int)和class MyClass这些类型是否为内建类型：

#include <iostream>
#include <type_traits>

int main() {
  std::cout << std::boolalpha;
  std::cout << std::is_fundamental<int>::value << std::endl; // 输出true
  std::cout << std::is_fundamental<int*>::value << std::endl; // 输出false
  std::cout << std::is_fundamental<int&>::value << std::endl; // 输出false
  std::cout << std::is_fundamental<double[]>::value << std::endl; // 输出false
  std::cout << std::is_fundamental<void(int)>::value << std::endl; // 输出false
  std::cout << std::is_fundamental<class MyClass>::value << std::endl; // 输出false
  return 0;
}

其中，int是内建类型，因此返回结果为true。而其余类型均不是内建类型，返回结果均为false。

需要注意的是，指针类型和引用类型虽然不是内建类型，但它们的底层类型是内建类型，因此使用std::is_fundamental模板判断它们的类型会返回false。如果想要判断底层类型是否为内建类型，可以使用std::is_arithmetic或std::is_scalar模板。

如何使用

std::is_compound模板定义如下：

template <class T>
struct is_compound;

该模板接受一个类型T作为参数，返回值是一个bool类型，表示T是否是复合类型。

使用方法很简单，只需要传入要判断的类型作为模板参数即可。如果要判断的类型是复合类型，返回值为true，否则返回false。

下面是一个示例代码，展示了如何使用std::is_compound模板判断类型是否为复合类型：

#include <iostream>
#include <type_traits>

template <typename T>
void print_is_compound() {
  if (std::is_compound<T>::value) {
    std::cout << "Type " << typeid(T).name() << " is a compound type." << std::endl;
  } else {
    std::cout << "Type " << typeid(T).name() << " is not a compound type." << std::endl;
  }
}

int main() {
  print_is_compound<int>(); // 输出 "Type int is not a compound type."
  print_is_compound<int*>(); // 输出 "Type int* is a compound type."
  print_is_compound<int&>(); // 输出 "Type int& is a compound type."
  print_is_compound<float[]>(); // 输出 "Type float[] is a compound type."
  print_is_compound<void(int)>(); // 输出 "Type void(int) is a compound type."
  print_is_compound<class MyClass>(); // 输出 "Type class MyClass is a compound type."
  return 0;
}

在上述代码中，我们定义了一个print_is_compound函数，用于接受模板参数T，然后判断T是否为复合类型并输出结果。通过调用该函数，我们可以方便地判断多种类型的是否为复合类型。