1.使用文件重定向
cpp
$ addexe <infile >outfile
//累加和.exe < test.txt >> ans.txt 追加模式,不覆盖
cpp
strcat(p1,p2); 把p2附加到p1的后面
C++ 复杂指针/数组声明详解
复杂指针声明的核心难点在于 *、[]、() 三者的优先级和结合方向。掌握一套"读法"后,任何复杂声明都能拆解。
一、核心原则:右左法则(Spiral Rule)
读一个声明的固定步骤:
- 从变量名开始 ,先看它右边 ,再看它左边,交替进行。
- 遇到
()表示"函数(返回...)",遇到[]表示"数组(元素是...)",遇到*表示"指针(指向...)",遇到const表示"常量"。 - 优先级 :
[]和()>*;同级时从右往左。 - 括号
()用于改变优先级,是唯一能"打断"结合顺序的东西。
记住一句话:"名字先跟右边结合,再跟左边结合;括号能改变结合对象。"
二、从简单到复杂,逐层拆解
例 1:int *p[10]
int *p[10];
- 先看
p右边:[10]→ p 是数组,10 个元素 - 再看左边:
*→ 元素是指针 - 再看更左:
int→ 指向 int
读作:p 是一个数组,含 10 个元素,每个元素是 int*。
即 "指针数组"(array of pointers)。
cpp
int a, b, c;
int *p[3] = {&a, &b, &c}; // ✅ p 是 3 个 int*
例 2:int (*p)[10]
int (*p)[10];
p被括号括住,先看括号内:*p→ p 是指针- 再看右边:
[10]→ 指向一个含 10 元素的数组 - 再看左边:
int→ 元素是 int
读作:p 是一个指针,指向"含 10 个 int 的数组"。
即 "数组指针"(pointer to array)。
cpp
int arr[10];
int (*p)[10] = &arr; // ✅ p 指向整个数组
// (*p)[3] 访问 arr[3]
⚠️ 这是初学者最容易混淆的一对:
int *p[10]= 指针数组(10 个指针)int (*p)[10]= 数组指针(1 个指针,指向 10 元素数组)
括号的作用是让*先和p结合。
例 3:int **p
int **p;
p右边无,左边*→ p 是指针- 再左边
*→ 指向指针 - 再左边
int→ 指向 int
读作:p 是"指向 int 指针"的指针,即二级指针。
例 4:int *f()
int *f();
f右边是()→ f 是函数- 左边
*→ 返回指针 - 左边
int→ 返回 int*
读作:f 是一个函数,返回 int*。 (注意:() 优先级高于 *,所以先结合函数)
例 5:int (*f)()
int (*f)();
- 括号内
*f→ f 是指针 - 右边
()→ 指向函数 - 左边
int→ 函数返回 int
读作:f 是一个函数指针,指向"返回 int、无参"的函数。
cpp
int add() { return 1; }
int (*f)() = add;
int x = f(); // 调用
对比记忆:
int *f()= 函数,返回int*int (*f)()= 函数指针
例 6:int (*p[10])()
int (*p[10])();
拆解:
p右边[10]→ p 是数组,10 元素- 括号内
*p[10]→ 元素是指针 - 再右边
()→ 指向函数 - 左边
int→ 函数返回 int
读作:p 是"10 个函数指针"的数组,每个函数返回 int。
cpp
int f1(){return 1;}
int f2(){return 2;}
int (*p[2])() = {f1, f2};
例 7:int *(*p)[10]
int *(*p)[10];
p被()括住 → p 是指针- 右边
[10]→ 指向 10 元素数组 - 括号内前面的
*→ 数组元素是指针 - 左边
int→ 指向 int
读作:p 是指针,指向"含 10 个 int* 的数组"。
例 8:int (*p[10])[20](二维数组指针数组)
int (*p[10])[20];
p右边[10]→ p 是 10 元素数组- 括号内
*p[10]→ 元素是指针 - 右边
[20]→ 指向 20 元素数组 - 左边
int→ 数组元素是 int
读作:p 是数组(10 元素),每个元素是"指向含 20 个 int 的数组"的指针。
cpp
int arr[20];
int (*p[10])[20];
p[0] = &arr; // ✅
例 9:返回函数指针的函数
cpp
int (*f(int))(double);
拆解:
f右边(int)→ f 是函数,接受 int 参数- 左边
*被括号括住 → 返回指针 - 该指针右边
(double)→ 指向"接受 double 的函数" - 左边
int→ 该函数返回 int
读作:f 是函数,接受 int,返回"指向函数(接受 double,返回 int)"的指针。
很绕,实际项目中几乎一定会用 typedef:
cpp
using FunPtr = int (*)(double); // 指向"double → int"函数的指针
FunPtr f(int); // 清爽多了
例 10:终极组合 int (*(*p)[10])(double)
cpp
int (*(*p)[10])(double);
p被括号括住 → p 是指针- 右边
[10]→ 指向 10 元素数组 - 再外面
*→ 数组元素是指针 - 右边
(double)→ 指向"接受 double 的函数" - 左边
int→ 函数返回 int
读作:p 是指针,指向"含 10 个函数指针的数组",每个函数接受 double、返回 int。
这种声明现实中几乎不会手写,但面试和阅读老代码时会遇到。
三、const 与指针的位置
const 的位置决定修饰谁:
| 声明 | 含义 |
|---|---|
const int *p |
p 指向 const int(值不可改,指针可改) |
int const *p |
同上(等价写法) |
int * const p |
p 是 const 指针(指针不可改,值可改) |
const int * const p |
都不可改 |
口诀:const 在 * 左边,修饰"被指对象";在 * 右边,修饰"指针本身"。
复杂例子:
cpp
const int * const * p;
// p 是指针,指向"const 指针",该 const 指针指向 const int
四、实战建议:别硬读,用 typedef / using
C++ 项目中几乎没人硬写复杂声明。用别名拆分:
反例(难读)
cpp
int (*(*signal(int, void (*)(int)))(int))(...);
正例(分层)
cpp
using SignalHandler = void (*)(int); // 信号处理函数
using SignalFunc = int (*)(int); // 返回 int 的函数
using Table = SignalFunc[10]; // 函数指针数组
using TablePtr = Table*;
TablePtr get_table(SignalHandler h); // 一步到位,一眼能懂
原则:
- 超过两个
*或同时含[] () *,一律using - 用
std::function/ 模板 / 类封装回调,替代函数指针 - 数组用
std::array,动态数组用std::vector,避免int (*)[N] - 现代 C++ 优先用
auto+ 显式类型别名
五、快速自测
请读出下面 6 个声明的含义,答案在下方:
cpp
1. int (*a[5])();
2. int (*b())[5];
3. int *(*c)[5];
4. int (*(*d)[5])();
5. char * const e;
6. int *f[5][5];
查看答案
a是数组,5 个元素,每个是函数指针(返回 int、无参)b是函数,返回"指向含 5 个 int 的数组"的指针c是指针,指向"含 5 个 int* 的数组"d是指针,指向"含 5 个函数指针的数组"(函数无参返回 int)e是 const 指针,指向 char(指针本身不可改)f是 5×5 数组,元素是int*
六、一句话总结
从变量名出发,先右后左交替读;
[]/()优先于*;括号能改结合顺序。工程里永远优先
using起别名,而不是硬写复杂声明。
需要的话,我可以再补充:
- 如何用
cdecl工具/在线工具验证声明 - C++ 类型别名
using X = ...的匹配写法 - 用
decltype/ 模板推导反推声明的技巧
explicit 是修饰构造函数 (以及 C++11 起的转换运算符 )的关键字,作用是:禁止隐式类型转换,只允许显式构造。
1. 为什么需要它:单参数构造函数的"隐式转换"问题
先看一个单参数构造函数:
cpp
class Buffer {
int size;
public:
Buffer(int n) : size(n) { } // 注意:没有 explicit
};
void f(Buffer b) { }
int main() {
Buffer a1(2); // 显式构造,OK
Buffer a2 = 2; // ❗隐式:把 2 转成 Buffer(2)
f(2); // ❗隐式:把 2 转成 Buffer(2) 再传参
}
Buffer a2 = 2; 和 f(2); 之所以能编译,是因为编译器会自动 把 int 隐式转换成 Buffer------这叫隐式转换(implicit conversion)。
问题在于:这种转换往往不是程序员本意 ,容易埋坑。比如 int 和 Buffer 语义上根本不是一回事,f(2) 能悄悄通过编译就很危险。
2. 加上 explicit 后
cpp
class Buffer {
int size;
public:
explicit Buffer(int n) : size(n) { }
};
void f(Buffer b) { }
int main() {
Buffer a1(2); // ✅ 显式构造,OK
Buffer a1b{2}; // ✅ 直接列表初始化,OK
Buffer a2 = 2; // ❌ 编译错误:禁止隐式转换
f(2); // ❌ 编译错误:禁止隐式转换
Buffer a3 = {2}; // ❌ 编译错误:拷贝列表初始化,不允许 explicit
}
explicit 就是告诉编译器:想构造 Buffer,必须明明白白写出 Buffer(...) 或 Buffer{...},不许偷偷拿 int 顶替。
3. 多参数构造函数也能用 explicit(C++11 起)
C++11 之前 explicit 只对单参数构造有意义;C++11 起,多参数构造 + 花括号列表初始化也能被隐式触发,所以 explicit 也用得上:
cpp
class Point {
public:
explicit Point(int x, int y) { }
};
Point p1(1, 2); // ✅
Point p2{1, 2}; // ✅ 直接列表初始化
Point p3 = {1, 2}; // ❌ 拷贝列表初始化,explicit 禁止
注意 p3 = {1, 2} 这种拷贝列表初始化(copy-list-initialization) 会被 explicit 挡住。
4. explicit 也用于转换运算符
C++11 起可以修饰 operator 类型():
cpp
class SafeBool {
public:
explicit operator bool() const { return true; }
};
SafeBool sb;
if (sb) { } // ✅ 条件上下文里允许显式转换
bool b = sb; // ❌ 隐式转换到 bool,被禁止
bool b2 = static_cast<bool>(sb); // ✅ 显式转换,OK
典型用途就是 explicit operator bool(),避免对象被隐式转成 bool 参与算术或比较。
5. 什么时候该加 explicit
经验法则:只要构造函数不是"真正意义上的类型转换",就加 explicit。
- 单参数构造函数(如
Buffer(int)、String(const char*))------几乎都该加,除非你确实想要隐式转换。 - 多参数构造函数------如果允许
{1, 2}隐式转换有歧义风险,也加。 - 想支持
Buffer b = 2;这种写法时,才故意不加。
一个反例是故意允许隐式转换 的:std::string(const char*) 没加 explicit,所以 std::string s = "hi"; 能写;而 std::vector<int> 的 vector(size_t n) 是 explicit 的,防止 vector<int> v = 5; 这种奇怪写法。
小结
| 写法 | 无 explicit |
有 explicit |
|---|---|---|
Buffer a(2); |
✅ | ✅ |
Buffer a{2}; |
✅ | ✅ |
Buffer a = 2; |
✅ 隐式转换 | ❌ |
f(2);(f(Buffer)) |
✅ 隐式转换 | ❌ |
Buffer a = {2}; |
✅ | ❌ |
一句话:explicit = 关掉"隐式构造"这扇门,只留"显式构造"这扇门。