| 括号类型 | 典型场景 | 编译期/运行时 | 安全性考量 |
|---|---|---|---|
() | 函数调用、运算优先级 | 两者 | 注意强制转换风险 |
[] | 数组访问、Lambda捕获 | 运行时主导 | 防止越界访问 |
{} | 统一初始化、聚合类型 | 编译期检查 | 阻止隐式窄化转换 |
<> | 模板实例化、元编程 | 编译期 | 注意模板展开爆炸问题 |
int x{5}; int x(5);有什么区别？
int x{5};
列表初始化。可以用于初始化各种类型的变量，并且在初始化时能避免隐式窄化转换。当使用 int x{5}; 时，它会直接把 5 这个值赋给整型变量 x。
优先调用 initializer_list 构造函数：对于类类型，如果类有 std::initializer_list 构造函数，列表初始化会优先调用该构造函数；
{} 像“盒子”：编译器会严格检查“盒子”里的内容是否完全匹配类型，避免“塞入不合适的东西”（如浮点数转整型）
int x(5);
直接初始化方式。在定义变量 x 时，调用了合适的构造函数（对于内置类型 int 而言，就是简单地赋值），将 5 作为初始值传递给 x。（对于类类型，如果类有 std::initializer_list 构造函数，列表初始化会优先调用该构造函数；直接初始化会根据参数类型调用其他合适的构造函数。）
允许隐式转换：例如 int x(5.0) 会隐式截断为 5，编译器可能仅给出警告
适用于显式调用构造函数：常用于类对象的初始化（如 std::vector<int> vec(5, 1)）
() 像“通道”：即使类型不完全匹配（如浮点数转整型），数据也会“流过去”并截断。
int x{5, 1};和int x(5, 1);
错误的代码。因为 int 类型只能接受一个初始化值。
| 初始化方式 | 括号类型 | 参数含义 | 底层构造函数匹配 | 典型结果 |
|---|---|---|---|---|
vector<int> v1(5, 1) | () | 数量 + 值 | vector(size_type, T) | 5 个 1 |
vector<int> v2{5, 1} | {} | 元素列表 | initializer_list | 2 个元素：5 和 1 |
vector<int> v3(5) | () | 元素数量 | vector(size_type) | 5 个 0 |
vector<int> v4{5} | {} | 单个元素 | initializer_list | 1 个元素：5 |
| int v5(5) | () | 值 | 1 个元素：5 |
vector<int> v(5)：圆括号表示元素数量，std::vector 是一个类模板，其构造函数vector(size_type count)，接受参数来决定如何初始化容器。vector 类的构造函数被设计为：当参数是单一整型时，表示元素数量；当有两个参数（如 vector<int> v(5, 10)）时，第一个参数是数量，第二个是初始值。
int v(5)：直接初始化方式
“圆括号构造，花括号装填；单数花括号是元素，单数圆括号是数量。”
圆括号 () 的主要作用有哪些？
- 表达式优先级控制：改变运算顺序，如
(a + b) * c - 类型转换：显式强制类型转换，如
(int)3.14。建议用static_cast替代。 - 条件/循环语句条件包裹：如
if (x > 0)或while (i < 10) - 函数返回类型声明（C++11后）：如
auto func() -> int。 - 函数调用与定义：如
func(10)，或定义函数时的参数列表void func(int x)
方括号 [] 在C++中的常见用途是什么？
- 数组定义与元素访问：如
int arr[5]和arr[0] = 10 - 运算符重载：用于自定义类的下标访问，如
vector<int>::operator[]。 - Lambda表达式捕获列表：如
[&]表示按引用捕获所有变量
花括号 {} 的初始化规则是什么？与圆括号有何区别？
- 统一初始化（C++11）：支持所有类型的初始化，如
int x{5}、vector<int> v{1,2,3} - 避免隐式窄化转换：
int num{3.14}尝试把double类型的3.14初始化为int类型，这属于窄化转换，使用{}初始化时会被编译器阻止。
// int num{3.14}; int num = static_cast<int>(3.14);- 初始化列表构造函数优先级：若类有
initializer_list构造函数，{}会优先调用它（如vector<int> v(5,1)与v{5,1}结果不同）
std::vector<int> v1(5, 1); // 5个1 → [1,1,1,1,1]
std::vector<int> v2{5, 1}; // 初始化列表 → [5,1]尖括号 <> 在模板和泛型编程中的作用是什么？
- 模板参数声明：定义模板时指定类型或值参数，如
template <typename T> - 模板实例化：如
vector<int>表示存储整数的容器 - 类型约束（C++20概念）：如
template <std::integral T>约束T为整数类型
template <typename T>
T add(T a, T b) { return a + b; } // 模板定义
auto result = add<int>(3, 5); // 显式实例化尖括号 <> 的特殊用法
完全特化：用 template <> 声明针对特定类型的定制实现
template <>
class Stack<bool> { // 完全特化布尔类型的Stack// 位域存储优化等特殊实现
};偏特化：保留部分模板参数泛型，特化其他参数
template <typename T>
class Stack<T*> { // 特化指针类型[8,16](@ref)// 针对指针的优化处理
};通过 <> 实例化类型萃取工具
static_assert(std::is_same_v<int, remove_const<const int>::type>); // 移除const 模板元编程中，<>用于在编译时进行计算和类型操作
#include <iostream>
template <int N>
struct Factorial {static const int value = N * Factorial<N - 1>::value;
};
template <>
struct Factorial<0> {static const int value = 1;
};
int main() {std::cout << Factorial<5>::value << std::endl;return 0;
}模板参数推导
auto val = add<int>(3, 5); // 强制实例化为int版本圆括号 () 的特殊用法
折叠表达式（C++17）：对变参模板参数包进行展开计算，生成(args1 + (args2 + ...))
(args op ...)、(... op args)、(args op ... op init)、(init op ... op args)——常见4种
template <typename... Args>
auto sum(Args... args) { return (args + ...); // 右折叠求和
}// (args + ...) 是右折叠求和，会把参数包 args 里的所有参数相加。
// 若调用 sum(1, 2, 3)，就会计算 1 + 2 + 3SFINAE约束： 结合 decltype 和 enable_if 控制模板重载
template <typename T, typename = enable_if_t<is_integral_v<T>>>
// 约束T为整数类型，若传入非整数类型，该模板就会被忽略。void func(T val) { /*...*/ }编译期条件判断：配合 if constexpr 实现编译时分支
template <typename T>
void process(T val) {if constexpr (is_pointer_v<T>) { // 编译期判断指针类型// 处理指针的逻辑}
}重载函数调用运算符()，让类的对象像函数一样被调用
#include <iostream>
class Adder {
public:int operator()(int a, int b) {return a + b;}
};
int main() {Adder adder;int result = adder(3, 5);std::cout << result << std::endl;return 0;
}花括号 {} 的特殊用法
统一初始化
std::vector<int> vec{1, 2, 3}; // 调用initializer_list构造函数成员初始化列表：在构造函数中初始化模板类成员
template <typename T>
class Widget {T data;
public:Widget(T arg) : data{arg} {} // 支持移动语义[6,9](@ref)
};避免Most Vexing Parse：解决函数声明歧义问题
vector<int> v() 声明函数而非对象
std::vector<int> v{}; // 正确：初始化空向量（而非声明函数）聚合初始化
struct Point { int x,y; };
Point p{1,2}; // 直接初始化成员方括号 [] 的次要用途
Lambda捕获列表：在模板元编程中捕获上下文变量（较少见）
auto lambda = [&](auto x) { /* 按引用捕获外部变量 */ };[=](){} // 值捕获（副本）
[&](){} // 引用捕获（需注意悬垂引用）
[var](){} // 显式捕获特定变量 []在结合std::function和std::bind时，可用于自定义函数对象的捕获和调用。
#include <iostream>
#include <functional>
void printSum(int a, int b) {std::cout << a + b << std::endl;
}
int main() {int x = 5;auto func = std::bind(printSum, x, std::placeholders::_1);std::function<void(int)> f = [func](int y) {func(y);};f(3);return 0;
}[[nodiscard]] int* alloc() { return new int[10]; } // 警告忽略返回值
复合括号的特殊场景
完美转发参数包：结合 () 和 <> 展开参数包
template <typename... Args>
void emplace(Args&&... args) {new (ptr) T(std::forward<Args>(args)...); // 完美转发构造
}模板参数依赖查找（ADL）：函数调用括号触发ADL机制，函数调用中的括号可能触发参数依赖查找
namespace N { struct X{}; void swap(X&, X&); }
N::X a, b;
swap(a,b); // 优先查找N::swap而非std::swap