@w.cn邮箱注册地址：
https://domains.live.com/members/signup.aspx?domain=w.cn

@9.cn邮箱注册地址：
https://domains.live.com/members/signup.aspx?domain=9.cn

标记为编译时刻错误
3.c++预定义可重载的操作符:
   + - * / % ^ & | ~
   ! , = < > <= >= ++ --
   << >> == != && || += -= /=
   %= ^= &= |= *= <<= >>= [] ()
   -> ->* new new[] delete delete[]
4.对于内置类型的操作符, 它的预定义意义不能被改变
5.预定义的操作符优先级不能被改变
6.除了operator()外, 对其他重载操作符提供缺省实参都是非法的

operator)的定义
2.new类对象 --只有new表达式成功的申请到空间内存, 构造函数才会被调用
3.构造函数定义为inline时, 创建对象是会在调用点展开构造函数
4.成员初始化列表(member initialization list)
5.构造函数不能用const或volatile关键字来声明
   一个const类对象在"从其构造函数完成到析构函数开始"这段时间内才被认为是const, volatile类对象也一样
6.explicit修饰符通知编译器不要提供隐式转换
   void print(const CTest &test);
   //...
   print("oops");  //这种调用会把"oops"转换成一个CTest对象
   缺省情况下, 单参数构造函数(或者有多个参数, 除了第一个参数外, 其他都有缺省实参)被用作转换符
   无意的隐式类转换, 是很难跟踪的错误!, 关键字explicit被引入到标准c++中, 以帮助我们抑制这种不受欢迎的编译辅助行为
   explicit只能被应用在构造函数上
7.缺省构造函数是不需要用户指定实参就能够被调用的构造函数, --并不意味着它不能接受实参, 只意味着构造函数的每个参数都有一个缺省值与之关联
8.限制对象创建 --把相关构造函数放到非公有访问区内, 从而限制或显示禁止某些形式的对创建动作
   在实际的c++程序中, 非公有的构造函数主要用处是:
    防止用一个类对象想该类另一个对象做拷贝
    指出只有当一个类在继承层次中被用作基类, 而不能直接被应用程序操纵时, 构造函数才能被调用
9.拷贝构造函数 --用一个类对象初始化该类的另一个对象被称为缺省按成员初始化(default memberwise initialization)
   一个类对象想该类的另一个对象作拷贝是通过依次拷贝每个非静态数据成员来实现
   类设计者可以通过提供特殊的拷贝构造函数(copy constructor)来改变缺省的行为
   拷贝构造函数不一定是const, 但它却必须是引用
10.无论何时, 当在一个函数内删除一个独立的堆对象时, 最好使用auto_ptr类对象而不是一个实际的指针
   如果delete表达式失败, 如一个异常被抛出, 会到时内存泄露(异常抛出, 跳过了delete操作?), 不会调用析构函数
   所以建议用auto_ptr智能指针
11.对于在堆中分配的类对象数组的元素, 我们没有办法提供一组显示的值来做初始化, 如果细化支持通过new表达式分配数组, 则类必须提供一个缺省的构

造函数, 或不提供构造函数
12.用一个类对象初始化另一个类对象, 称为按成员初始化(default memberwise initialization)
    发生在 用一个类对象显示的初始化另一个对象
           把一个类对象作为实参传递给一个函数
           把一个类对象作为一个函数的返回值传递回来
           非空顺序容器类型的定义
           把一个类对象插入到一个容器类型中
13.成员类对象初始化
14.缺省按成员赋值(default memberwise assignment) --用一个类对象向该类的另一个对象的赋值操作
    用隐式的拷贝赋值操作符
    一般来所, 如果缺省的按成员初始化对于一个类不合适, 则缺省的按成员赋值也不合适
    通过提供一个现实的拷贝赋值操作符的实例, 可以改变缺省的按成员赋值
    注意要防止一个类对象向自己赋值 --对于"先释放与该对象当前相关的资源, 以便分配与被拷贝对象相关资源"这样的拷贝赋值操作符, 拷贝自身尤其不

1.mfc支持两种线程
   用户界面线程
   工作线程
2.mfc中所有线程都是由CWinThread对象表示
    CWinThread是用户接口线程的基类, CWinApp就是从CWinThread派生出来的
    在写用户接口线程时, 也要从CWinThread类派生出自己的线程类
    可以调用AfxBeginThread函数, 会创建CWinThread对象
3.编写是想工作线程的控制函数, 控制函数的原型:
    UINT ControlFunctionName(LPVOID pParam); //线程回调
4.线程调用AfxBeginThread函数就可以创建新的线程
5.创建并启动工作线程:
    CWinThread* AfxBeginThread(
        AFX_THREADPROC pfnThreadProc,
        LPVOID pParam,
        int nPriority = THREAD_PRIORITY_NORMAL,
        UINT nStackSize = 0,
        WORD dwCreateFlags = 0,
        LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);
6.AfxEndThread终止线程
7.创建用户界面线程
    从CWinThread类派生出自己的线程类
    改造这个类
    启动用户界面
8.基类的一些成员函数:
    ExitInstance, 当线程退出是, 会调用执行清理工作
    InitInstance, 执行线程类实例初始化, 子类必须重写
    OnIdle, 执行线程特定空闲时间处理
    PreTranslateMessage, 过滤消息
    Run, 执行线程函数
9.AfxBeginThread函数的另一个重载原型:(界面线程)
    CWinThread* AfxBeginThread(
        CRuntimeClass* pThreadClass,  //用RUNTIME_CLASS宏将线程类指针转换为指向CRuntimeClass对象指针
        int nPriority = THREAD_PRIORITY_NORMAL,
        UINT nStackSize = 0;
        DWORD dwCreateFlags = 0,
        LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL
    );
10.终止线程
    正常终止线程 VOID PostQuitMessage(int nExitCode);
    提前终止线程 在线程内调用AfxEndThread函数 VOID AfxEndThread(UINT nExitCode);
11.线程同步技术
    信号量 --限制使用共享资源的线程数目
        CSemaphore g_Sem(5, 5); 时间内最多只有5个线程能共享资源, 还初始开始时没有线程获得信号资源
            一旦线程访问共享资源, 信号量计数器就减1, 若变为0, 则下来对资源的访问就会被拒绝, 知道持有的资源线程释放了资源的持有权
    互斥对象 --内核对象
    临界区 --用户模式对象 弄不好就容易出现死锁, 不过用起来很简单, 只有4个API
        InitializeCriticalSection, EterCreiticalSection, LeveCriticalSection, DeleteCriticalSection
    事件对象 --内核对象 分收工重置对象和自动重置对象

员
10.类的定义不会引起存储区分配, 只有当定义一个类的对象时, 系统才会分配存储区
11.每个类成员函数的拷贝只有一份
12.把一个成员函数声明为const可以保证这个成员函数不修改类的数据成员, 但是, 如果该类含有指针, 那么在const成员函数中就能修改指针所指的对象,

编译器不会检测为错误, 这常常令c++初学者吃惊
13.为了允许修改一个类的数据成员, 即使它是一个const对象的数据成员, 我们也可以把改数据成员声明为mutable(易变的). mutable数据成员永远不会是

const成员, mutable成员中可以被更新
14.每个类成员函数都含有一个指向被调用对象的指针, 这个指针被称为this:
    在非const成员函数中, 它的类型是指向该类类型的指针
    在const成员函数中, 是指向const类类型的指针
    在volatile成员函数中, 是指向volatile类类型的指针
15.类的静态成员被当做该类类型的全局对象, 对于非静态成员, 每个类对象都有自己的拷贝, 而静态数据成员对每个类类型只有一个拷贝, 静态数据成员只

有一份, 该类类型对所有对象共享访问
16.同全局对象相比, 使用静态数据成员有两个优势:
    静态数据成员没有进入程序的全局名字空间
    可以实现信息隐藏, 静态成员可以是private成员, 而全局对象不能
17.静态数据成员的类型可以是其他所属类, 而非static数据成员只能被声明为该类的对象的指针或引用
18.静态数据成员可以被作为类成员函数的缺省实参, 而非static成员不能
19.静态成员函数的声明除了在类体中的函数声明加上关键字static, 以及不能声明为const或volatile之外, 与非静态成员函数相同, 出现在类体外的函数

定义不能指定关键字static
20.静态成员没有this指针
21.类成员的指针必须总是通过特定的对象或指向该类类型的对象的指针来访问
    针对类对象和引用的.*
    针对指向类对象的指针的->*
22.定义一个成员函数指针需要制定函数返回类型, 参数表和类:
    int (CTest::*)();
    int (CTest::*pmf)() = &CTest::test;
    pmf = &CTest::test2;
23.静态类成员属于该类的全局对象和函数
24.联合:一种节省空间的类
    使用union是危险的, 通过一个不适当的数据成员以为的获取到当前存储在union中的值]
25.c++标准库提供了一个bitset类模板, 它可以辅助操作位的集合, 在可能的情况下, 应尽可能使用它来取代位域
26.一个类可以在另一个类中定义, 这样的类被称为嵌套类(nested class)
    嵌套类是其外围类的一个成员
27.类也可以定义在函数体内, 这样的类被称为局部类(local class)
    局部类的成员函数必须被定义在类定义中, 这就把局部类的成员函数的复杂性限制在几行代码中

对象上
5.catch-all
    try {
        ....
    }
    catch(...) {} //catch-all格式
6.catch子句被检查的顺序与它们在try块之后出现的顺序相同, 一旦找到了一个匹配, 则后续的catch子句将不再检查
7.异常规范(exception specification)
    void foo() throw(Object); //这种声明就是异常规范
    异常声明是函数接口的一部分
8.异常规范不允许重被抛出的异常类型到异常规范制定的类型之间的转换:
    void foo() throw(string) {
        ....
        throw "exception";  //不允许从const char* 到string的转换, 此时调用unexpected()
        throw string("exception"); //可以
    }

    包含编译模式下, 在每个模板被实例化的文件中包含函数模板的定义, 并且往往把定义放在头文件中, 向对内联函数左那样
    --缺点: 函数模板体(body)描述了实现细节
    分离编译模式下, 函数模板声明放在头文件中, 函数模板定义放在cpp文件里

    //.h
    template <typename Type> Type min(Type t1, Type t2);

    //.cpp
    export template <typename Type>
    Type min(Type t1, Type t2) { /* ... */ }

    //关键字 export! 可导出的模板
    //并不是所有的编译器都支持分离模式

stl 找出数组的最小值:

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;

template<typename Type, int size>
Type getMin(const Type (&arr)[size])
{
    cout << "Size:" << size <<endl;
    vector<Type> vec(arr, arr + size);
    sort(vec.begin(), vec.end());
    return vec[0];
}

int main(int argc, char *argv[])
{
    int arr[] = {4, -3, 2, 4, 5, 3, 4, 3};

    cout << getMin(arr) < <endl;
    
    return 0;
}

stl删除重复数据

map字符检索

查到文件之间的类型违例, 这些类型违例可能是程序严重错误的根源
10.头文件为所向extern对象声明, 函数声明以及inline函数定义提供了一个集中的位置: 这被称作声明的局部化(localization)
11.头文件提供了两个安全保证
    保证所有文件都包含同一个全局对象或函数的同一份声明
    如果需要修改声明, 则只需要改变一个头文件
    --只在本cpp用的全局函数, 该不该定义在头文件里面?
12.局部对象(local object)
   自动对象(automatic object)  --程序运行栈
   寄存器对象(register object) --如果所选择的变量被频繁使用, 则寄存器变量可以提高函数的执行速度
   局部静态对象(local static object)
13.当一个自动变量的地址呗存储在一个生命期长与它的指针时, 该指针被称为空悬指针(dangling pointer)
14.动态分配的对象被分配在程序的空闲存储区(free store)的可用内存池中
15.new表达式失败时, 通常会抛出bad_alloc异常
16.应用delete表达式失败, 使内存无法返回空闲存储区, 称作内存泄露(memory leak)
17.对用一内存应用了两次delete表达式, 通常发生在两个指针指向同一个动态分配对象的时候, 这是一个很难跟踪的问题
18.在对象被释放后读写该对象, 这常常会发生, 因为delete表达式应用的指针没有被设置为0
19.为帮助程序员更好地管理动态分配的内存, c++库提供了auto_ptr类类型的支持 --智能指针
20.auto_ptr类模板头文件<memory>
    auto_ptr<int>pi(new int(1024));
    //pi是局部智能指针, 当pi生命期结束时候, 会自动释放pi指向的堆空间
    为了判断auto_ptr对象是否指向了一个对象, 可以用操作get()返回auto_ptr对象内部的底层指针
    if(p_auto_int.get() != 0 && *p_auto_int != 1024) { ... }
21.在某些情况下, 小细节会积聚成可怕的性能瓶颈, 这些细节不应该烦扰那些试图为整个程序提供解决方案的人, 但是这些细节是有经验的程序员应该考虑
的
22.定位new表达式
    new表达式可以允许程序员要求将对象创建在已经被分配好的内存中, 这种形式的new表达式被称为定位new表达式(placement new expression)
    new (place_address) type -specifier
    place_address必须是个指针
    头文件<new>
    byte *mem = new byte[4096]; //这个是自定义内存池?
    char *tmp = new(mem) char; //在内存池分配一个char来用?
    delete [] mem;

容量)
4.capacity()操作 --求一个容器的容量
5.容器的长度 --容器当前拥有元素的个数
6.size()操作 --求一个容器的长度
7.数据类型越复杂, vector的效率就越低
8.reserve()操作 --允许程序员将容器的容量设置成一个现实指定的值
9.迭代器(iterator) --提供了一种一般化的方法, 对顺序或关联容器类型中的每个元素进行连续访问
10.每个容器类型都提供了一个begin()和一个end()成员函数
11.begin()返回一个iterator, 指向容器的第一个元素
12.end()返回一个iterator, 指向容器的末元素的下一个位置
13.出了iterator类型, 每个容器还定义了一个const iterator类型, 对于遍历const容器是必需的
14.iterator算术论算只适用于vector或deque, 而不适用与list, 因为ielist的元素在内存中不是连续存储的
15.string.find_first_of()查找与被搜索字符串中任意一个字符相匹配的第一次出现, 并返回它的索引位置
16.string.substr()生成string对象的字串的一个拷贝
17.string.rfind()查找最后的指定字串出现的索引
18.string.find_first_not_of()查找第一个不与要搜索字符串的任意字符相匹配的字符
19.string.find_last_of()查找字符串中的"与搜索字符串任意元素相匹配"的最后一个字符
20.string.find_last_not_of()查找字符串中的"与搜索字符串任意字符全不匹配"的最后一个字符
21.string.erase(pos, num)操作去掉字符串中的指定串, pos表示位置, num表示去掉的长度
22.<locale>ctype类, 封转了标准c库函数的功能及一组非成员函数
23.string.compare(pos, num, str); 比较pos位置的后面num个字符是否为str
24.string.insert(pos, newstring); pos表示要插入的位置, newstring表示要插入的字符串
25.string.assign(); 字符串拷贝
26.string.append(); 字符串拼接
27.string.swap(); 交换两个字符串
28.string.at(); 对字符的下标索引操作, 有对索引值范围检测, 下标越界时抛出out_of_range异常
   try {
      char ch = st.at(index);
   } catch(std::out_of_range) { ... }
29.string.replace(pos, num, newstring); 用newstring代替pos后面num个字符子串
30.map 也叫关联数组(associative array) 键/值对 key/value
    键用来索引map, 值用作存储和检索的数据
    map对象定义, 至少要指明键和值的类型, 如:
    map<string, int> word_count;
31.map的数据录入
    map<string, string> str_str;
    str_str[string("one")] = string("1"); //这种效率比较低
    str_str.insert(
        map<string, string>::value_type("two", "2")
    );  //这种效率高
32.查找并获取map中的元素
    最简单的方法:
    value = mapObj[key];
    但这样有个问题, 如果不存在key这个键, mapObj就会插入key键, 并把对应的value值为默认值, 这样得到的value是无效的
    所以, 应该这样写
    if(mapObj.count(key))
        value = mapObj[key];
    或者这样:
    map<keyType, valueType>::iterator iter = mapObj.find(key);
    if(iter != mapObj.end())
      value = mapObj[key];
33.从map中删除元素
    erase操作
    mapObj.erase(key);
    还有两种重载方式, 详见文档

    mapObj.clear(); 清空map对象所有值

34.set对象插入元素
    #include <set>
    set<setType> setObj;
    setObj.insert(key);
35.set对象查找元素
    setObj.count(key); //1有, 0没有
    setObj.find(key); iter为setObj.end()表示没有
36.multiset和multimap允许要被存储的键出现多次
    对于multiset和multimap的迭代策略是联合使用find返回的iterator和count返回的值:
    count = mulsetObj.count();
    multiset<type>::iterator iter;
    iter = mulsetObj.find(key);
    for(int i = 0; i < count; ++i, ++iter)
        do_something(*iter);
    另一种方法是使用equal_range()返回的iterator值
    如果这个值存在, 则第一个iterator指向该值的第一个实例, 且第二个iterator指向这个值的最后一个实例的下一个位置:
    switch(mulmapObj.count) {
    case 0: break; //不存在
    case 1: //只有一项, 用普通的find操作
        multimap<keyType, valueType>::iterator iter;
        iter = mulmapObj.find(key);
        do_something(*iter);
        break;
    default: //有许多项
        typedef multimap<keyType, valueType>::iterator it;
        pair<it, it>pos;
        pos = mulmapObj.equal_range(key);
        for(; pos.first != pos.second; pos.first++)
            do_somethine(*pos.first);
    }
    //对应的, 删除的话用mulmapObj.erase(pos.first, pos.second);
    //不支持下标操作是访问multimap元素的一个限制:
    mulmapObj[key]; //错误
37.栈容器(stack container)支持的操作 //头文件<stack>
   empty()
   size()
   pop()
   top()
   push(item)
38.栈类型被称为容器适配器(container adapter)
39.缺省情况下, 栈用容器类型deque实现, 改变这个缺省值可以这样:
    stack<type, list<type>> stackObj; //改成用容器类型list实现
    //一般是定义一个指针栈
    class CTest;
    stack<CTest*> ctestStack;
40.标准库提供了两种风格的队列: queue(队列), priority_queue(优先级队列)
    头文件 <queue>
41.queue和priority_queue操作
   empty()
   size()
   pos()
   front() //只能用在一般队列
   back() //只能用在一般队列
   top()  //只能用在优先级队列
   push(item)