现代c++4.1

1.使用文件重定向

cpp 复制代码
$ addexe <infile >outfile
//累加和.exe < test.txt >> ans.txt  追加模式,不覆盖
cpp 复制代码
strcat(p1,p2); 把p2附加到p1的后面

C++ 复杂指针/数组声明详解

复杂指针声明的核心难点在于 *、[]、() 三者的优先级和结合方向。掌握一套"读法"后,任何复杂声明都能拆解。


一、核心原则:右左法则(Spiral Rule)

读一个声明的固定步骤:

  1. 从变量名开始 ,先看它右边 ,再看它左边,交替进行。
  2. 遇到 () 表示"函数(返回...)",遇到 [] 表示"数组(元素是...)",遇到 * 表示"指针(指向...)",遇到 const 表示"常量"。
  3. 优先级 :[] 和 () > *;同级时从右往左。
  4. 括号 () 用于改变优先级,是唯一能"打断"结合顺序的东西。

记住一句话:"名字先跟右边结合,再跟左边结合;括号能改变结合对象。"


二、从简单到复杂,逐层拆解

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

查看答案

  1. a 是数组,5 个元素,每个是函数指针(返回 int、无参)
  2. b 是函数,返回"指向含 5 个 int 的数组"的指针
  3. c 是指针,指向"含 5 个 int* 的数组"
  4. d 是指针,指向"含 5 个函数指针的数组"(函数无参返回 int)
  5. e 是 const 指针,指向 char(指针本身不可改)
  6. 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 = 关掉"隐式构造"这扇门,只留"显式构造"这扇门。

相关推荐
布莱克60534 分钟前
Swift 字符串详解:从基础用法到性能与最佳实践
服务器·开发语言·ssh·字符串·swift
下一站春风里1 小时前
Spring IoC 控制反转 完整技术笔记
java·spring boot·笔记·spring
挖掘狂人1 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·后端·面试
codigger1 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·程序员·支付·java后端
Resean02231 小时前
SpringMVC 6+源码分析(十)数据绑定与类型转换
java·spring·springmvc
lw_zhang11011 小时前
爆肝一个月,Java 从入门到精通39 - 使用Log4j
java·单元测试·log4j
Rain的Java大神之路1 小时前
面试官问"MySQL 大表 COUNT(*) 怎么优化",90% 的人第一步就答错了
java·后端·面试
唐老板2 小时前
AI 都会编程了,Java 何去何从
java·ai编程
nice_lcj5202 小时前
MySQL 慢查询与 EXPLAIN:怎么定位、怎么优化
java·数据库·后端·mysql