C++的std::is_aggregate是标准库
std::is_aggregate的基本用法
std::is_aggregate是一个类模板，接收一个类型参数，继承自std::integral_constant<bool, 值>，其中值部分在类型属于聚合类型时为true，否则为false。使用时需要包含<type_traits>头文件，典型用法如下：
#include <iostream>
#include <type_traits>
struct NormalStruct {
int a;
double b;
};
class NormalClass {
public:
int x;
int y;
};
int main() {
// 判断普通结构体是否为聚合类型
std::cout << std::boolalpha << std::is_aggregate<NormalStruct>::value << std::endl;
// 判断普通类是否为聚合类型
std::cout << std::boolalpha << std::is_aggregate<NormalClass>::value << std::endl;
return 0;
}
上述代码中，NormalStruct和NormalClass都满足聚合类型的基本条件，因此std::is_aggregate的判断结果都为true。
聚合类型的判定条件
要理解std::is_aggregate的作用，首先需要明确C++标准对聚合类型的定义，不同C++标准下的判定规则略有差异：
C++17及之后的聚合类型条件
- 类型必须是数组，或者是类类型（包含struct、class、union）
- 没有用户声明的构造函数（可以是编译器生成的默认构造函数）
- 没有私有或受保护的非静态数据成员
- 没有虚函数
- 没有虚基类
- 如果是类类型，没有用=、{}或者直接初始化语法之外的其他方式初始化的非静态数据成员（C++17新增规则，避免有自定义初始化逻辑的类型被判定为聚合）
不符合聚合类型的常见情况
以下情况会导致类型不是聚合类型，std::is_aggregate返回false：
#include <type_traits>
#include <iostream>
// 情况1：有用户声明的构造函数
struct HasCtor {
HasCtor(int a) : val(a) {}
int val;
};
// 情况2：有私有非静态数据成员
class PrivateMember {
int x;
public:
int y;
};
// 情况3：有虚函数
struct HasVirtual {
virtual void func() {}
int a;
};
int main() {
std::cout << std::boolalpha << std::is_aggregate<HasCtor>::value << std::endl; // false
std::cout << std::boolalpha << std::is_aggregate<PrivateMember>::value << std::endl; // false
std::cout << std::boolalpha << std::is_aggregate<HasVirtual>::value << std::endl; // false
return 0;
}
std::is_aggregate对初始化的影响
std::is_aggregate的判断结果直接决定了类型是否支持聚合初始化，聚合初始化是一种不需要调用构造函数的初始化方式，直接用花括号包裹初始化值列表即可：
支持聚合初始化的场景
当std::is_aggregate<T>::value为true时，类型T可以直接使用聚合初始化：
#include <type_traits>
#include <iostream>
struct Point {
int x;
int y;
};
int main() {
// 编译期确认Point是聚合类型
static_assert(std::is_aggregate<Point>::value, "Point should be aggregate");
// 聚合初始化
Point p1 = {1, 2};
Point p2{3, 4};
std::cout << "p1: x=" << p1.x << ", y=" << p1.y << std::endl;
std::cout << "p2: x=" << p2.x << ", y=" << p2.y << std::endl;
return 0;
}
不支持聚合初始化的场景
当std::is_aggregate返回false时，使用聚合初始化会直接编译报错：
#include <type_traits>
struct HasCtor {
HasCtor(int a) : val(a) {}
int val;
};
int main() {
// HasCtor不是聚合类型，以下初始化会报错
// HasCtor obj = {10}; // 编译错误：不能使用初始化列表初始化没有匹配的构造函数
HasCtor obj(10); // 正确，调用用户声明的构造函数
return 0;
}
实际开发中的应用场景
std::is_aggregate通常用于模板元编程中，根据类型是否为聚合类型选择不同的初始化逻辑：
#include <type_traits>
#include <iostream>
struct AggStruct {
int a;
int b;
};
class NonAggClass {
public:
NonAggClass(int x) : m_x(x) {}
int m_x;
};
// 聚合类型初始化函数
template <typename T>
typename std::enable_if<std::is_aggregate<T>::value, T>::type create_obj(int a, int b) {
return T{a, b};
}
// 非聚合类型初始化函数
template <typename T>
typename std::enable_if<!std::is_aggregate<T>::value, T>::type create_obj(int val) {
return T(val);
}
int main() {
auto s = create_obj<AggStruct>(1, 2);
auto c = create_obj<NonAggClass>(10);
std::cout << "s.a=" << s.a << ", s.b=" << s.b << std::endl;
std::cout << "c.m_x=" << c.m_x << std::endl;
return 0;
}
通过std::is_aggregate的编译期判断，可以让模板代码自动适配不同类型的初始化规则，避免手动判断类型属性带来的错误。
std::is_aggregate聚合初始化C++类型特性修改时间：2026-07-21 10:51:34