[C++面试] C++中各类括号的差异：[]、{}、＜＞、()

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> 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]

尖括号 <> 在模板和泛型编程中的作用是什么？​ 

1. 模板参数声明​：定义模板时指定类型或值参数，如 template <typename T>
2. ​模板实例化​：如 vector<int> 表示存储整数的容器
3. ​类型约束​（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 + 3

SFINAE约束： 结合 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