C++.3 内联函数·auto· nullptr·C++ for语法·面向过程·面向对象·类·访问限定符·面向对象的三大特性

1. 内联函数 ：inline 修饰的函数就叫内联函数。

内联函数解决了宏函数缺点，同时兼具它的优点！

内联函数在符合条件的地方会在调用时展开，inline 是一种以空间换时间的做法，省去调用函数额外的开销，所以代码很长或者有递归的函数不适宜作为内联函数！

内联函数不要定义和申明分离，应该都放在申明(.h)文件中

       inline 修饰的函数就叫内联函数。编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，是一种以空间换时间的做法，内联函数提升了程序运行的效率。如果编译器将函数当成内联函数处理，那么在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。inline对于编译器而言只是一个建议，编译器可以选择忽略这个请求。一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

2. auto ：自动推导类型

        如：int a = 0; auto b = a;auto 会自动推导出 b 为 int 类型

               for(auto e : a) { cout << e << " ";}里面会根据 a 的类型自动推导出 e 的类型。语句意思为：

把 a 中所有的值依次赋值给 e，每赋值一次，打印依次 “e的值 空格 ”

        std::map<std::string, std::string>::iterator 是一个类型，但是该类型太长了，特别容易写错，

可以通过typedef给类型取别名，比如：

#include <string>
#include <map>
 
typedef std::map<std::string, std::string> Map;
int main()
{
    Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
    Map::iterator it = m.begin();
    while (it != m.end())
    {
        //....
    }
    return 0;
}

 使用typedef给类型取别名确实可以简化代码，但是typedef有会遇到新的难题：

typedef char* pstring;
 
int main()
{
    const pstring p1;    // 编译成功还是失败？
    const pstring* p2;   // 编译成功还是失败？
    return 0;
}

       在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，但 auto 可以做到这一点。使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

3. nullptr ：以后尽量用 nullptr 表示空指针；

在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的！

         NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void *)0)
#endif
#endif

 可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

void f(int)
{
    cout<<"f(int)"<<endl;
}
 
void f(int*)
{
    cout<<"f(int*)"<<endl;
}
 
int main()
{
    f(0);
    f(NULL);
    f((int*)NULL);
    return 0;
}

         程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖。因此，为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

C++ for语法:

        在C++98中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        array[i] *= 2;
    
    for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
        cout << *p << endl;
}

         对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
        e *= 2;
    
    for(auto e : array)
        cout << e << " ";
    
    return 0;
}

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

4. C语言是面向过程的，关注的是过程，分析出求解问题的步骤通过函数调用逐步解决问题；

   C++是 基于面向对象(不是纯粹面向对象的意思)的，关注的是对象，将一件事情分成不同的对象，靠对象之间交流！

5. 类：类就是结构体，为C中的结构体的升级版，它不仅可以定义变量，还可以定义函数，这是C++里的概念，C里的结构体只可以定义变量，即 C++ 中的关键字 struct 不仅可以定义变量，还可以定义函数，struct 的{ }里，即使变量在函数后面也是可以访问的，C 中的关键字 struct 只可以定义变量。考虑到C++是兼容C的，所以类里是可以用C里的结构体知识写的，如在C++中，定义一个结构体变量就可以用C中的 "struct 标签名字 定义的结构体变量"来实现，而用 “”标签名字 定义的结构体变量“” 也可以实现，这是C++的定义方式。

类中有两个关键词 ： struct、class

        C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

        struct { }；C中，struct 的{ }里的内容是可以被括号外面访问的，C++中的struct的{ }里的内容也是可以被括号外面访问的，这主要是考虑C++要对C做兼容

     class { }；C++中的class的{ }里的内容是不可以被括号外面访问的，若把 { } 改成{ public：...... primate： .....}，则 public：的冒号后面的......是可以被外界访问的， primate：的冒号后面的......是不可以被外界访问的，有些数据不给外界访问有一部分原因是因为数据复杂，不了解原理很容易使用错误。这里面 public、primate 属于访问限定符；

类的定义方式：2种

1) 申明和定义都放在类中：一般是定义的内容比较短，定义的内容太长影响申明的查看体验。有些把太长的定义和申明放在一起，再对定义进行内联来减少访问时间这些都是不推荐的，申明还是以方便查看为主，即使时间减少了但还是影响了申明的体验；

2) 申明放在 .h 文件中，定义放在 .cpp 文件中，但此时.cpp对.h中的申明进行编写时一定要写清楚哪里的定义，因为类中的函数定义出了类的{ }外界识别不了，如：

.h：struct stt {void func（）{}；int a；int b}，此时.cpp 文件对 func 描述时应写为：void stt ::func{...}

6. 访问限定符：public、protected、private 。访问限定符是针对类的外面而言的，来限定他们能不能访问类的内部，限定不了类内部之间能否访问；

        public ：公有。类外面可访问；

        protected ：保护。类外面不可访问；   

        private ：私有。类外面不可访问；

访问限定符的作用域是从该访问限定符出现的位置开始直到下一个访问限定符出现为止这一片区域！

C++中，class默认访问权限为 private，struct 默认访问权限为public(因为要兼容C)，其他方面没什么区别！

7. 面向对象的三大特性：封装、继承、多态。