C++进阶 - 内存管理

最新推荐文章于 2021-03-16 14:33:13 发布

路人暴脾气

最新推荐文章于 2021-03-16 14:33:13 发布

阅读量1.1k

点赞数 5

分类专栏： C/C++进阶 C++学习之路文章标签： c++内存管理 C-C++-野指针野指针内存泄漏指针与数组

本文链接：https://blog.csdn.net/qq_33775402/article/details/75252291

版权

C++学习之路同时被 2 个专栏收录

9 篇文章 2 订阅

订阅专栏

C/C++进阶

4 篇文章 0 订阅

订阅专栏

内存分配方式

静态存储区分配
内存在编译的时候就已经分配好了，这块内存在程序的整个运行期间都存在。
栈内存
函数的局部变量在执行时的存储单元，函数退出时，由于栈平衡这些内存全部释放。
堆内存
用new/delete分配的内存，内存的生存期由我们自己决定
自由存储区
使用malloc进行分配，使用free进行回收。和堆类似。
常量存储区
这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。

指针与数组的区别

以字符串为例比较指针与数组的区别

对内容的修改
先看下面的代码

#include <iostream>
using namespace std;
int main()
{
    char str[] = "hello";
    str[2] = 'x';
    cout << str << endl;

    char *p = "hello";
    p[2] = 'x';
    cout << p << endl;
    getchar();
    return 0;
}

看上去并没什么毛病（编译器也是这么认为的），然后运行一把，程序打印出hexlo，然后就挂掉了。。。
数组名对应着一块内存，其地址，容量是固定的，只有数组的内容可以改变；指针可以指向任意类型的内存块。p[2]=‘X’; 看起来是没有错，不过他在试图修改程序常量字符串的值！！！这个是不被允许的！

内容的复制与比较

#include <iostream>
using namespace std;
int main()
{
    char str[] = "hello";
    char strs[6]{0};
    //strs = str;  
    strcpy_s(strs, str);
    cout << strs << endl;

    char * p = "www.breeziness.cn";
    char *ps = NULL;
    ps = p;   //仅仅是把p指向的地址赋给了ps
    cout << ps << endl;

    //把字符串的值赋给p_s
    char * p_s = new char[strlen(p)+1];
    strcpy_s(p_s,strlen(p)+1, p);
    cout << p_s << endl;
    delete p_s;
    p_s = NULL;

    //比较大小的时候也不可以直接用==  
    if (strcmp(str,strs)==0)
    {
        cout << "相等" << endl;
    }
    getchar();
    return 0;
}

内存容量的计算
sizeof 可以计算数组的容量，但是要注意数组作为参数进行传递时，函数参数中保存的是数组的首地址，是一个指针变量。所以数组作为参数时sizeof计算的仅仅是平台的指针长度。

#include <iostream>
using namespace std;
int func(char a[])
{
    size_t len = sizeof a;
    cout << len << endl;
    return 0;
}
int main()
{
    char a[10]{0};
    size_t len = sizeof a;
    cout << len << endl;
    func(a);
    getchar();
    return 0;
}

数组作为参数传递时传递的仅仅是首地址，从反汇编代码中也不难看出。仅将首地址压栈。

sizeof 指针的话，自然就是平台的指针长度。而不是指针指向的内存容量。C/C++是没法知道指向内存的大小的。获取字符串的长度，使用strlen( );

指针参数传递内存

指针作为参数时，通常是需要修改指针所指向的变量的值。
那么如果用该指针申请动态内存呢？
看如下代码

#include <iostream>
using namespace std;
int func(int *p)
{
    p = new int[10];
    return 0;
}

int funcs(int **p)
{
    *p = new int [10];
    return 0;
}

int main()
{
    int *p = NULL;

    func(p);
    if (p==NULL)
    {
        cout << "申请失败" << endl;
    }


    funcs(&p);
    if (p==NULL)
    {
        cout << "申请失败" << endl;
    }
    else
    {
        cout << "申请成功" << endl;
    }

    getchar();
    return 0;
}

不要指望用传递进来的指针去申请动态内存！！！
可以在逻辑上仔细推敲一下
修改普通变量的值传指针
修该指针变量的值就应该传二级指针！为指针动态申请内存就是在修改指针的值，so传二级指针

二级指针如果过于深奥，那么如果要在函数中申请动态内存，可以使用返回值。

int * funs_i()
{
    int * p = new int[10];
    return p;
}

int main()
{
    int *p = funs_i();
    if (p!=NULL)
    {
        cout << "成功" << endl;
    }
    getchar();
    return 0;
}

注意：这里返回的是堆上的指针，而不是栈上的！
返回栈上的指针将会是一个不发预料的灾难！因为该内存在函数结束时就已经消亡了

char * funs_1()
{
    char* p = "xxxx";
    return p;
}

char * funs_2()
{
    char v = 'c';
    return &v;   //编译器警告
}


int main()
{
    //返回的是常量存储区的只读内存
    char *p = funs_1();
    cout << p << endl;
    //返回了栈内存，程序出现问题
    char *pp = funs_2();
    cout << pp << endl;
    getchar();
    return 0;
}

可能会觉得很奇怪，为什么p返回的是常量区中的地址，p本身不也在栈内存中？这里要注意，C++ 不管是参数，还是返回值，其实都是副本。func_1（）返回的是p指向的地址的副本，也就是那个字符串常量的地址。并不是返回p自己的地址。如果像体验一把返回p的地址，可以看看下面的代码（编译器会警告）

char ** funs_1()
{
    char* p = "xxxx";
    return &p;  //警告
}

动态内存的释放 | 野指针 | 内存泄漏

野指针不是NULL指针，而是指向‘垃圾’内存的指针。一般不会用错空指针，因为if语句就可以判断，但是野指针是没法判断的，所以很危险。
野指针的成因有两种：

指针变量没有初始化，任何指针变量在刚刚被创建时是不会被自动成为NULL指针，他的缺省值是随机的。
指针被 free / delete之后没有被设置为空。如果程序太大，自己都可能搞不清楚是不是合法的指针。注意：free/delete仅仅是释放内存，并不会过问指针有没有置为NULL的事。
指针操作超越了变量的作用范围,如下代码

#include <iostream>
using namespace std;

int func(int **p)
{
    int a = 0;
    *p = &a;
    return 0;
}
int main()
{
    int **p = NULL;
    func(p);
    cout << p << endl;
    getchar();
    return 0;
}

程序直接GG

接下来说说动态内存的释放问题
先看看如下代码：

#include <iostream>
using namespace std;

void func()
{
    int *p = new int[100];

}
int main()
{

    func();

    getchar();
    return 0;
}

函数中申请的这块内存释放了没？
答案是没有。有人可能会想到，在函数退出时p指针变量已经消亡了，为什内存没有释放？其实道理很简单。变量就是个容器。容器是没有，并不代表申请的东西也没了！所以要注意指针的以下特征：

指针消亡了，不代表它指向的内存会被自动释放（内存泄漏）
内存被释放了，不代表指针会消亡或者成为NULL指针（野指针）

so 为了愉快的写代码，一定要记得两件事：

看好你的内存，别把他弄丢了。
内存被释放后指针及时置为NULL;