C++ 归纳复习常规篇

复习之前必须说一个关键点   C++这门语言是强类型语言，非常的强调类型。

1. 关键字const

   1.0 ) const 非指针

int main()
{
    const int a = 1;
    int *p = (int *)&a;
    *p = 10;

    return 0;
}

  结果 a = 1    *p = 10

  原因：a是常量，处在常量符号表中。在编译阶段，编译器检查到使用a这个常量时，会从常量符号表中取出这个值，而不是从该地址内存中取值。

  当使用 &获取地址后，才会为这个地址申请内存。因此*p只是操作这个地址的值，不影响a的常量符号表中的值

　　

  1.1 ) const 指针

int main()
{
    int a = 1;
    int b = 2;

    const int *p1 = (int *)&a;
    int *const p2 = (int *)&b;    

    *p1 = 10;   //错误 
     p1 = &b;    //正确

    *p2 = 20;   //正确
     p2 = &a;   //错误

    return 0;
}

 当const在 * 左侧，即代码中的指针p1，表示修饰的是p1指向的地址的内存，因此，修改p1指向地址是可以的，但修改p1指向地址的内存编译器会报错。

 当const在 * 右侧，即代码中的指针p2，表示修饰的是p2指向的地址，因此，修改p2指向地址的内存是可以的，但是修改p2指向地址编译器会报错。

2.  关键字const 与define的区别

　　发生的时期不同。

       define发生在预处理阶段，进行简单的文本替换，但不会进行类型检查作用域检查。

       const在预处理之后的编译阶段，会对类型进行检查。

　　因此用define的时候要格外小心，特别是宏定义一些函数的时候，要考虑符号的优先级问题。

3. inline 内联函数

    一般调用一个普通较短的函数，就是跳转到这个函数名（地址），在一些实时性要求高的程序里面，跳转就要有系统开销（保存现场、恢复现场），会降低实时性。因此可以使用inlne关键字来修饰函数，类似于define，就是原地展开函数。

内联是一种请求，如果函数过于复杂，编译器会拒绝内联，函数变回普通函数。

4. 函数重载

   这是C++一个重要的特性。

  

void r1chie(void)
{

}

void r1chie(int a)
{

}

void r1chie(int a,int b)
{

}

void r1chie(char a)
{

}

void r1chie(char a,int b)
{

}

int main()
{
  int a; 
  char c;
  r1chie();
  r1chie(a);
  r1chie(a,c);
  r1chie(c);
  r1chie(c,a);

  return 0;
}

我们反汇编上面这段函数

00000000004006ef <main>:
  4006ef:    55                       push   %rbp
  4006f0:    48 89 e5                 mov    %rsp,%rbp
  4006f3:    48 83 ec 10              sub    $0x10,%rsp
  4006f7:    e8 ba ff ff ff           callq  4006b6 <_Z6r1chiev> //4006b6
  4006fc:    8b 45 fc                 mov    -0x4(%rbp),%eax
  4006ff:    89 c7                    mov    %eax,%edi
  400701:    e8 b7 ff ff ff           callq  4006bd <_Z6r1chiei> //4006bd
  400706:    0f be 55 fb              movsbl -0x5(%rbp),%edx
  40070a:    8b 45 fc                 mov    -0x4(%rbp),%eax
  40070d:    89 d6                    mov    %edx,%esi
  40070f:    89 c7                    mov    %eax,%edi
  400711:    e8 b1 ff ff ff           callq  4006c7 <_Z6r1chieii> //4006c7
  400716:    0f be 45 fb              movsbl -0x5(%rbp),%eax
  40071a:    89 c7                    mov    %eax,%edi
  40071c:    e8 b3 ff ff ff           callq  4006d4 <_Z6r1chiec>  //4006d4
  400721:    0f be 45 fb              movsbl -0x5(%rbp),%eax
  400725:    8b 55 fc                 mov    -0x4(%rbp),%edx
  400728:    89 d6                    mov    %edx,%esi
  40072a:    89 c7                    mov    %eax,%edi
  40072c:    e8 af ff ff ff           callq  4006e0 <_Z6r1chieci> // 4006e0
  400731:    b8 00 00 00 00           mov    $0x0,%eax
  400736:    c9                       leaveq 
  400737:    c3                       retq   

可以看到，虽然函数名是一样的，但是地址却是不一样的。

那么重载是根据什么呢？

   4.1 ）参数的数量

   4.2 ）参数的类型

   4.3） 参数的顺序

   4.4） 同一作用域

5. 关键字new和delete

   malloc函数与关键字new。

    5.1）malloc是库函数，需要包含头文件。new需要编译器支持。

    5.2）malloc需要指定大小。new是编译器计算。

    5.3）malloc返回的是void *类型指针，还需要进行强转。new返回的是对象类型指针，因此不需要强转。

使用new申请内存，如果内存不需要了就记得释放

class r1chie
{

public:
      int a;
      int b;
private:
      int c;

};


int main()
{
    int *p1 = new int();
    int *p2 = new int(10);
    int *p3 = new int[10];
    char *p4 = new char();
    r1chie *p5 = new r1chie;
        int  **p6 = new int*[10];

    delete p1;
    delete p2;
        delete[] p3;
    delete p4;
    delete p5;
    delete[] p6[10];


    return 0;
}

  6.  namespace 命名空间

  

#include <iostream>

namespace r1chie
{
    int i = 1; 
}

namespace r1chie_2
{

    int i = 10;
}

using namespace std;

int main()
{
    
    int i = 100;
    
    cout << r1chie::i << endl;
        cout << r1chie_2::i << endl;
    cout << i << endl;

    return 0;
}

输出结果：

1

10

100

7. C++的引用 &

　 7.0）引用的本质就是指针。

     7.1）一个变量可以取多个别名

　　

int main()
{
    int a = 1;
    int& b = a;    
    int& c = a;
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;

    a = 2;
    cout << a << endl;
    cout << b << endl;
    cout << c << endl;

    return 0;
}

输出结果：

1
1
1
2
2
2

     7.2）引用必须初始化

int main()
{
    int& b;    // 编译器报错
 
    return 0;
}

　 7.3）引用只能初始化一次，不能改变为其它变量的引用

 　7.4）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名

　 7.5）引用的类型要相同

int main()
{
        int a = 1;
        float& b = a; //报错

        return 0;
}

　7.6）常引用

　　7.6.1） 使用常引用，则不能使用引用对目标变量的值进行改变，从而使引用的目标成为了const。

int main()
{
        int a = 1;
        const int& b = a;

        a = 2;  //正确
        b = 3;  //报错

        return 0;
}

     7.6.2）临时对象，临时对象都是const类型的

string fun1();
void fun2(string &s);

fun2(fun1());  //报错
fun2("Hello world"); //报错

　　原因是将const类型转换成非const，C++是强类型的语言因此报错。

　　7.7）C++中引用的内部实现

int& a            --->      int* const a

void f(int& a)    ----> void f(int* const a)
{                       {
   a = 5;                   *a = 5;
}                       }    

关于引用这篇文章分析得很好  https://www.cnblogs.com/Mr-xu/archive/2012/08/07/2626973.html

8. C++的强制类型转换

　　这个又是一个比较重要的特性。

　四种转换：

     8.1）static_cast 

变量和对象之间的转换 和 有继承关系的类对象指针转换，可通过父类对象去初始化子类对象（只会初始化父类部分）。　　　　

class Base
{

public:
    int a;    
    
    Base(int i)
    {
         a = i;
        cout << "This is Base"<< endl;
    }
};

class Child :public Base
{

public:
    int b;
    Child(int i) : Base(i)
    {
        b = i;
        cout << "This is Child" << endl;
    }
};


int main()
{
    int a = 1;
    char b = 'a';

    a = static_cast<int>(b);

    Base *b1 = new Base(10);
    Child *c1 = static_cast<Child*>(b1);
    
    c1->b = 100;
    cout << "c1->a = " << c1->a << endl;
    cout << "c1->b = " << c1->b << endl;
    c1->a = 20;
    cout << "b1->a = " << b1->a << endl;
    return 0;
}

输出结果

This is Base
c1->a = 10
c1->b = 100
b1->a = 20

　 8.2）const_cast

　　　　去除类对象的属性，但必须要强制转换成引用或指针

int main()
{
    const int a = 2;

//    int b  = const_cast<int>(a);  报错
    int& c = const_cast<int&>(a);
    int *p = const_cast<int*>(&a);

    cout << a << endl;
    cout << c <<endl;
    cout << *p << endl;

    c  = 6;
    cout << endl;
    cout << a << endl;
    cout << c <<endl;
    cout << *p << endl;

    return 0;
}

输出：

2
2
2

2  //从常量符号表取出，因此a的值依然是2
6
6

　 8.3）dynamic_cast 

　　用于有继承关系的类指针（引用）间的转换

　　用于有交叉关系的类指针（引用）间的转换

　　具有类型检查的功能，编译时会去检查使用的方法是否正确，转换是否成功只有程序运行过程才知道

　　父类转子类时，父类中必须有虚函数支持（换句话说必须是多态）

　　

class Base
{
public:
    Base()
    {
        cout <<  "This is Base"<<endl;
    }
/*    
    virtual ~Base()
    {
        cout << "This is ~Base" << endl;
    }
*/

};

class Child : public Base
{

};


int main()
{
    Base *p = new Base;
    Child *pc = dynamic_cast<Child*>(p); //报错，原因父类没有虚函数
    cout << p << endl;

    delete p;
    


    return 0;
}

 　8.4）reinterpret_cast

　　用于指针之间的转换

int main()
{
  int a = 1;
  char * b = reinterpret_cast<char*>(&a);
  char c = reinterpret_cast<int>(a); //报错    

  return 0;  
}