内联函数与动态内存分配

内联函数

• 调用普通函数的问题：

          每个普通函数调用语句都需要发生跳转操作，这种跳转操作会带来时间开销。

• 内 联就是用 函数已被编译好的二进制代码 ， 替换 对该函数的调用指令

• 内 联在保证函数特性的同时，避免了函数 调用的时间开销

 总结

1.内联会使可执行文件的体积和进程代码的内存变大，因此只有频繁调用的简单函数才适合内联
2.inline关键字仅表示期望该函数被优化为内联，但是否适合内联则完全由编译器决定
3.稀少被调用的复杂函数和递归函数都不适合内联

 代码演示

//内联函数:编译器的优化策略
#include<iostream>
void foo(int x){    //普通函数
    cout << "foo(int):" << x << endl;
}
inline void bar(int x){ //内联函数
    cout << "bar(int):" << x << endl;
}
using namespace std;
int main(){
    foo(10);  //生成跳转指令，调用函数
    foo(20);  //..........
    foo(30);  //..........

    bar(10);  //将此处替换为bar函数编译后产生的二进制指令集，不生成跳转指令
    bar(20);  //..........
    bar(30);  //.........
    return 0;
}

动态内存分配

• 可以继续使用 标准 C 库函数 malloc /free

• 更建议使用 new / delete 操作符在堆中分配 / 释放内存

–> int * pi = new int ;
->delete pi;

• 在分配内存的同时 初始化

–> i nt * pi = new int (100);

• 以数组方式 new 的也要以 数组方式 delete

–> int * pi = new int [4] {10, 20, 30, 40};
->delete[ ] pi;

        当你申请这4个int类型大小的空间时，系统默认会多分配一个int类型大小，用来计数，存储当前数组元素个数。对于这4个字节的数据，系统拒绝用户对这块数据进行任何操作，用户可以获取这块空间的地址，但不能进行读写。在释放这个数组的空间时，指针会先进行减4字节的操作，从而连同多分配的这4字节数据一 起释放。                                                                                                                      

1.      通过new操作符分配N维数组，返回N-1维数组指针

                int (*prow)[4]= new int [3][4];

                int (*pparr)[4][5]= new int [3][4][5]
2.      不能通过delete操作符释放已释放过的内存
3.      delete野指针后果未定义，delete空指针安全
4.      new操作符申请内存失败，将抛出异常

代码演示 

//动态(堆)内存分配
#include <iostream>
#include<cstdlib>
using namespace std;
int main(){
    int* pm = (int*)malloc(4);
    cout << "*pm:" << *pm << endl;
    free(pm);

    int* pn = new int(100);//堆内存初始化为100
    cout << "*pn:" << *pn << endl;
    delete pn;

    int* parr = new int[4]{1,2,3,4};
    for(int i = 0; i < 4; i++){
        cout << parr[i] << ' ' ;
    }
    cout << endl;
    delete[] parr;
    int(*p)[4] = new int[3][4]; //动态分配二维数组
    delete[] p;
    return 0;
}