第11章 选择适当的 操作
11.1 逻辑 / 位 / 递增减
1 逻辑
&& || !
(1) 操作数
指针/算术 类型
(2) 短路特性: 逻辑上 需要 时, && 和 || 才会对 第2实参求值
while (p && !whitespace(*p) ) ++p;
2 位
& | ~(非) ^(异或) >> <<
含义 & 应用(位向量)
unsigned 整型
每1位 表示 集合的1个成员
(1) & 求 交
从 32 位 int 中 提前中间 16位
constexpr unsigned short middle(int n)
{
static_assert( sizeof(int) == 4, "unexpected int size" );
static_assert( sizeof(short) == 2, "unexpected short size" );
return (n >> 8) & 0xFFFF;
}
int x = 0xFF00FF00; // 假定 sizeof(int) = 4
short y = middle(x); // y = 0x00FF
(2) | 求 并
在 现有状态 上 添加内容
enum ios_base::iostate
{
goodbit = 0, eofbit = 1, failbit = 2, badbit = 4
};
state |= eofbit;
(3) ~ 求 补
(4) ^ 异或: 相异( 有变化 ) 为 1
判 `状态 是/否 变化`
现值 与 旧值 异或 => result 作 条件 转换为 `bool 值 true/false`
if ( 结果 可转换为 true <=> 至少有 1 位 有变化 => 有变化 )
int old = cin.rdstate(); // rdstate() 返回 状态
// ...
if( cin.rdstate() ^ old ) // 有变化吗 ?
3 递 增/减
(1) char* strcpy(char*, const char*); // <string.h>
循环 拷贝 以 0 结尾的 C 风格字符串
void cpy(char* p, const char* q);
6 个版本
1) `读 2 次 字符串`
先求 strlen(): 第 1 次 读
int length = strlen(q);
for(int i = 0; i <= length; i++)
p[i] = q[i];
|
| 性能提升
|/
2) `读 1 次 字符串`
没遇到 结束符 0 时, copy
+
遇到时, 跳出 + dst 置 结束符 0
for(int i = 0; q[i] != 0; i++)
p[i] = q[i];
p[i] = 0;
3) 用 `指针操作 替换 数组下标操作`
while (*q != 0)
{
*p = *q;
p++;
q++;
}
*p = 0;
4) `后置递增: 允许 先使用值 再 递增`
while(*q != 0)
**p++ = *q++;
*p = 0;
5) `赋值表达式 的 值` 是 右操作数的值/赋值后左操作数 的值
*p++ = *q++ 的值是 *q
=> while(*p++ = *q++) 终止条件是 *q == 0
1> copy: *p = *q -> 结果 *q 转换为 bool 值 -> 编译器 先存着
2> 递增
3> 判 递增前 *q (若 0) 转换的 bool 值 -> 若 false -> exit => 结束符 已 copy 给 dst
while(*p++ = *q++)
{}
6) 循环体空 => 略去
while(*p++ = *q++);
11.2 自由存储
(1) 引入
命名对象 lifetime 由其 scope 决定
|
| 希望 `分离 对象 与` 对象创建语句所在 `scope`
|/
new 运算符
分配的对象 `位于 自由存储 之上`
(2) delete 运算符
1) delete / delete[] nullptr; 什么也不做
2) 被 delete 的对象类型 含 dtor
delete 将
[1] 调用 该 dtor
释放 该对象 所管理的资源 (若有)
[2] 释放 该对象所占内存空间
以供后续使用
1 内存管理
(1) 自由存储 的 问题
1) 对象泄露
new 但忘了 delete ---> 可能资源耗尽
2) 过早 delete
3) 重复 delete
同一对象被释放 2 次
2 次调用 dtor
(2) 解决
1) 优先`scoped 对象`
必要时再 自由存储
2) RAII
[1] 将 自由存储 对象 的 `ptr` 放到 `handle 对象` 中
|
| 尽可能 作
|/
`scope 内 变量`
string / vector / unique_ptr / shared_ptr
[2] 很多用 自由存储 的场合
都可以用 `move 语义` 替代
从 函数返回 表示 大对象的 句柄 即可
RAII
字面含义
句柄 ctor 中 创建资源, dtor 中 释放资源
本质含义
让 句柄 own 资源, dtor 中 释放资源
=>
`资源 与 句柄 的 lifetime 管理 统一起来`
只要不泄露句柄, 就能不泄露资源
至于让 ctor 创建资源, 还是 把资源创建好, 再交给 ctor 保管, 无优劣之分
可用 Factory Method 返回 创建好的资源, client 就不用管 里面怎么实现了
2 除非必须直接使用 char*, 否则一般而言, std::string 更好
(1) new 创建 对象的数组
char* save_string(const char* p)
{
char* s = new char[strlen(p) + 1];
strcpy(s, p);
return s;
}
int main(int argc, char* argv[])
{
// ...
char* p = save_string( argv[1] );
// ...
delete[] p;
}
|
| (2)
|
| 简化 + 不操心 delete / delete[]
|/
string save_string(const char* p)
{
return string{p};
}
int main(int argc, char* argv[])
{
// ...
string s = save_string( argv[1] );
// ...
}
(2) delete / delete[] 必须清楚 分配的对象 有多大
new 分配的对象 比 静态对象 所占空间 稍大(至少存得下 对象 size)
3 重载 new
默认下, new 运算符 在 自由存储 上 创建对象
|
|/
想在 `指定空间` 分配对象
|
| 重载 new: placement new <new>
|/
目标空间地址 作 参数
void* buf = reinterpret_cast<void*>(0xF00F); // 明确的地址
void* operator new(size_t, void* p) { return p; } // placement new <new>
/ |\
_ _ _ /_ _ _ _ _ _ _|
| /
|/ /
X* p = new(buf) X; // 在 buf 处 构建 X,
// 调 operator new( sizeof(X), buf )
// ===
clas B
{
public:
virtual void* alloc(size_t) = 0;
virtual void free(void*) = 0;
// ...
};
void* operator new(size_t sz, B* pB)
{
return pB->alloc(sz);
}
extern B* gpPersistent;
extern B* gpShared;
void g(int n)
{
X* p = new(gpPersistent) X(i); // 在 持续存储 上 分配 X
X* q = new(gpShared) X(i); // 在 共享内存 上 分配 X
// ...
}
// 销毁: 显式调用 dtor
void destory(X* pX, B* pB)
{
pX->~X(); // 显式调用 dtor: 清理资源
pB->free(pX); // 释放内存
}
11.3 列表 {}
{} 列表
|
| 及其 底层数组 `lifetime` 与 initializer_list 对象 相同
|/
编译器 构建 临时数组 作 `底层数组`
|
| 不可修改
|/
构建 `initializer_list 对象` 管理之
小对象: 以 值传递 可行
11.4 lambda 表达式
(1) `回调`
1) 操作 作 实参 传给 算法
2) 再通过 function pointer / function object / lambda
去调 函数调用运算符 operator() (paraList)
function pointer 本身不能 持有 state, 只能由 算法 提供
(2) mutable 修饰符
默认下, operator() 是 const: const 含义
lambda body 内
不修改 通过 `值捕获的变量 的 copy`
note：而不是 不修改 通过引用捕获的变量的状态
(3) vs. 函数
函数 无 捕获功能
=> lambda 可作 局部函数, 普通函数不能
1 实现
函数对象
void f(const vector<int>& v, ostream& os, int n)
{
for_each(v.begin(), v.end(),
[&os, n](int x) { if(x % n == 0) os << x << '\n'; } );
} | |
|
class F | |
{ /|
ostream& os;| |
int n; |
public: / |
F(ostream& s, int nn): os(s), n(nn) {}
/
void operator() (int x) const
{
if(x % n == 0) os << x << '\n'; }
}
};
void f(const vector<int>& v, ostream& os, int n)
{
for_each(v.begin(), v.end(), F{os, n} );
}
2 捕获
(1) lambda 主要用途
`封装` 部分代码 以便将其用 `作 参数`
定义处使用
而不用像 函数/函数对象 那样, 分离定义与使用
(2) 3种捕获形式
1) 隐式捕获
[=] 引用传递
[&] 值传递
2) 显式捕获
[捕获列表]
可捕获 this
3) 混合 隐式 与 显式 捕获
捕获列表中 `没出现的 名字(外层 context 局部变量)`
通过 引用 / 值 传递, 列出的 通过 值/引用
/ |
/ [=, 捕获列表]
/ |
[&, 捕获列表] 必须 以 & 为 前缀
| => 不可出现 this
|/
不能 以 & 为 前缀
=> 可出现 this
(3) 很多时候, 既可 捕获, 也可 传实参
(4) lambda 与 this
1) 捕获 this: [this]
通过 this 访问 `类对象的 成员`
2) [this] 与 [=] 不兼容
=> 多线程 中易发生 `竞争条件`
class A
{
int value;
int result;
public:
void execute()
{
[this]() { result = f(value); }
}
int f(int v);
};
11.5 显式 类型转换 / 强转 casting
1 列表 T {v}
(1) 用 值 v 构造 T 类型的临时对象
(2) 好处
只执行 "行为良好的" 类型转换
存在
[1] v 向 T 的 `非窄化` 类型转换, 或
[2] 正确的 `T 类型 ctor`
T{}
构造函数: 类型 T 默认值
2 4种 命名转换
const_cast
为某些 const 对象 获得 写入权利
仅对 const / volatile
reinterpret_cast
改变 位模式 的 含义
`非关联类型 间` 转换
1> 整数 -> 指针
2> 指针 -> 非关联指针
IO_device* p = reinterpret_cast<IO_device*>(0xFF00); // 0xFF00 处的 设备
static_cast
`关联类型 间` 转换
`原始内存` 指针转换
int* p = static_cast<int*>(my_allocator(100) );
1> 整数 -> 枚举 / 浮点 -> 整数
2> 指针 -> 同一类层次中 其他指针
3> (单参数) explicit ctor
|
|
|/
X::X(T v)
4> `类型转换运算符`
|
| X(类类型) 向 T(任意类型) 的 类型转换
|/
X::operator T()
dynamic_cast
`动态检查` 类层次 关系
执行 `运行时检查` // static_cast 不做 运行时检查
3 C 风格 转换
(T)v
|
|/
可执行 命名转换 中 除 dynamic_cast 之外的 3种转换的 任意组合
4 函数形式 的转换
T(v)
|
| 对 内置类型 T <=>
|/
(T) V
第12章 函数
12.1 函数声明
1 返回 void
并不存在 void 值, 但可 `调用 void 函数` 作 `另一 void 函数 的 返回值`
void g(int*p);
void h(int* p)
{
// ...
return g(p); // <=> g(p); return;
}
2 inline 函数
遵循 ODR(一次定义法则)
定义出现在 多个编译单元 (通常是因为 inline 放 头文件)
定义必须保持一致
3 constexpr 函数
遵循 ODR(一次定义法则)
可视为 更严格的 inline
4 local static 对象
在 `函数多次调用` 间 `维护1份公共信息`,
而无需使用 `global 变量` -> 可能被 其他不相关含访问
12.2 传参
1 引用传递
与 引用初始化 规则相同
`字面值 / 常量 / 需类型转换的参数` 可传给 `const 引用` (const t&)
|
|/
转换后的值 存入 临时变量
|
| 传给
|/
const 引用
float fsqrt(const float&);
void g(double d)
{
float r = fsqrt(d); // 传递 存 static_cast<float>(d) 的 临时变量
}
2 传 数组的引用: paraType 数组引用 类型
函数模板 实参推断: size 也是 paraType 的一部分
template<typename T, int N>
void f( T(&r)[N] );
12.3 重载函数
1 自动 重载解析
(1) 概念
调用函数 f 时, 由 compiler 据 `实参类型`
与 `scope 中` 名为 f 的 各函数 作 `最佳匹配`
(2) 匹配顺序
1) 精确 匹配
[1] 无须 类型转换
[2] 仅需 简单类型转换
数组名 -> 指针
函数名 -> 函数指针
T -> const T
2) 提升 后匹配
[1] bool/char/short -> int
... unsigned 版本
[2] float -> double
3) 标准类型转换 后匹配
[1] 算术类型 间 `强转`
整型间、整型与浮点型间
[2] OO/GP 中 指针 `隐转`
类层次 中
Derived* -> Base*
模板中
T* -> void*
4) 用户自定义类型转换 后匹配
[1] 单参数 explicit ctor
[2] 类型转换运算符 X::operator T()
5) 使用 函数声明中 省略号 ...匹配
二义性 => compile error
能找到的 最高层级(同一层) 中 不止1个匹配
(3) 函数模板 的 special
模板实参推断 -> 特例化版本 -> 参与 重载解析规则
23.4.2 节
——————————————————————————————————————————————————————————————————————————————————————————————
模板 函数 | (先) `引用推断` (模板实参推断) + (再决定) 右值引用传递 / (还是) 左值引用传递
| |
右值引用模板实参| | 区分 左值 和 右值
| |/
| X 类型 的 `左值 / 右值` 被 `推断为 X& / X`
|
———————————————————————————————————————————————————————————————————————————————————————————————
非模板 函数 | (右) 值 绑定到 右值引用
| |
右值引用实参 | 移动
——————|—————————————————————————————————————————————————————————————————————————————————————————
|
|/
void f(vector<int>&& );
(4) 模板函数 重载: 23.4.3 节
——————————————————————————————————————————————————————
5句话
——————————————————————————————————————————————————————
1) 找 `所有 特例化版本`
——————————————————————————————————————————————————————
2) 找 `更特殊的`
——————————————————————————————————————————————————————
3) 与 普通函数 一起, 按 `普通函数 重载解析` 规则
——————————————————————————————————————————————————————
4) 普通函数 与 特例化版本 匹配得一样好, `优选 普通函数`
——————————————————————————————————————————————————————
5) `无法确定 最佳匹配` => 二义性 => 编译报错
————————————————————————————|——————————————————————————
|
二义性消除
template<typename T>
T max(T, T);
max('a', 1); // max<char, char> 还是 max<int>(int)
max(2.7, 4); // max<double, double> 还是 max<int>(int)
1> 显式限定
max<int>('a', 1); // max<int>(int)
max<double>(2.7, 4); // max<double>(double)
2> 封装 1层
1) 找参与重~析的 `所有 特例化版本`
调 sqrt(z)
sqrt<double>(complex<double>) 与
sqrt<complex<double>>(complex<double>) 都成为 候选
2) 若 2个 模板函数 都可调用, 找`更特殊的`
调 sqrt(z)
sqrt<double>(complex<double>) 比
|
|
T
sqrt<T>(complex<T>)
sqrt< complex<double> >(complex<double>)
|
|
T
sqrt<T>(T)
更特殊
因为, 任何匹配 sqrt<T>(complex<T>) 的 调用, 也都能匹配 sqrt<T>(T)
3) 还留在 `候选集` 中的
|
|
`模板函数 和 普通函数`
|
| 用
|/
`普通函数 重载解析规则`
sqrt(2)
sqrt<int>(int) 优于 sqrt(double)
note:
参与了 `模板实参推断` 的 `(模板) 函数实参`,
不能再进行 提升、标准类型转换、用户自定义类型转换
4) 若 普通函数 与 特例化版本 `匹配的一样好`
优选 `普通函数`
sqrt<2.0>
sqrt(double) 优于 sqrt<double>(double)
5) 多个一样好的匹配, 且
`无法确定 最佳匹配` => 二义性 => 编译报错
2 重载 与 returnType
重载解析过程 `不考虑 returnType`
3 重载 scope
—————————————————————————————————————————————————————————————————
1) 显而易见 的 scope: context scope / 函数调用前的 global scope
显式
2) using 指示 / using 声明
引入的 跨 类 作用域
————————————————————————————————————————————————————————————————
3) 重载函数 被 类成员调用
引入 类 及其 基类 scope
隐式
4) ADL 引入的 scope / 关联 namespace
———————————————————————————————————————————————————————
| ADL 的 关联名字空间
| ( associated namespace ) ADL scope
———————————————————————————————————————————————————————
函数调用 f(arg...) |
的参数 args... 是 |
———————————————————————————————————————————————————
内置类型 | 无
———————————————————————————————————————————————————
namespace 成员 | namespace
———————————————————————————————————————————————————
class 成员 | 类 + 其基类 + 类所在的 namespace
———————————————————————————————————————————————————————————————————
4 函数 重载 优先级 (14.2.4 节)
———————————————————————————————————————————————————————————————————
函数 重载 优先级
函数调用 f(arg...) 在
———————————————————————————————————————————————————————————————————
(1) 非类成员调用
[1] 函数调用 所在 scope (global scope)
[2] ADL scope
———————————————————————————————————————————————————————————————————
(2) 类成员调用
———————————————————————————————————————————————————————————————
1) 命名函数调用
[1] 优先 类 scope + 基类 scope
[2] 再 ADL scope
———————————————————————————————————————————————————————————————
2) 匿名函数调用(运算符)
[1] 类 scope + 基类 scope + ADL scope
———————————————————————————————————————————————————————————————————
// === (1)
1) 命名函数调用 f(x) + 在 类 D 成员 g() 内调用, `实参 x` 类型 N::S
find scope
D+Base 的 scope
x 的 ADL scope
global
find order
[1] 先 D+Base 的 scope 中 找, 找到 Base::f(N::S) => 匹配调用
2) 实参1
find order
[1] 先 D+Base 的 scope 中 找, 没找到
[2] ADL 无法实现 => 查不到 h(int) => 编译报错
namespace N
{
struct S {int i};
void f(S);
void h(int);
};
struct Base
{
void f(N::S);
};
struct D: Base
{
void g(N::S x)
{
f(x); // 1)
h(1); // 2)
}
};
// === (2) 匿名函数调用
匿名函数调用 operator!(X) 在 类 Z 成员 f() 内调用, `实参 x` 类型 X
find scope:
Z 的 scope & global scope
find order: 2 个 scope 同优先级
Z::operator!() 不匹配
::operator!(X) 匹配 => 调用
X operator!(X);
struct Z
{
Z operator!();
X f(X x)
{
// ...
return !x; //(1)
}
int f(int x)
{ return !x; } //(2) 对 int 调 内置 !
};
// === 3 命名函数调用 f(x, 1) + 非类成员调用
find scope:
global scope
参数 x 的 ADL scope: N::X 是 namespace N 的 成员 => ADL scope = N
find order:
2 个 scope 同优先级
N::f(X, int) 比 N2::f(N::X, unsigned) 更匹配
=> 调 N::f(X, int)
namespace N
{
template <class T>
void f(T, int);
class X {};
};
namespace N2
{
N::X x;
void f(N::X, unsigned);
void g()
{
f(x, 1); // 调 N::f(X, int)
}
};
12.4 函数指针
1. C <-> C++ 函数指针 的 赋值/初始化
type `精确匹配`
(1) 实参 与 形参 `函数指针 类型` 必须 `精确匹配`
C 编译
using CFT = int(const void*, const void*);
void ssort(void* base, size_t n, size_t sz, CFT cmp);
C++ 编译
int cmp(const User* p, const User* q) // User: 用户自定义类型 struct
{
return strcmp(p->id, q->id);
}
cmp 作 实参 调 ssort => 两种 函数指针 类型 非 精确匹配 => 编译报错
解决
中间层
const void* p
|
|/
static_cast<const User*>(p)
int cmp(const void* p, const void* q)
{
return strcmp(static_cast<const User*>(p)->id, static_cast<const User*>(q)->id);
}
| C与C++ 链接方式/链接方式 (=>调用机制) 不同 =>
|/
仍报错
(2) C & C++ code 链接方式/链接规范 要相同 (=>调用机制 相同)
// file1.c
extern "C"
{
using CFT = int(const void*, const void*);
void ssort(void* base, size_t n, size_t sz, CFT cmp);
}
// file2.cpp
extern "C" int cmp(const void* p, const void* q);
2 作 操作参数 调 算法/函数
回调
3 成员 函数指针 与 普通函数指针 本质不同
|
|/
是 vtbl 的 index: 0 / 1 / 2 / ...
12.5 宏
编译器 接触 程序前, 宏 会 `重排程序文本`
=> 调试器、交叉引用、性能评测工具 很难发挥作用
(1) 宏名 不允许 `重载`
宏 无法处理 `递归`
(2) 尽管尽量用 括号() 将 `宏的参数 括起来`
只能解决 简单语法问题,
|
| 但对于
|/
`宏产生的 副作用` 仍 `无能为力`
#define MIN(a, b) ( ( (a) < (b) ) ? (a) : (b) )
| |
|/ |/
最外层 也加 括号 不是语句 => 末尾没 分号
int x = 1;
int y = 10;
int z = MIN(x++, y++); // x 变成 3, y 变成 11
? 会使 x/y 均 递增 => 选中 (x++) => x 再递增
|
|
( ( (x++) < (y++) ) ? (x++) : (y++) )
|
| (x++) < (y++) 是表达式
|/
其值为 true
(3) 宏 的应用
1) `字符串 拼接`
##
#define NAME2(a, b) a##b
int NAME2(hack, cah)();
展开为
int hackcah();
2) 宏 的 `空 参数列表`
#define EMPTY() std::cout << "empty\n"
EMPTY(); // 输出 "empty\n"
3) 变长参数 宏
#define err_print(...) fprintf(stderr, "error: %s %d\n", __VA_ARGS__)
|
|/
把 实参 当作 字符串
err_print("The answer", 54);
// 输出: The answer 54
1 条件编译
有一种 宏 无法替代
条件编译
#ifdef 等
2 预定义宏
__cplusplus
C++ 编译器中 定义, C 编译器 没有
C++11 中其 值为 201103L
__LINE__
当前源文件 的 代码行数
3 编译指令
网友评论