C++学习笔记

类定义以关键字 class 开始

class Sales_item { 
public: 
// operations on Sales_item objects will go here 
private: 
std::string isbn; 
unsigned units_sold; 
double revenue; 
}; 

类不是在类定义里定义数据成员时初始化数据成员，而是通过称为构造函数（第 2.3.3 节）的特殊成员函数控制初始化。

访问标号 public、private 可以多次出现在类定义中。{{类的属性通常会声明为private，也就是私有的，然后提供一个公有的方法来访问它}}
不是类的组成部分的代码不能访问 private成员

如果使用 class 关键字来定义类，那么定义在第一个访问标号前的任何成员都隐式指定为 private；如果使用 struct 关键字，那么这些成员都是 public

头文件用于声明而不是用于定义 
头文件可以定义类、值在编译时就已知道的 const 对象和 inline 函数

=======第三章=====
抽象数据类型：抽象数据类型支持哪些操作就可以
:: 操作符，该操作符是作用域操作符（右操作数的名字可以在左操作数的作用域中找到）
using 声明：可以在不需要加前缀 namespace_name:: 的情况下访问命名空间中的名字

cin >> s;读取并忽略开头所有的空白字符（如空格，换行符，制表符）。 读取字符直至再次遇到空白字符，读取终止
getline；getline 函数从输入流的下一行读取，并保存读取的内容到不包括换行符，getline 并不忽略行开头的换行符
如果第一个字符就是换行符，则 string 参数将被置为空 string。 

endl 来输出一个换行符并刷新输出缓冲区
s.empty()  s.size()  
s[n]常被称为“下标”或“索引”（index）

任何存储 string 的 size 操作结果的变量必须为 string::size_type 类型。特别重要的是，还要把 size 的返回值赋给一个 int 变量。

前面部分相匹配，则短的 string 对象小于长的 string 对象

string 对象的赋值
string st1, st2 = "The expense of spirit"; 
st1 = st2; // replace st1 by a copy of st2
它必须先把 st1 占用的相关内存释放掉，然后再分配给 st2 足够存放 st2 副本的内存空间，最后把 st2 中的所有字符复制到新分配的内存空间。

把 s2 直接追加到 s1 的末尾，可以使用 += 操作符： 
s1 += s2;
string s3 = s1 + ", " + s2 + "\n"
进行 string 对象和字符串字面值混合连接操作时，+ 操作符的左右操作数必须至少有一个是 string 类型的：
string s5 = s1 + ", " + "world";等于
{
string tmp = s1 + ", "; // ok: + has a string operand 
s5 = tmp + "world"; // ok: + has a string operand
}

 s[s.size() - 1] 则表示 s 的最后一个字符。
cin 还会对键盘上是否有作为流结束标志的 Ctrl+Z (window)或者 Ctrl+D(linux)键按下作出检查，其检查的方式有两种：阻塞式以及非阻塞式。

vector 是一个类模板,  ==保存 string 对象的 vector，或保存 int 值的 vector, 又或是保存自定义的类类型对象（如 Sales_items 对象）的 vector
 vector 保存何种对象的类型，通过将类型放在类型放在类模板名称后面的尖括号中来指定类型：
vector<int> ivec; // ivec holds objects of type int 
vector<Sales_item> Sales_vec; // holds Sales_items 
vector 不是一种数据类型,vector<int> 和 vector<string> 都是数据类型。
vector 对象在运行时高效地添加元素, 动态地添加元素
v.empty() v.size()  v.push_back(t) v[n]
v.push_back(t) 在 v 的末尾增加一个值为 t 的元素
使用 size_type 类型时，必须指出该类型是在哪里定义的。vector<int>::size_type
使用下标操作符来获取元素

必须是已存在的元素才能用下标操作符进行索引
vector<int> ivec; // empty vector 
cout << ivec[0]; // Error: ivec has no elements!

迭代器是一种检查容器内元素并遍历元素的数据类型。
：所有的标准库容器都定义了相应的迭代器类型，而只有少数的容器支持下标操作
vector<int>::iterator iter;
返回迭代器
由 begin 返回的迭代器指向第一个元素
vector<int>::iterator iter = ivec.begin();//{ivec[0]} //ivec.end()
由 end 操作返回的迭代器指向 vector 的“末端元素的下一个”。“超出末端迭代器”（off-the-end iterator）。表明它指向了一个不存在的元素。

vector 迭代器的自增和解引用运算
迭代器类型可使用解引用操作符 *iter = 0;

const_iterator  该类型只能用于读取容器内元素，但不能改变其值。 不允许用 const_iterator: 进行赋值 
不要把 const_iterator 对象与 const 的 iterator 对象混淆起来。声明一个 const 迭代器时，必须初始化迭代器。
vector<int> nums(10); // nums is nonconst 
const vector<int>::iterator cit = nums.begin(); 
*cit = 1; // ok: cit can change its underlying element 
++cit; // error: can't change the value of cit 
const 迭代器这种类型几乎没什么用处

迭代器的算术操作
iter + n // iter - n 
iter1 - iter2  两个迭代器对象的距离（iter1 与 iter2 两者必须都指向同一 vector 中的元素）
该距离是名为 difference_type的 signed 类型 size_type 的值
vector 中间元素
vector<int>::iterator mid = vi.begin() + vi.size() / 2;

任何改变 vector 长度的操作都会使已存在的迭代器失效。例如，在调用 push_back 之后，就不能再信赖指向 vector 的迭代器的值了

3.5. 标准库 bitset
#include <bitset> 
using std::bitset; 
bitset<n> b; b 有 n 位，每位都 0 
bitset<n> b(u); b 是 unsigned long 型 u 的一个副本 
bitset<n> b(s); b 是 string 对象 s 中含有的位串的副本 
bitset<n> b(s, pos, n); b 是 s 中从位置 pos 开始的&nbps;n 个位的副本。

与 vector 不一样的是 bitset 类型对象的区别仅在其长度而不在其类型。
定义 bitset 时，要明确 bitset 含有多少位，须在尖括号内给出它的长度值：
bitset<32> bitvec;  
(bitvec[31])0000 0000 0000 0000 0000 0000 0000 0000(bitvec[0])
bitset<16> bitvec1(0xffff);
bitset<32> bitvec2(0xffff); // bits 0 ... 15 are set to 1; 16 ... 31 are 0

string 对象读入位集的顺序是从右向左
string strval("1100"); 
bitset<32> bitvec4(strval);//  0000 0000 0000 0000 0000 0000 0000 1100

string str("1111111000000011001101"); 
bitset<32> bitvec5(str, 5, 4); // 4 bits starting at str[5], 1100
表3.7. bitset 操作
以下是则返回1
b.any() b 中是否存在置为 1 的二进制位？ 
b.none() b 中不存在置为 1 的二进制位吗？ 
b.count() b 中置为 1 的二进制位的个数 (count 操作的返回类型是标准库中命名为 size_t 类型,size_t 类型定义
在 cstddef 头文件)
b.size() b 中二进制位的个数 
b[pos] 访问 b 中在 pos 处二进制位 
b.test(pos) b 中在 pos 处的二进制位置为 1 么？ 
b.set() 把 b 中所有二进制位都置为 1 
b.set(pos) 把 b 中在 pos 处的二进制位置为 1 
b.reset() 把 b 中所有二进制位都置为 0 
b.reset(pos) 把 b 中在 pos 处的二进制位置为 0 
b.flip() 把 b 中所有二进制位逐位取反 
b.flip(pos) 把 b 中在 pos 处的二进制位取反 
b.to_ulong() 用 b 中同样的二进制位返回一个 unsigned long 值 
os << b 把 b 中的位集输出到 os 流 

flip 操作可以对 bitset 对象的所有位或个别位取反：以下一样
bitvec.flip(0); // reverses value of first bit 
bitvec[0].flip(); // also reverses the first bit

bitvec.flip();// reverses value of all bits 

to_ulong 操作返回一个 unsigned long 值
unsigned long ulong = bitvec3.to_ulong(); 

=======第四章 数组和指针=============
C++ 语言提供了两种类似于 vector 和迭代器类型的低级复合类型——数组和指针。
只有当性能测试表明使用 vector 无法达到必要的速度要求时，才使用数组

•  在函数体外定义的内置数组，其元素均初始化为 0。 
•  在函数体内定义的内置数组，其元素无初始化。
•  如果其元素为类类型，则自动调用该类的默认构造函数进行初始化
数组下标的正确类型则是 size_t

指针用于指向对象  指针用于指向单个对象，而迭代器只能用于访问容器内的元素。
string s("hello world"); 
string *sp = &s;
vector<int> *pvec;
string *pstring;

指向  const  对象的指针
如果指针指向 const 对象，则不允许用指针来改变其所指的 const 值
const double *cptr;//这里的 cptr 是一个指向 double 类型 const 对象的指针
const 限定了cptr 指针所指向的对象类型，而并非 cptr 本身,
保存 const 对象的地址，而必须使用 const void*类型的指针保存 const 对象的地址
C++ 语言强制要求指向 const 对象的指针也必须具有 const 特性

const  指针 --本身的值不能修改,
const 指针也必须在定义时初始化
int errNumb = 0; 
int *const curErr = &errNumb;//不能使 curErr 指向其他对象

指向  const  对象的  const  指针
const double pi = 3.14159; // pi_ptr is const and points to a const object 
const double *const pi_ptr = &pi;
既不能修改 pi_ptr 所指向对象的值，也不允许修改该指针的指向（即 pi_ptr 中存放的地址值）

typedef string *pstring; 
const pstring cstr;
声明 const pstring 时，const 修饰的是 pstring 的类型，这是一个指针
该声明语句应该是把 cstr 定义为指向 string 类型对象的 const 指针,这个定义等价于
string *const cstr;

动态分配数组时，如果数组元素具有类类型，将使用该类的默认构造函数实现初始化；如果数组元素是内置类型，则无初始化：
string *psa = new string[10]; // 有初始化，调用 string 类型的默认构造函数依次初始化数组中的每个元素
int *pia = new int[10]; // 没有初始化

允许动态分配空数组
size_t n = get_size(); // get_size returns number of elements needed 
int* p = new int[n];
for (int* q = p; q != p + n; ++q)

动态空间的释放
delete [] pia;
动态数组的使用

标准库函数 strlen 返回的是字符串的长度，并不包括字符串结束符，在获得的字符串长度上必须加 1 以便在动态分配时预留结束符的存储空间

混合使用标准库类  string 和C 风格字符串

第五章 表达式
5.3.1. bitset 对象或整型值的使用
bitset_quiz1.set(27);

6.13.2. try 块
try 块的通用语法形式是： 
try { 
program-statements 
} catch (exception-specifier) { 
handler-statements 
} catch (exception-specifier) { 
handler-statements 
} //...

第九章. 顺序容器
标准库 vector 类型，这是一种顺序容器（sequential container）
标准库定义了三种顺序容器类型：vector、list 和 deque（是双端队列“double-ended queue”的简写，发音为“deck”）
顺序容器适配器包括 stack、queue 和 priority_queue 类型

顺序容器
vector 支持快速随机访问
list 支持快速插入/删除
deque 双端队列 

顺序容器适配器 
stack 后进先出（LIFO）堆栈
queue 先进先出（FIFO）队列
priority_queue 有优先级管理的队列 
对应头文件
#include <vector>
#include <list>
#include <deque>

容器类型的操作集合形成了以下层次结构：
•  一些操作适用于所有容器类型。 
•  另外一些操作则只适用于顺序或关联容器类型。 
•  还有一些操作只适用于顺序或关联容器类型的一个子集。

定义某种特殊的容器
vector<string> svec; 
list<int> ilist; 
deque<Sales_item> items; 
C<T> c： 创建一个名为 c 的空容器。C 是容器类型名，如 vector，T 是元素类型，如 int 或 string 适用于所有容器。 
C c(c2)： 创建容器 c2 的副本 c；c 和 c2 必须具有相同的容器类型，并存放相同类型的元素。 适用于所有容器。 
C c(b, e)：创建 c，其元素是迭代器 b 和 e 标示的范围内元素的副本。 适用于所有容器。 
C c(n,t)：用 n 个值为 t 的元素创建容器 c，其中值 t 必须是容器类型 C 的元素类型的值，或者是可转换为该类型的值。 只适用于顺序容器 
C c(n)： 创建有 n 个值初始化（第 3.3.1 节）（value-initialized）元素的容器 c。 只适用于顺序容器 

vector<int> ivec; 
vector<int> ivec2(ivec); // ok: ivec is vector<int> 
list<int> ilist(ivec); // error: ivec is not list<int>
vector<double> dvec(ivec); // error: ivec holds int not double
将一个容器复制给另一个容器时，类型必须匹配：容器类型和元素类型都必须相同

 

 

 

===========其他专业英语名词======

access labels（访问标号）
compound type（复合类型）
const reference（const 引用）
constant expression（常量表达式）
constructor（构造函数）
copy-initialization（复制初始化）
declaration（声明）
direct-initialization（直接初始化）
enumeration（枚举）
escape sequence（转义字符）
header guard（头文件保护符）
identifier（标识符）
implementation（实现）
integral types（整型）
literal constant（字面值常量）
local scope（局部作用域）
lvalue（左值）rvalue（右值）
magic number（魔数）
nonconst reference（非 const 引用）
nonprintable character（非打印字符）
preprocessor（预处理器）
private member（私有成员）
public member（公用成员）
separate compilation（分别编译）
statically typed（静态类型的）
type-checking（类型检查）
undefined behavior（未定义行为）
uninitialized（未初始化的）
unsigned（无符号型）
variable initialization（变量初始化）

cctype 头文件中定义 #include <cctype>（C 标准库的 ctype.h 头文件，多了个c少了.h）
isalnum(c) 如果 c 是字母或数字，则为 True。 
isalpha(c) 如果 c 是字母，则为 true。 
iscntrl(c) 如果 c 是控制字符，则为 true 
isdigit(c) 如果 c 是数字，则为 true。 
isgraph(c) 如果 c 不是空格，但可打印，则为 true。 
islower(c) 如果 c 是小写字母，则为 true。 
isprint(c) 如果 c 是可打印的字符，则为 true。 标点符号则是除了数字、字母或（可打印的）空白字符（如空格）以外的其他可打印字符
ispunct(c) 如果 c 是标点符号，则 true。 
isspace(c) 如果 c 是空白字符，则为 true。 空白字符则是空格、制表符、垂直制表符、回车符、换行符和进纸符中的任意一种
isupper(c) 如果 c 是大写字母，则 true。 
isxdigit(c) 如果是 c 十六进制数，则为 true。 
tolower(c) 如果 c 大写字母，返回其小写字母形式，否则直接返回 c。 
toupper(c) 如果 c 是小写字母，则返回其大写字母形式，否则直接返回 c
和返回真值的函数不同的是，tolower 和 toupper 函数返回的是字符，返回实参字符本身或返回该字符相应的大小写字符。

===
abstract data type（抽象数据类型）
bitset
cctype header（cctype 头文件）
class template（类模板
container（容器）
difference_type
getline
high-order（高阶）low-order（低阶）
index（索引）
iterator（迭代器）
iterator arithmetic（迭代器的算术操作）
off-the-end iterator（超出末端的迭代器）
push_back
sentinel（哨兵）本章中使用由 end 操作返回的迭代器作为保护符
size由库类型 string、vector 和 bitset 定义的函数， 分别用于返回此三个类型的字符个数、元素个素、二进制位的个数
size_t cstddef 头文件中定义的机器相关的无符号整型， 该类型足以保存最大数组的长度
size_type 由 string 类类型和 vector 类类型定义的类型，用以保存任意 string 对象或 vecotr 对象的长度
using declarations（using 声明）
value initialization（值初始化）

#include <cstring>
strlen(s)  标准库函数 strlen 用于计算 C 风格字符串中的字符个数，到\0结束，不包括 null 结束符
调用 strncpy 时，要求复制 17 个字符：字符串 cp1 中所有字符，加上结束符 null。
strcmp(s1, s2)=比较两个字符串 s1 和 s2 是否相同。若 s1 与 s2 相等，返回 0；若 s1 大于 s2，返回正数；若 s1 小于 s2，则返回负数
strcat(s1, s2)
strcpy(s1, s2)
strncat(s1, s2,n) 将 s2 的前 n 个字符连接到 s1 后面，并返回 s1 
strncpy(s1, s2, n) 将 s2 的前 n 个字符复制给 s1，并返回 s1

compiler extension（编译器扩展）
delete expression（delete 表达式）:delete 表达式用于释放由 new 动态分配的内存： delete [] p;
new expression（new 表达式）用于分配动态内存的表达式。下面的语句分配了一个有 n 个元素的数组：new type[n];
dynamically allocated（动态分配的
free store（自由存储区）
heap（堆）