第一章
文件头及声明
关于extern
使用extern 声明而不定义，它是说明变量定义在程序其他地方
全局不初始化的extern int i; 是声明不定义；只要声明并且有初始化式，那么就是定义；带有extern且有初始化的声明（也是定义），比如extern float fval =2.34; 这种必须放在函数外面，否则出错
文件B要访问另外一个文件A中定义的变量，那么在B中必须先extern声明一下，并且不需要include A。另外，A中定义的变量一定是全局变量。
Extern C
const常量在函数外定义默认是文件级，别人不可访问。要想成为程序级（被其他文件访问）必须要加extern。A.pp中extern const int ival=23;而在B.cpp中extern const int ival;声明一下就可以使用(声明时const不是必须，但最好加上)。另外，const常量在声明的时候必须初始化，如果是使用常量表达式初始化，最好放在头文件去定义（头文件特殊的可以放定义的三个之一）。否则只能放在源文件中定义，并加上extern以能被多个文件共享。
struct MSGMAP_ENTRY {
UINT nMessage;
void (*pfn)(HWND, UINT, WPARAM,LPARAM);
};
struct MSGMAP_ENTRY _messageEntres[] = {
WM_LBUTTONDOWN, OnLButtonDown,
WM_RBUTTONDOWN, OnRButtonDown,
WM_PAINT, OnPaint,
WM_DESTROY, OnDestroy
};
关于结构体的说明:
上面定义了一种结构体类型后，后面要定义数据类型时就要struct MSGMAP_ENTRY 变量名。 蓝色部分就是当变量类型使用
第二章
变量和基本类型
1. 只有内置类型存在字面值，没有类类型或标准库类型的字面值（可以这样理解，是内置类型组成了其他类型）。
C++中有整型字面值，浮点字面值，布尔字面值和字符字面值，字符串字面值，转义序列，多行字面值
2. 下面
a) ‘数字1’＝＝＝0x31 (49)
b) ‘A’＝＝＝0x41 (65)
c) ‘a’=====0x61(97)
3. 由空格，制表，换行连接的字符串字面值可以连接成一个新的字符串
但是连接字符串与宽字符串的结果就不可预料了
代码续行 \后面不能有空格，只能是回车，接下来的一行要从头开始，没有缩进 字符串换行要加/ ＝＝＝》小线倾斜的方向不一样
4. 1024f有错，整数后面不能有f
5. 2.34UL有错，浮点数后面不能有U
6. 标识符不能以数字开头
7. 直接初始化与复制初始化 int ival = 123; int ival(34);
8. int ival = 09; 错！ 八进制数，不能有大于等于8的数字
9. 函数外定义的变量初始化为0，函数内的变量不进行初始化（可能是一些无意义的值但是合法的值，所以造成错，所有编译器难以发现所有这类错）
所以，建议每个内置类型对象都要初始化
在函数外定义的类类型对象使用默认构造函数初始化，对于没有默认构造函数的类型，要显式初始化，即使用带参构造函数
10. 初始化不是赋值。初始化要分配空间并给初值，而赋值则是要替换当前值
11. 声明与定义的区别
a) 定义要分配空间，一个变量程序中只能定义一次
b) 声明用于向程序表明自己的名字和类型，程序中可以出现多次；定义也是声明，定义的时候也声明了它的名字和类型
c) 使用extern 声明而不定义，它是说明变量定义在程序其他地方
函数内或外int i; 都是定义（都分配空间，但函数内没有初始化为0） // 不能放在头文件中。
d) 全局不初始化的extern int i; 是声明不定义；只要声明并且有初始化式，那么就是定义；带有extern且有初始化的声明（也是定义），比如extern float fval = 2.34;这种必须放在函数外面，否则出错
e) 文件B要访问另外一个文件A中定义的变量，那么在B中必须先extern声明一下，并且不需要include A。另外，A中定义的变量一定是全局变量。
f) 在正式编写程序语句前定义的一些全局变量或局部变量，在C中为声明，C++中为定义
( int a;//在标C中为声明，是不可执行语句；在C++中为定义)
12. 定义在函数外的变量有全局作用域
13. 局部同名变量屏蔽了上层作用域的变量，烂程序，不易读。在局部中要想使用全局中的同名变量在变量前使用域作用符::
14. 在内建数据类型的情况下，++i与i++效率没区别，在自定义数据类型的情况下++i的效率高
15. c++中，定义和声明可以放在任何可以放语句的位置，所以，通常把一个对象定义在首次使用它的地方是一个很好的办法
16. const int pi = 3.14; 采用const易维护（在多次出现3.14的地方使用const变量来代替）
再比如:
const int max = 23;
for (int i = 0; i != max; ++i)
标准C++中，for中定义的i只在语句作用域中(for语句)，出了for就不可见了
17. 全局变量的程序级与文件级, const全局变量
a) 普通变量在函数外定义就是程序级，别的文件要使用只先extern声明一下就行。并且不用include变量定义的文件
b) const常量在函数外定义默认是文件级，别人不可访问。要想成为程序级（被其他文件访问）必须要加extern。A.pp中extern
const int ival=23;而在B.cpp中extern const int ival;声明一下就可以使用(声明时const不是必须，但最好加上)
c) const常量在声明的时候必须初始化，如果是使用常量表达式初始化，最好放在头文件去定义（头文件特殊的可以放定义的三个之一）。否则只能放在源文件中定义，并加上extern以能被多个文件共享。
18. 关于const引用与非const引用与它们所绑定的对象的关系：(const引用是指向const对象的引用，非const引用是指向非const对象的引用)
a) 非const引用类型必须要与它所引用的变量的类型一致(非const引用只能绑定到与该引用同类型的对象，而不能是右值)
int ival =12;
int &ref = dval 或34; //error 初始化的时候只能绑定到同类型的对象（不能是右值）。 非初始化的时候可以被赋值，引用与其绑定的对象的值都会改变
b) const引用可以绑定到不同但相关（即可以转化）的类型的对象（可以是非const对象）或右值
比如[const] double dval= 3.14; //这里要不要const都行
const int &refVal = dval; // warning,编译器会中间把3.14转成int temp的3,然后再给了refVal，这里编译不出错，但是会给出警告
constint &refVal2 = 2.33; // warning，这里const不可少，不然不使用右值
refVal2 = dval; // error, const引用的值不可改变
19. enum color {red, blue=4, white};其中white是5
枚举成员是常量而不能改变，所以初始化时要用常量表达式，const常量与整形字面值都是常量表达式
扩展color black = red; // 必须使用里面定义的来作为右值进行初始化
color pink = 3; // error
20. 设计类：从操作开始设计类。先定义接口，可以决定需要哪些数据以及是否需要私有函数来支撑公有函数
21. class与struct定义类仅仅影响的是默认访问级别，struct为public，class为private
22. c++支持分别编译separatecompilation，头文件和源文件。将main放在其他的源文件中.
头文件中有类定义，extern变量声明，变量和函数声明，带来的莫大的好处，一是统一性：保证所有文件使用的同一声明，二是易维护:需要修改时，只改头文件就行了，易维护
设计头文件时注意：声明最好放在一起。编译头文件需要一定的时间。有些C++编译器支持预编译头文件，需要查手册。
头文件用于声明，而不是定义——有三个例外：类定义，用常量表达式初始化的const变量和inline函数的定义。它们可以在多个源文件中定义(相当于头文件被include到了多个源文件中)，只要在多个源文件中的定义时相同的。
解释：允许在头文件中定义类和inline函数是因为编译器需要它们的定义来产生代码，对于类类型需要知道类对象的数据成员和操作才能分配空间。但是对于单个源文件A.cpp为了避免多重包含，在定义时须加#ifndef与#endif（头文件应该有保护符，会被其他文件包含）
如果将inline函数的定义放在某源文件中，那么其他源文件将永远访问不到
允许在头文件中定义const常量的原因：const常量是文件级作用域的，多个文件包含它互不影响，不算是重复定义。所以可以在头文件中定义。多个文件共享const变量的前提是必须保证多个文件使用的是相同的名称和值，将它放在头文件中，谁需要的时候就include它就行，安全方便。
另外要注意：在实际中，源文件里大多编译器只是像宏替换一样的使用常量表达式来替换const变量，而没有分配空间来存储用常量表达式初始化的const变量。
如果const变量不是用常量表达式初始化的，这就不应该放在头文件中定义。此时它应该放在源文件中定义并初始化，加上extern以使它能够被多个文件共享。
23. //Page58页小字部分：编译和链接多个源文件组成的程序
24. 关于inline函数
inline函数目的是：为了提高函数的执行效率(速度)。以目标代码的增加为代价来换取时间的节省。
非内联函数调用有栈内在的管理，包括栈创建和释放的开销。函数调用函数调用前保护好现场，返回后恢复现场，并按原来保存的地址继续执行。对于短小且频繁执行的函数，将影响程序的整体性能
在C中可以用#define，编译器用复制宏代码的方式取代函数调用，但没有参数类型检查。
有两点特点注意的：
（1） 内联函数体中，不能有循环语句、if语句或switch语句，否则，函数定义时即使有inline关键字，编译器也会把该函数作为非内联函数处理。
（2） 内联函数要在函数被调用之前定义，否则内联失效。将它的定义放在头文件中就很好的可以做到这点，由于是在源文件中先include，再后面调用的，就保证了调用之前定义
（3）关键字inline必须与函数定义体放在一起才能使函数真正内联，仅把inline放在函数声明的前面不起任何作用。因为inline是一种用于定义的关键字，不是一种用于声明的关键字。（根据高质量C/C++指南，声明前不应该加，因为声明与定义不可混为一谈）
25. 复合类型compoundtype，引用，数组，指针
第三章标准库类型
1．#include<string>
usingstd::string;
using std::cout;
2．头文件中定义确定需要的东西
3. 注意区分string类型与字符串字面值
4. 在Windows下用命令行要编译和运行.cpp文件
打开vs2005命令提示
cl /EHsc simple.cpp 生成exe文件//EHsc 命令行选项指示编译器启用 C++ 异常处理
若要运行 simple.exe 程序，请键入 simple 并按 Enter
要加入程序变量: simple < data\book_sales
vs2005中同样也可以加入程序变量，就在命令行参数里
5.
a) cin.getline(char*, int, char) // 是istream流
// 可以接收空格并输出，它的参数有三个，第三个是结束符，默认为'\n'
char ch[20];
cin.getline(ch,5);
cout<< ch << endl; // 输入abcdefg,输出abcd最后一个为'\0'
//这个\0是自动加上的，所以可以cout << ch;
char ch[20];
cin.getline(ch,5,'a'); // 遇到a结束，并加上\0
cout<< ch << endl; //输入xyamnop，输出xy
b) getline(cin, str)， 须加#include <string> // 是string流
#include <string>
istream& getline( istream& is, string& s, char delimiter = '\n' ); // delimiter分隔符
接收一行字符串，可以接收空格并输出，遇到回车返回，并丢掉换行符。
不忽略行开头的换行符，如果第一字符是回车，那么str将是空string
逐行输出：
string str;
while(getline(cin, str)) {
cout << line << endl; // 由于不含换行符，需要endl刷新输出缓冲区
}
逐词输出：
string str;
while (cin>> str) {
cout << str << endl;
}
c) cin.get()吃掉没有用的字符，读到回车才退出
d) char ch1[100],ch2[100];
cin >> ch1 >> ch2; //接收字符串，忽略有效字符前的空白字符，以空白符(空格，TAB，回车)作为输入结束
而getline(cin,str)
不忽略开头的空白字符，读取字符直到遇到换行符，读取终止并丢掉换行符
e) gets(str) 接收一个字符串，可以接收空格并输出。加#include<iostream>
与getline(cin,str)类似
f) getchar()无参数，须加#include <string>，是C中的函数，尽量少用或不用
6. str.size()的实现（返回有效字符的个数，不含最后的空字符，它的类型是string::size_type）
constchar *st = "The expense of spirit\n";
int len = 0;
while (*st) { ++len; ++st; }
str.size的应用
for (string::size_type ix = 0; ix !=str1.size(); ++ix)
7. string对象可以＝＝, >=, <= !=操作
8. string的赋值操作：str1 = str2；须先把str1的内存释放，然后再分配能存放副本大小的空间，再复制过来
9. string s2 = “hello” + s1; //error，开头必须是变量
10. #include <cctype> p77页
isalnum(c) 字母数字
isalpha(c) 字母
iscntrl 控制字符
isdigit 数字
isgraph 不是空格但是可以打印
islower 小写
isprint 可打印
ispunct 标点
isspace 空格
isupper 大写
isxdigit 十六进制数
tolower 变小写
toupper
11. p78 使用C标准库头文件，使用#include <cname>不要用#include <name.h>，这样保证标准库文件中的名字与std中的一致
12. string s;
cout << s[0] << endl; // error
13. t3_10，输入一个字符串，去掉里面的标点：
ispunct(ch)
result_str+= ch;
14. string是数据类型，vector是模板 vector<string>是数据类型
15. vector<Student> v5(4); // 4个实例，必须有默认初始化构造函数
vector<int>v3(10,5); // 10个5
虽然能预先分配内存，但使用空vector来push_back更好
for(ix!=vector_size) vec.push_back(ix*5);
vector<int>ivec; //是个空vector，没有分配空间,所以ivec[0]=3;//error
for(vector<int>::size_type ix = 0; ix != ivec.size(); ++ix) //由于是动态变化的，所以这时使用函数
vector<int>ivec(10); // 10个0
for(vector<string>::const_iterator it = ivec.begin();it != ivec.end(); ++it) { // 如果ivec为空，则for不执行
//cout << *it << endl;
*it = 42;// error遍历只读
}
vector的操作p81 , ==, !=, < >=
16. 迭代器可以==或!=操作，若指向同一个元素 则相等
迭代器的算法操作
it+n size_type类型
it-n difference_type类型
it1-it2 difference_type类型 it1或it2可以是vec.end()
记住：push_back()等改变长度的操作，使存在的迭代器全部失效!!
vector<int>::iterator
17. bitset<n> b; // n个0 //n必须是字面值或用常量值初始化的const对象
bitset<n> b(u); // b是unsigned long型u的一个副本
bitset<n> b(s); // 字符串
bitset<n> b(s, pos, n); // 字符串pos开始的n个
如：
bitset<16> bitvec1(0xffff); // 高十六个0去掉, 0到15位设为1
0xffff代表32位的unsigned long，高十六个0，低十六个1
bitset<128> bitvec2(0xffff); // 31位以上的都是0
string s(“1100”); // s[0]值为1
bitset<8> bitvec3(s); // 读入位集的顺序是从右向左(用string最大下标元素来赋值给bitvec的最小下标值),结果是0000 1100， 这样bitvec[0]的值是最右的那个0
size_t sz = bitvec1.size(); // #include <cstddef>
//一个与机器相关的unsigned类型，其大小足以保证存储内存中对象的大小
if (bitvec.test(i))
if (bitvec[i])
bitvec.reset(); 全为0
bitvec.set(); 全为1
bitvec.flip(1);
bitvec[1].flip();
bitvec.flip(); // 全部取反
uLong = bitvec.to_ulong(); 取回unsigned long值
// 若bitvec的位数128超过了unsigned long长度，那以会产生overflow_error异常
t3_24:
1,2,3,5,8,13,21的相应位置为1
bitset<32> b;
int x = 0, y = 1, z = x + y;
while (z <= 21) {
b.set(z);
x = y;
y = z;
z = x + y;
}
第四章数组和指针
1. int arr[32]; // 维数必须是字面值，枚举常量，常量表达式初始化的const变量
上面这句话在函数外，则初始化为0
若定义在函数内，没有初始化，但分配了空间
int arr[5] = {1,2,3}; // 剩下的初始化0，若是类类型就使用默认初始化构造函数, java中不行，不能写维数的
vector<int> ivec = {1,2,3}; // error，vector没有这样的初始化
2. 数组不能直接复制和赋值
3. 数组下标越界导致：buffer overflow
4. 比较两个vector，先比较长度
5. 现代C++使用vector替换数组，使用string替换C风格字符串
6. 关于指针：
a) string* s1, *s2看上去很不好，所以尽量将*与变量名放在一块
b) 避免使用未初始化的指针
C++没有办法检查出未初始化的指针，使用它可能会导致基础数据
如果要指向的对象还没有存在，那么就先不要定义这个指针。如果要定义，就＝0或NULL（#include <cstdlib>）
预处理器变量NULL不是在std命名空间中定义的，所以不是std::NULL
c) void *
void* 这不叫空指针,这叫无确切类型指针.这个指针指向一块内存,却没有告诉程序该用何种方式来解释这片内存.所以这种类型的指针不能直接进行取内容的操作.必须先转成别的类型的指针才可以把内容解释出来；
'\0'不是空指针所指的内容，而是表示一个字符串的结尾,不是NULL；
真正的空指针是说,这个指针没有指向一块有意义的内存,比如说:
char* p;
这里这个p就叫空指针.我们并未让它指向任意地点，又或者 char* p = NULL；这里这个p也叫空指针,因为它指向NULL 也就是0,注意是整数0,不是'\0'
一个空指针我们也无法对它进行取内容操作.
空指针只有在真正指向了一块有意义的内存后,我们才能对它取内容.也就是说要这样p = "hello world!"; 这时p就不是空指针了
后面会看到：不能使用void*指向const对象，必须使用const
void *类型的指针保存const对象的地址
void *p; 只支持以下操作：
与另一指针比较
作参数或函数返回值
给另一个void *赋值
7. 指针与引用的比较：
引用定义时必须初始化！
引用被赋值后改变的是所引用的对象
指针被赋值后将会指向另一个变量的地址，不专一
8. int arr[5];
int *p = arr;
int *p2 = p + 2;// 那么，p的算术运算要求原 指针与计算出的新指针都要指向同一数组的元素，结果范围必须在[0,5],//注意这里5也算合法结果
注意：C++允许计算数组或对象的超出末端的地址，但不允许对此地址进行解引用操作
可以把指针看成是数组的迭代器
ptrdiff_tn = p1 – p2; // #include <cstddef>
// 与机器相关：size_t是unsigned, ptrdiff_t是signed
注意，ptrdiff_t只保证指向同一数组的两个指针间的距离，若是指向不同的指针，那么error
t4_17:
p1 += p2– p1; 若p1与p2指向同一数组那么始终合法，让p1指向p2所指向的地址
9. 关于const指针
a) 指向const对象的指针
const double pi = 3.14; // 不能用普通指针来指向它 但是相反地，可以用const double*的指针指向非const的变量
const double *cptr = 0或NULL; //这里const限定的是所指向的对象，而不是cptr本身，所以定义的时候可以不初始化,
蓝const是必须的,防止通过cptr来改变所指对象的值
cptr = pi; // 也可以在定义的时候初始化
指向const对象的指针可以指向非const对象
注意：不能保证cptr指向的对象的值一定不可修改！它完全有可能指向一个非const对象，将它赋给普通指针就可以改
double dval = 2.34; // 非const
cptr = &dval; //可以指向一个非const对象，但仍不可通过cptr来修改
const void *cpv = pi; // ok ，不能使用void*指向const对象，必须使用const
void *类型的指针保存const对象的地址
t5_33: 将一个指向const对象的指针成void *
const string *ps;
void *pv;
pv = (void *)ps; // error!!!应该按下面写
pv = static_cast<void*>(const_cast<string*>(ps));
把ps变成string*之后再转成void*，就是说，先去掉const特性
static_cast<void*>跟(void *)差不多，就相当于强制转化
//============找回原来指针值，与上例t5_33没关系
对于void *pv;
小括号强制转化pc = (char*)pv; // 找回原来指针值
或者pc =static_cast<char*>(pv);
b) const指针 //不能再指向别的对象，但能改变所指向对象的值
int ival = 32;
int *const ptr = &ival; // 从右向左读：指向int对象的const指针
*ptr = 34; 则ival的值也变成34了。
但ptr = &ival2; //error指针值不可变
c) typedef与const指针
typedef string *pstring;
const pstring cstr; // 这里不要简单的理解为const string *cstr, 这里const限定的是指针，而不是所指对象!! string* const cstr 最好写成pstringconstcstr;
好理解
10. t4_19:
const int ival; // error必须初始化
int *const ptr1; // error必须初始化
const int *ptr2; // ok,可以不用初始化
const int ival2 = 23; // 不能由指向非const对象的指针来指向它
int *const ptr2 = &ival2; // error，指向非const对象的指针不能指向const对象
11. p113讲：C风格字符串尽量少用，因为它常常带来很多错误，是导致大量安全问题的根源!
c-style character string
const char *cp = “hello world”;
while (*cp) {
//TODO..
++cp;
}
c风格字符串的库函数：#include <cstring>
strlen(s)// 返回有效长度
strcmp
strcat
strcpy
strncat(s1, s2, n) // 前n个字符， 返回s1
strncpy(s1, s2, n)
实参指针不能是空指针，即指向0或NULL的指针。且指向以NULL结束的字符数组中的指针
必须确保目标字符串足够大，否则造成安全漏洞
char ca[] = {‘a’,’b’,’c’};
strlen(ca); // error!!!
使用strn比strcat strcpy更安全
strncat连接时，第二个字符串要覆盖掉第一个字符串的NULL
12. t4_25
两个string类型的比较可以使用>,< 而两个C风格字符串比较使用strcmp
它们读入：t4_26
string str;
cin >> str;
size_t str_size = 90;
char ch[str_size];
cin >> ch;
13. 创建动态数组, 在运行时确定长度
int *p = new int[3]; //内置类型分配空间 无初始化
int *p = new int[4](); 值初始化为0, 但没有初始化值列表的形式
const int *p = new const int[22](); //最后的()是必须的,不然就没有初始化const元素 ,虽然vs2005通过
string *pstr = new string[4]; // 分配空间 使用默认构造函数初始化
const char *p4 = s2.c_str();
14. int arr[0]; // error，不能为0
int *parr = new int[0]; // ok, 可以为0，但是parr不能进行解引用操作
15. delete[] parr; // 漏掉[]编译器不会发现错，运行时错
16. 使用string比C风格字符串的程序执行速度要快很多
17. 可以使用C风格字符串对string对象赋值或初始化
C风格字符串可以作为左操作数与string对象相加
char*ch = "hello ";
strings("good");
strings2;
s2 =ch +s; // ok
s2= “abc” + ch + s; // error
18. 使用数组初始化vector
in iarr[6] = {0,1,2,3,4,5};
vector<int> ivec(iarr+1, iarr+4); //[a,b)，不包括iarr[4]
19. t4_34
vector<string> ivec;
string str;
while (cin >> str) { // 读入一组string放在vector中
ivec.push_back(str);
}
//下面是将vector这组string拷到一个字符指针数组中。
char **pa = new char*[ivec.size()];
size_t k = 0; // #include <cstddef>
for(vector<string>::iterator it = ivec.begin(); it != ivec.end(); ++it) {
char *p = new char[(*it).size() +1]; // 分配空间
strcpy(p, (*it).c_str()); //拷贝 #include <cstring>
pa[k++] = p;
}
20. int *p[3];
int (*p)[3];
21. 使用typedef简化多维数组
int ia[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
typedef iint int_array[4];
int_array *p; // p也可以定义为 int (*p)[4];
for (p = ia; p != ia + 3; ++p;) {
for(int *q = *p; q !=
*p+ 4; ++q) {
cout<< *q << endl;
}
}
第五章表达式
1. 指针不能转化为浮点类型
2. short [-32768,32767]
unsigned short: [0, 65535]
int: [-21.4亿， 21.4亿]
3. -21 % -8 值为 -5
4. 对于位操作，由于系统不能确保如何处理符号位，所以建议使用unsigned数!
左移补0
unsigned char ch = 0277;
ch = ~ch; 全部取反 flip操作
ch << 1; // 左移，右边补0
//右移左边补0; 右移个数要小于8(操作数的位数)
对于signed，右移补0还是符号位根据机器而定
bitset优于整数数据的低级直接位操作
bitset_quiz1.set(27);
int_quiz1 |= 1UL << 27;
bitset_quiz1.reset(27);
int_quiz1 &= ~(1UL << 27);
<<优先级高于<
所以 cout << (10 < 32); // ok
cout << 10 < 32; // error
5. i + j = k; // error
int i;
const int ci = i; // ok, 将来ci无意义
6. int a; int *p;
a = p = 0; // error 不能将指针类型赋给int
7. a += b; a计算了一次， a = a + b; a计算了两次
8. 使用++i而不用i++:
工作量少啊，后置操作要先保存操作数原来的值，以便返回未加1之前的值作为操作的结果。
9. .>* 取成员操作大于解引用操作
(*pstu).name = “leiming”;
pstu->name = “leiming32”;
++>* ++也大于解引用操作
*iter++ 相当于 *(iter++)
10. t5_18:定义一个string指针的vector,输入内容，然后输出
vector<string *> vec;
string str;
cout << "enter strings:" ;
while (cin >> str) {
string *pstr = new string; // 必须新分配一块地方
// string *pstr = &str;不对，指向同一空间啦
*pstr = str; // 每个指针单独指向一块空间，赋值
vec.push_back(pstr);
if(vec.size()==4) cout <<"vec[1]:" << *vec[1] << endl;
}
for (vector<string *>::iterator it =vec.begin(); it != vec.end(); ++it) {
cout <<**it << ", len: " << (**it).size()<< endl;
}
11. 三种语法：
sizeof (expr)
sizeof (type name) // 必须加括号
sizeof expr : 并没有计算表达式的值
Sales_item item, *p;
sizeof item;
sizeof *p; // 并没有解引用操作, p指向一块没有意义 的地址
sizeof (Sales_item)
12. 逗号表达式的是其最右边表达式的值
13. int *p = new int;
//ok 没有初始化
int *p = new int();// ok，p所指的对象内容初始化为0
int *p = 0;
delete p; // ok，可以删除空指针
delete p;之后，删掉了它所指向的对象，p此时成了悬挂指针，应该p = 0;
如果你使用delete是未加括号，delete便假设删除对象是单一对象。否则便假设删除对象是个数组。delete[] 相比 delete 会多做一件事，就是在删除这个内存块前，析构每个元素，特别是对于对象数组
万一需要重载 new, delete,new[], delete[], 我们必须全部都重载，而不能仅仅重载 new, delete, 然后希望 new[],delete[] 会调用它们
string*stringPtr1 = new string;
string *stringPtr2 = newstring[100];
……
delete stringPtr1;
delete [] stringPtr2;
如果你对着stringPtr1使用“[]”形式，其结果未定义。如果你对着stringPtr2没有使用“[]”形式，其结果亦未定义。犹有进者，这对内建型别如int者亦未定义，即使这类型别并没有destructors。
游戏规则很简单，如果你在调用new时使用了[]，则你在调用delete时也使用[]，如果你在调用new的时候没有[]，那么你也不应该在调用时使用[]。
14. a[][5]; // 第一维可缺省 ，5不可省
15. 动态创建const对象：
const int *pci = new const int(32); // 定义的时候必须初始化，初始化后就不可以修改 pci指向一个const对象，所以它也要是const的
1) 普通指针不能指向const对象;
void reset(int *pi) //实参不能是指向const int对象的指针
// 为了保护所指向的值，一般地将定义为指向const对象的指针
void reset(const int *cpi);
2) 指向const对象的指针可以用普通指针来初始化
3) 指向const对象的指针可以指向非const对象，但不能修改它，可以赋给非指向const对象的指针来改;
4) 可以使用普通指针初始化const指针
5) 不能用const对象来初始化非const的引用
6) 可以使用const对象来初始化非const对象，反之亦然
所以const形参的时候，实参可以是const对象也可以是非const对象
C语言中，const形参与非const形参没有区别，为了支持与C的兼容，编译器将const形参看作是普通的形参，所以const不能看作是函数重载的根据
const string *pcs = new conststring; // ok
内置类型的以及没有默认构造函数的类型必须显式初始化
可以删除const指针：
delete pci; // ok
delete pcs; // ok
16. t5_30:
vector<string> svec(10); // 十个空串元素
vector<string> **pvec = new
vector<string>[10]; // error
//右边返回的是一个指向元素类型是vector<string>的指针
17. 算术转换：
char, signed char, unsigned char, short, unsignedshort如果能包容在int内则转换为int，否则转成unsigned int(主要针对unsiged short)
bool 提升为int， false转为0， true转为1
inta = 2 + true;
cout<< a << endl; // 3
向上提升：int->unsigned int->long->unsignedlong
signed int + unsigned int,则signed int会转为unsigned int
unsignedchar b = -1; // 1000 0001，符号位不变所有位取反，再加1 : 1111 1111
cout<< (int)b << endl; // 255
inti = 32;
constint &iref = i; // 使用非const对象初始化const对象的引用，将非const对象转成const对象
i= 33;
//iref= 34; // error
cout<< iref << endl; //ok, iref要随着i而变 = 33
const int *cpi = &i; // 非const对象的地址（或非const指针）转成指向相关const类型的指针
int *pi = &i;
const int *cpi2 = pi; // 可以使用非const指针初始化const指针
18. 显式转换
1) 什么时候使用
i. 强制转换
ii. 存在多种类型转换时，需要选择一种特定的类型转换
2) cast-name<type>(expression)
dynamic_cast
运行时识别指针或引用所指向的对象
3) const_cast
int*cpi3 = const_cast<int *>(cpi);// 是指针或对象
//*cpi= 100; // error
*cpi3= 43;
cout<< "i=" << i << endl;
const int ci = 32;
int ival = const_cast<int>(ci);//error不能从const int转int
int &iref2 = const_cast<int&>(ci); // 可以将const转换掉
iref2 = 35;
cout << ci << endl; // 32
cout << iref2 << endl; // 35
4) static_cast
int ival = static_cast<int>(2.4); // 关闭警告,不关心精度丢失
可以找回放在void*中的地址值：
double dval = 2.33;
void *p = &dval;
double *pd = static_cast<double*>(p);
5) reinterpret_cast
为操作数的位模式提供较低层次的重新解释，依赖于机器，要阅读编译器细节。
int *ip;
char *pc = reinterpret_cast<char*>(ip);//不能把pc看成是普通字符指针,程序员必须记住pc指向真正指向的是int
string str(pc); // compile error
6) 最后：避免使用强制类型转换，也能写出好程序
使用const_cast抛弃cast属性意味着设计缺陷
有些强制转换有危险
如果必须要用，则限制强制转换值的作用域，记录所有假定涉及的类型
7) 在新编译器上写程序，最好不要用()式的老强制转换
19. dval = ui * fval; // ui先转成float再乘，结果是double