《C++Primer》第十九章

// new表达式
string *sp = new string("a value");  // 分配并初始化一个string对象
string *arr = new string[10];        // 分配10个默认初始化的string对象

delete sp;       // 销毁*sp, 然后释放sp指向的内存空间
delete [] arr;   // 销毁数组中的元素, 然后释放对应的内存空间

// 这些版本可能抛出异常
void *operator new(size_t);        // 分配一个对象
void *operator new[](size_t);      // 分配一个数组
void *operator delete(void*) noexcept;   // 释放一个对象
void *operator delete[](void*) noexcept; // 释放一个数组

// 这些版本承诺不会抛出异常
void *operator new(size_t, nothrow_t&) noexcept;
void *operator new[](size_t, nothrow_t&) noexcept;
void *operator delete(void*, nothrow_t&) noexcept;
void *operator delete[](void*, nothrow_t&) noexcept;

void *operator new(size_t size) {
    if (void *mem = malloc(size))
        return mem;
    else
        throw bad_alloc();
}
void operator delete(void *mem) noexcept { free(mem); }

new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type [size] { braced initializer list }

string *sp = new string("a value");   // 分配并初始化一个string对象
sp->~string();

dynamic_cast<type*>(e)   // e必须是一个有效的指针
dynamic_cast<type&>(e)   // e必须是一个左值
dynamic_cast<type&&>(e)  // e不能是左值

if (Derived *dp = dynamic_cast<Derived*>(bp))
{
    // 使用dp指向的Derived对象
} else {  // bp指向一个Base对象
    // 使用bp指向的Base对象
}

void f(const Base &b)
{
    try {
        const Derived &d = dynamic_cast<const Derived&>(b);
        // 使用b引用的Derived对象
    } catch (bad_cast) {
        // 处理类型转换失败的情况
    }
}

Derived *dp = new Derived;
Base *bp = dp;   // 两个指针都指向Derived对象

// 在运行时比较两个对象的类型
if (typeid(*bp) == type(*dp)) {
    // bp和dp指向通医药类型对象 
}
// 检查类型是否是某种指定类型
if (typeid(*bp) == typeid(Derived)) {
    // bp实际指向Derived类型
}

// 下面检查永远失败: bp类型是指向Base的指针
if (typeid(bp) == typeid(Derived)) {
    // 此处代码永远不会执行
}

class Base {
    friend bool operator==(const Base&, const Base&);
public:
    // Base的接口成员
protected:
    virtual bool equal(const Base&) const;
    // Base的数据成员和其他用于实现的成员
};

class Derived: public Base {
public: 
    // Derived的其他接口成员
protected:
    bool equal(const Base&) const;
    // Derived的数据成员和其他用于实现的成员
};

bool operator==(const Base &lhs, const Base &rhs)
{
    // 如果typeid不相同,则返回fallse; 否则虚调用equal
    // 当运算对象是Base的对象时调用Base::equal, 否则调用Derived::equal
    return typeid(lhs) == typeid(rhs) && lhs.equal(rhs);
}

bool Derived::equal(const Base &rhs) const
{
    // 我们清楚两个类型是相等的, 所以转换不会抛出异常
    auto r = dynamic_cast<const Derived&>(rhs);
    // 执行比较两个Derived对象的操作并返回结果
}

bool Base::equal(const Base &rhs) const
{
    // 执行比较Base对象的操作    
}

enum class open_modes {input, output, append};
// 等价
enum struct open_modes {input, output, append};

enum color {red, yellow, green};
enum {floatPrec = 6, doublePrec = 10, double_doublePrec = 10};

enum color {red, yellow, green};          // 不限定作用域的枚举类型
enum stoplight {red, yellow, green};      // 错误: 重复定义了枚举成员
enum class peppers {red, yellow, green};  // 正确: 枚举成员被隐藏了

int i = color::red;     // 正确: 不限定作用域的枚举类型的枚举成员隐式地转换成int
int j = peppers::red;   // 错误: 限定作用域的枚举类型不会进行隐式转换

enum intValues : unsigned long long {
    charTyp = 255, shortTyp = 65535, intTyp = 65535,
    longTyp = 4394967295UL,
    long_longTyp = 18446744073709551615ULLL
};

// 不限定作用域的枚举类型，潜在类型因机器而异
enum Tokens {INLINE = 128, VIRTUAL = 129};
void ff(Tokens);
void ff(int);
int main() {
    Tokens curTok = INLINE;
    ff(128);        // 精确匹配ff(int)
    ff(INLINE);     // 精确匹配ff(Tokens)
    ff(curTok);     // 精确匹配ff(Tokens)
    return 0;
}

class Screen {
public:
    typedef std::string::size_type pos;
    char get_cursor() const { return contents[cursor]; }
    char get() const;
    char get(pos ht, pos wd) const;
private:
    std::string contents;
    pos cursor;
    pos height, width;
};

// pdata可以指向一个常量(非常量)Screen对象的string成员
// 将pdata声明为"一个指向Screen类的const string成员的指针"
const string Screen::*pdata;

pdata = &Screen::contents;

auto pdata = &Screen::contents;

Screen myScreen, *pScreen = &myScreen;
// .*解引用pdata以获得myScreen对象的contents成员
auto s = myScreen.*pdata;
// ->*解引用pdata以获得pScreen所指对象的contents成员
s = pScreen->*pdata;

class Screen {
public:
    // data是一个静态成员, 返回一个成员指针
    static const std::string Screen::*data()
        { return &Screen::contents; }
}

// 我们调用data函数时, 将得到一个成员指针
// data()返回一个指向Screen类的contents成员的指针
const string Screen::*pdata = Screen::data();

// pdata指向Screen类的成员而非实际数据, 要想使用pdata必须把它绑定到Screen类型的对象上
auto s = myScreen.*pdata;

// pmf是一个指针, 它可以指向Screenn的某个常量成员函数
// 前提是该函数不接受任何实参, 并且返回一个char
auto pmf = &Screen::get_cursor;

// 例如我们可以声明一个指针, 令其指向含有两个形参的get:
char (Screen::*pmf2)(Screen::pos, Screen::pos) const;
pmf2 = &Screen::get;  // 必须加取地址符&, 在成员函数和指针之间不存在自动转换规则

Screen myScreen, *pScreen = &myScreen;
// 通过myScreen所指的对象调用pmf所指的函数
char c1 = (pScreen->*pmf)();
// 通过myScreen对象将实参0, 0 传给含有两个形参的get函数
char c2 = (myScreen.*pmf2)(0, 0);

// Action是一种可以指向Screen成员函数的指针, 它接收两个pos实参, 返回一个char
using Action = char (Screen::*)(Screen::pos, Screen::pos) const;

Action get = &Screen::get;  // get指向Screen的get成员

// action接受一个Screen的引用和一个指向Screen成员函数的指针
Screen& action(Screen&, Action = &Screen::get);

Screen myScreen;
// 等价调用
action(myScreen);                // 使用默认实参
action(myScreen, get);           // 使用我们之前定义的变量get
action(myScreen, &Screen::get);  // 显式地传入地址 

class Screen {
public:
    // 其他接口和实现成员与之前一致
    // 这几个函数共同点: 不接受任何参数, 并且返回值是发生光标移动的Screen的引用
    Screen& home();        // 光标移动函数
    Screen& froward();
    Screen& back();
    Screen& up();
    Screen& down();
}

class Screen {
public:
    // Action是一个指针, 可以用任意一个光标移动函数对其赋值
    using Action = Screen& (Screen::*)();
    // 指定具体要移动的放共享
    enum Directions { HOME, FORWARD, BACK, UP, DOWN };
    Screen& move(Directions);
private:
    static Action Menu[];   // 函数表
};

Screen& Screen::move(Directions cm)
{
    // 运行this对象中索引值为cm的元素
    return (this->*Menu[cm])();  // Menu[cm]指向一个成员函数
}

Screen::Action Screen::Menu[] = {
    &Screen::home,
    &Screen::forward,
    &Screen::back,
    &Screen::up,
    &Screen::down,
};

Screen myScreen;
myScreen.move(Screen::HOME);   // 调用myScreen.home
myScreen.move(Screen::DOWN);   // 调用myScreen.down

auto fp = &string::empty;   // fp指向string的empty函数
// 错误, 必须使用.*或者->*调用成员指针
find_if(svec.begin(), svec.end(), fp);

// 在find_if内部试图执行如下代码, 但是要想通过成员指针调用函数, 必须使用该->*运算符, 所以失败
if (fp(*it))

vector<string> svec;
function<bool (const string&)> fcn = &string::empty;
find_if(svec.begin(), svec.end(), fcn);

vector<string*> pvec;
function<bool (const string*)> fp = &string::empty;
find_if(pvec.begin(), pvec.end(), fp);

find_if(svec.begin(), svec.end(), mem_fn(&string::empty));

// mem_fn生成的对象可以通过对象调用, 也可以通过指针调用
auto f = mem_fn(&string::empty);  // f接收一个string或者一个string*
f(*svec.begin());    // 正确: 传入一个string对象, f使用.*调用empty
f(&svec[0]);         // 正确: 传入一个string指针, f使用->*调用empty

auto it = find_if(svec.begin(), svec.end(), bing(&string::empty, _1));

// bind生成的可调用对象第一个实参既可以是string的指针, 也可以是string的引用
auto f = bind(&string::empty, _1);
f(*svec.begin());
f(&svec[0]);

class TextQuery {
public:
    class QueryResult;   // 嵌套类稍后定义
}

// QueryResult是TextQuery的成员
class TextQuery::QueryResult {
    // 位于类的作用域内, 因此我们不必对QueryResult形参进行限定
    friend std::ostream& print(std::ostream&, const QueryResult&);
public:
    // 嵌套类可以直接使用外层类的成员, 无须对该名字进行限定
    QueryResult(std::string, std::shared_ptr<std::set<line_no>>,
               std::shared_ptr<std::vector<std::string>>);
};

TextQuery::QueryResult::QueryResult(string s, shared_ptr<set<line_no>> p,
                                   std::shared_ptr<std::vector<std::string>> f) :
    sought(s), lines(p), file(f) { }

// Token类型的对象只有一个成员, 该成员的类型可能是下列类型中的任意一个
union Token {
    // 默认情况下成员是公有的
    char cval;
    int ival;
    double dval;
};

Token first_token = {'a'};      // 初始化cval成员, 如果提供初始值则用于初始化第一个成员
Token last_token;               // 未初始化的Token对象
Token *pt = new Token;          // 指向一个未初始化的Token对象的指针

union {
    char cval;
    int ival;
    double dval;
};  // 未命名对象, 我们可以直接访问它的成员
cval = 'a';    // 为匿名union赋一个新值
ival = 42;     // 该对象当前保存的值是42

int a, val;
void foo(int val)
{
    static int si;
    enum Loc { a = 1024, b };
    // Bar是foo的局部类
    struct Bar {
        Loc locVal;
        int barVal;
        
        void fooBar(Loc l = a)
        {
            barVal = val;    // 错误, val是foo的局部变量
            barVal = ::val;  // 正确: 使用一个全局变量
            barVal = si;     // 正确: 使用一个静态局部对象
            locVal = b;      // 正确: 使用一个美剧成员
        }
    };
    // ...
}

typedef unsigned int Bit;
class File {
    Bit mode: 2;         // mode占两位
    Bit modified: 1;     // modified占1位
    Bit prot_owner: 3;   // 占3位
    Bit prot_group: 3;   // 占3位
    Bit prot_world: 3;   // 占3位
public:
    // 文件以八进制的形式表示
    enum modes { READ = 01, WRITE = 02, EXECUTE = 03 };
    File &opne(modes);
    void close();
    void write();
    bool isRead() const;
    void setWrite();
};

volatile int display_register;    // 该int值可能发生改变

// cstring头文件中C函数的声明
// 单语句链接指示
extern "C" size_t strlen(const char *);
// 复合语句链接指示
extern "C" {
    int strcmp(const char*, const char*);
    char *strcat(char*, const char*);
}

// 复合语句链接指示
extern "C" {
#include <string.h>  // 操作C风格字符串的C函数
}

// pf指向一个C函数, 该函数接受一个int返回void
extern "C" void (*pf)(int);

// f1是一个C函数, 它的形参是一个指向C函数的指针
extern "C" void f1(void(*)(int));

// calc函数可以被C程序调用
extern "C" double calc(double dparm) { /*...*/) }

// 错误: 两个extern "C"函数的名字相同
extern "C" void print(const char*);
extern "C" void print(int)