C++学习笔记

C++是一种混合型语言。一方面我们可以把C++当作是C语言的拓展和改进，在这个意义上，C++是一种过程语言。另一方面，C++又充分展示了其面向对象的特征，因此C++又是一种面向对象的语言。
C语言是面向过程的语言（命令型语言），采用自顶向下设计，将大问题分解为若干小问题（函数分解法），其缺点是对某个过程的变动会传递到子过程中（串联改变），不利于软件维护（系统的测试、调试、升级）。
C++是面向对象程序设计语言，构成模块的基本单元是类，而不是过程，一个类就是一种数据类型。

string类的成员函数
1. erase(int a, int b)——删除子串（删除从位置a开始的b个字符）
2. insert(int a, string s)——插入子串（将s插入位置a）
3. replace(int a, int b, string s)——代替子串（用s代替从a位置开始的b个字符）
4. swap(string s)——调换两字符串内容
5. substr(int a, int b)——提取子串（提取从a位置开始的b个字符为一个子串）
6. find(string/char s, int a)——查找（返回大于或等于a的索引，a默认为0，返回无穷大表示查找失败）
7. rfind(string/char s, int a)
8. find_first_of(string s)
9. find_first_not_of(string s)

无名名字空间
在C语言中，为了使得一个顶层函数（不是类的成员函数）不能定义在该函数的文件之外访问，可以将其声明为static。在C++中还有一个更好的方法——放到无名名字空间中。

//file F1.cpp
namespace {
    void g() { cout << "g\n";}
}//包含了函数g的定义，只有与g在同一文件内的函数才能调用g。

举例说明定义和使用一个指向类成员的指针的语法

struct C{
    int x;
    float y;
    float z;
};
int main()
{
    float C::*f_ptr;//f_ptr并不是指向float类型的指针，
                    //而是指向类C的float成员的指针。
    C c1, c2;
    C *c_ptr;
    f_ptr = &C::y;
    c1.*f_ptr = 3.14;
    c2.*f_ptr = 3.14;
    c_ptr = &c1;
    c_ptr->*f_ptr = 3;

    return 0;
}

inline内联函数
1. 关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。
2. 在类的声明中定义的成员函数都是inline类型的。
3. 成员函数声明时使用inline关键字可将原本定义在类声明之外的成员函数强制变成内联函数。
4. 比较小、调用次数较多的函数适合使用内联函数。

time函数与ctime
函数原型time_t time(time_t* ptr);
time函数返回一个代表当前时间的值。传给time函数的实参可以是某个time_t类型变量的地址，也可以是0（NULL）。如果传给time函数一个time_t类型变量的地址，time函数将当前时间保存到这个变量中。
函数ctime的原型为char* ctime（const time_t* ptr）；
通常我们先调用time来设置time_t类型的变量，然后将该变量地址传给ctime。ctime返回一个C风格字符串。

#include <iostream>
#include <ctime>
using namespace std;

int main()
{
    time_t now = time(0);
    char *b = ctime( &now );                //char a[] = ctime( &now );错误
    cout << now << endl
        << ctime( &now )
        << sizeof(ctime( &now )) << endl    //ctime( &now )返回的是地址，即指针大小为4
        << strlen(ctime( &now )) << endl;   //输出25 ctime返回的C风格字符串会加上一个‘\n’
    cout << *b << endl;                     //首地址的内容，一个字母
    cout << sizeof(*b);                     //输出1

    return 0;
}

构造函数与析构函数
构造函数是一种与类名相同没有返回值的成员函数，一个类可以有多个构造函数，一个类声明了任何构造函数，编译器将不再生成公有的默认构造函数。
1. 通过构造函数约束对象的创建或禁止通过传值方式传递和返回类对象
将某种构造函数声明为私有成员函数即可。
2. 拷贝构造函数
拷贝构造函数可以有多个参数，但第一个以后的所有参数都必须有默认值。如果不提供拷贝构造函数，编译器会自动生成一个。
如果一个类包含指向动态存储空间指针类型的数据成员，则就应为这个类设计拷贝构造函数。
3. 转型构造函数与隐式类型转换
类C转型构造函数用于类型间的转换，它只有一个参数

class Person {
public:
    Person() { name = "Unknown"; }
    Person( const string& n ) { name = n; }     //转型构造函数
    Person( const char* n ) { name = n; }       //转型构造函数
private:
    string name;

};
void f(Person p) {}
int main()
{
    Person soprano("Dawn Upshaw");      //转型构造

    string s = "Turandot";
    f(s);   //只要Person类有一个转型构造函数

    return 0;
}

然而有时隐式类型转换会导致一些无法预料的错误，我们可以用explicit关键字关闭这种隐式转换。

1. 初始化列表

class C {
public:             //初始化列表仅在构造函数中有效，不用于其他函数
    C() : c(0), x(-1) {}     //初始化const类型数据成员的唯一方法
private:
    int x;
    const int c;      //初始化顺序完全取决于声明的顺序
};

1. 析构函数
   析构函数不带参数，因此不能被重载。与构造函数一样，没有返回值。
   析构函数可以是内联函数，析构函数可以为虚函数，且用于多态性是必须为虚函数，构造函数不能。

常量指针this
this指针是一个常量，它不能作为赋值、递增、递减等运算的目标对象。而且this只在非static成员函数中用才有效。

改变继承成员访问权限
基类中的公有成员一般被继承为公有成员，但使用using声明可将其改为私有成员。

操作符重载
当我们定义重载的运算符时，必须首先决定是将其声名为类的成员函数还是声明为一个普通的非成员函数。

• 赋值（=）、下标（[]）、调用（()）和成员访问箭头（->）运算符必须是成员。
• 复合赋值运算符一般来说应该是成员，但并非必须，与赋值运算符略有不同。
• 改变对象状态的运算符或者与给定类型密切相关的运算符，如递增、递减和解引用运算符，通常应该是成员。
• 具有对称性的运算符可能转换任意一端的运算对象，如算术、相等性、关系和位运算符等，因此它们通常应该是普通的非成员函数。
• 输入输出运算符必须是非成员函数，IO运算通常需要读写类的非公有数据成员，所以IO运算符一般被声明为友元。

注：除了重载函数调用运算符operator()之外，其他重载运算符不能含有默认实参。
当运算符作用于内置类型的运算对象时，我们无法改变该运算符的含义。int operator+(int, int);//××
（::） 、（.*） 、（.） 、（?:） 运算符不能被重载
通常情况下，不应该重载逗号、取地址、逻辑与和逻辑或运算符。

范型
所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。

重载、重写、重定义（隐藏）
重载overload：是函数名相同，参数列表不同 重载只是在类的内部存在。但是不能靠返回类型来判断。
重写override：也叫做覆盖。子类重新定义父类中有相同名称和参数的虚函数。函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。
重写需要注意：
1 被重写的函数不能是static的。必须是virtual的
2 重写函数必须有相同的类型，名称和参数列表
3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为public,protected也是可以的
重定义 (redefining)也叫做隐藏:
子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。
如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用是不能成功的。
综上所述，总结如下：
1 成员函数重载特征：
a 相同的范围（在同一个类中）
b 函数名字相同
c 参数不同
d virtual关键字可有可无
2 重写（覆盖)是指派生类函数覆盖基类函数，特征是：
a 不同的范围，分别位于基类和派生类中
b 函数的名字相同
c 参数相同
d 基类函数必须有virtual关键字
3 重定义(隐藏)是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
a 如果派生类的函数和基类的函数同名，但是参数不同，此时，不管有无virtual，基类的函数被隐藏。
b 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有vitual关键字，此时，基类的函数被隐藏。

运行期类型识别
dynamic_cast操作符：在C++中，编译器合法的类型转换操作可能会在运行期引发错误，涉及到指针和引用是更易发生错误。使用dynamic_cast可在运行期对可疑转型操作进行测试。而static_cast不能保证运行期类型安全。

• dynamic_cast仅对多态类型（基类至少有一个虚函数）有效。

• 在<>中指定的dynamic_cast目的类型必须是一个指针或引用。

  例：B为虚基类，D* p = dynamic_cast< D* >( new A );//正确
  注：若派生类中有基类没有的函数则转换失败，因为当派生类指针调用该函数时，有基类转换的类中并没有该函数。这也是使用static_cast会产生运行期错误的原因。因此只能由派生类到基类的转换。

C++中四种强制类型转换
使用标准C++的类型转换符：static_cast、dynamic_cast、reinterpret_cast和const_cast。
1、static_cast
用法：static_cast (expression)
如果涉及到类的话，static_cast只能在有相互联系的类型中进行相互转换,不一定包含虚函数。
该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：
（1）用于类层次结构中基类和派生类之间指针或引用的转换
进行上行转换（把派生类的指针或引用转换成基类表示）是安全的
进行下行转换（把基类的指针或引用转换为派生类表示），由于没有动态类型检查，所以是不安全的
（2）用于基本数据类型之间的转换，如把int转换成char。这种转换的安全也要开发人员来保证
（3）把空指针转换成目标类型的空指针
（4）把任何类型的表达式转换为void类型
注意：static_cast不能转换掉expression的const、volitale或者__unaligned属性。

2、dynamic_cast
用法：dynamic_cast (expression)
该运算符把expression转换成type_id类型的对象。type_id必须是类的指针、引用或者void*；
如果type_id是类指针类型，那么expression也必须是一个指针，如果type_id是一个引用，那么expression也必须是一个引用。
dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。
在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；
在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

class B
{
public:

      int m_iNum;
       virtual void foo();
};

class D:public B
{
    public:
       char *m_szName[100];
};

void func(B *pb)
{
    D *pd1 = static_cast<D *>(pb);
    D *pd2 = dynamic_cast<D *>(pb);
}

在上面的代码段中，如果pb指向一个D类型的对象，pd1和pd2是一样的，并且对这两个指针执行D类型的任何操作都是安全的；
但是，如果pb指向的是一个B类型的对象，那么pd1将是一个指向该对象的指针，对它进行D类型的操作将是不安全的（如访问m_szName），
而pd2将是一个空指针。
另外要注意：B要有虚函数，否则会编译出错；static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表（
关于虚函数表的概念，详细可见）中，只有定义了虚函数的类才有虚函数表，
没有定义虚函数的类是没有虚函数表的。

另外，dynamic_cast还支持交叉转换，如下所示。

class A
{
public:
    int m_iNum;
    virtual void f(){}
};

class B:public A
{

};

class D:public A
{

};

void foo()
{    
    B *pb = new B;    
    pb->m_iNum = 100;    
    D *pd1 = static_cast<D *>(pb); //compile error    
    D *pd2 = dynamic_cast<D *>(pb); //pd2 is NULL    
    delete pb;    
}

在函数foo中，使用static_cast进行转换是不被允许的，将在编译时出错，而使用dynamic_cast转换则是允许的，结果是空指针。

3、reinterpret_cast
用法：reinterpret_cast (expression)
type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，
在把该整数转换成原类型的指针，还可以得到原先的指针值）。
该运算符的用法比较多。
(static_cast .与. reinterpret_cast比较，见下面 )
该运算符平台移植性比价差。

4、const_cast
用法：const_cast (expression)
该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
常量指针被转化成非常量指针，并且仍然指向原来的对象；
常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。
volatile和const类型，举例如下所示。

class B
{
public:    
    int m_iNum;    
}

void foo()
{
    const B b1;    
    b1.m_iNum = 100; //comile error    
    B b2 = const_cast<B>(b1);    
    b2. m_iNum = 200; //fine    
}

上面的代码编译时会报错，因为b1是一个常量对象，不能对它进行改变；
使用const_cast把它转换成一个非常量对象，就可以对它的数据成员任意改变。注意：b1和b2是两个不同的对象。

构造函数初始化时必须采用初始化列表一共有三种情况，
1.需要初始化的数据成员是对象(继承时调用基类构造函数)
2.需要初始化const修饰的类成员
3.需要初始化引用成员数据
4.没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数；

常量必须在构造函数的初始化列表里面初始化或者将其设置成static

class A
{
    const int size = 9;//错误
    //应该为：
    static const int size = 9;
    //或者
    A()
    { const int size = 9; }
};