日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

C語言深入講解內存操作問題_C 語言

作者：清風自在?流水潺潺 ? 更新時間： 2022-06-17 編程語言

一、野指針

  • 指針變量中的值是非法的內存地址，進而形成野指針
  • 野指針不是 NULL 指針，是指向不可用內存地址的指針
  • NULL 指針并無危害，很好判斷，也很好調試
  • C 語言中無法判斷一個指針所保存的地址是否合法

二、野指針的由來

  • 局部指針變量沒有被初始化
  • 指針所指向的變量在指針之前被銷毀
  • 使用已經釋放過的指針
  • 進行了錯誤的指針運算
  • 進行了錯誤的強制類型轉換

? ? ? ? 下面看一個示例：

#include <stdio.h>
#include <malloc.h>
 
 
int main()
{
    int* p1 = (int*)malloc(40);
    int* p2 = (int*)1234567;    //p2 是一個野指針
    int i = 0;
    
    printf("%p\n", p1);
    for(i=0; i<40; i++)
    {
        *(p1 + i) = 40 - i; //由于指針運算產生了野指針，改寫了非法內存地址
    }
 
    free(p1); 
    
    printf("%p\n", p1);
    
    for(i=0; i<40; i++)
    {
        p1[i] = p2[i];  //使用已經釋放了的內存空間
    }
    
    return 0;
}

? ? ? ? 輸出結果如下：?

?? ? ? ? 兩個打印語句打印出來的地址值是完全相同的，這說明 free() 函數只負責釋放 p1 所指向的內存空間，但是不負責將 p1 重置為空指針，或者說重置為任何地址值。

? ? ? ? 可以做以下修改：

#include <stdio.h>
#include <malloc.h>
 
int arr[40] = {1, 2, 3, 4, 5, 6, 7};
 
int main()
{
    int* p1 = (int*)malloc(40 * sizeof(int));
    int* p2 = arr;    
    int i = 0;
    
    printf("%p\n", p1);
    for(i=0; i<40; i++)
    {
        *(p1 + i) = 40 - i; 
    }
 
    free(p1); 
    p1 = NULL;
    
    printf("%p\n", p1);
    
    for(i=0; i<40; i++)
    {
        p1[i] = p2[i];  //使用已經釋放了的內存空間
    }
    
    return 0;
}

? ? ? ? ?輸出結果如下：

? ? ? ? ?這里注意一個技巧，將釋放之后的指針立即賦值成空指針。

三、基本原則

  • 絕不返回局部變量和局部數組的地址
  • 任何變量在定義后必須初始化
  • 字符數組必須確認 0 結束符后才能成為字符串
  • 任何使用與內存操作相關的函數必須指定長度信息

? ? ? ? 下面再來看一個示例：

#include <stdio.h>
#include <string.h>
#include <malloc.h>
 
struct Student
{
    char* name;
    int number;
};
 
char* func()
{
    char p[] = "AutumnZe";
    
    return p;
}
 
void del(char* p)
{
    printf("%s\n", p);
    
    free(p);
}
 
int main()
{
    struct Student s;   //由于沒有初始化，產生了野指針
    char* p = func();   //產生了野指針
    
    strcpy(s.name, p);  //使用野指針，name 成員保存的地址值完全不知道
    
    s.number = 99;
    
    p = (char*)malloc(5);
    
    strcpy(p, "AutumnZe");   //產生內存越界，操作了野指針
    
    del(p);
    
    return 0;
}

? ? ? ? 輸出結果如下：

四、小結-上?

  • 內存錯誤是實際產品開發中最常見的問題，然而絕大多數的bug都可以通過遵循基本的編程原則和規范來避免。
  • 因此，在學習的時候要牢記和理解內存操作的基本原則，目的和意義。

五、常見的內存錯誤

  • 結構體成員指針未初始化
  • 結構體成員指針未分配足夠的內存
  • 內存分配成功，但并未初始化
  • 內存操作越界

? ? ? ? 下面看一個示例：

#include <stdio.h>
#include <malloc.h>
 
void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    free(p);    //這里多釋放了一次內存
}
 
void func(unsigned int size)
{
    int* p = (int*)malloc(size * sizeof(int));
    int i = 0;
    
    if( size % 2 != 0 )
    {
        return; 
    }
    
    for(i=0; i<size; i++)
    {
        p[i] = i;
        printf("%d\n", p[i]);
    }
    
    free(p);
}
 
int main()
{
    int* p = (int*)malloc(5 * sizeof(int));
    
    test(p, 5);
    
    free(p); 
    
    func(9);
    func(10);
       
    return 0;
}

? ? ? ? ? 輸出結果如下，可以看到程序崩潰了：

0
0
0
0
0
*** glibc detected *** ./a.out: double free or corruption (fasttop): 0x0969e008 ***
======= Backtrace: =========
/lib/libc.so.6(+0x6c0c1)[0x27b0c1]
/lib/libc.so.6(+0x6d930)[0x27c930]
/lib/libc.so.6(cfree+0x6d)[0x27fa1d]
./a.out[0x804851f]
/lib/libc.so.6(__libc_start_main+0xe7)[0x225ce7]
./a.out[0x8048391]
======= Memory map: ========
0013c000-00158000 r-xp 00000000 08:02 4629 ? ? ? /lib/ld-2.12.1.so
00158000-00159000 r--p 0001b000 08:02 4629 ? ? ? /lib/ld-2.12.1.so
00159000-0015a000 rw-p 0001c000 08:02 4629 ? ? ? /lib/ld-2.12.1.so
0020e000-0020f000 r-xp 00000000 00:00 0 ? ? ? ? ?[vdso]
0020f000-00366000 r-xp 00000000 08:02 4645 ? ? ? /lib/libc-2.12.1.so
00366000-00368000 r--p 00157000 08:02 4645 ? ? ? /lib/libc-2.12.1.so
00368000-00369000 rw-p 00159000 08:02 4645 ? ? ? /lib/libc-2.12.1.so
00369000-0036c000 rw-p 00000000 00:00 0?
00dbf000-00dd9000 r-xp 00000000 08:02 102 ? ? ? ?/lib/libgcc_s.so.1
00dd9000-00dda000 r--p 00019000 08:02 102 ? ? ? ?/lib/libgcc_s.so.1
00dda000-00ddb000 rw-p 0001a000 08:02 102 ? ? ? ?/lib/libgcc_s.so.1
08048000-08049000 r-xp 00000000 08:05 525125 ? ? /home/delphi/a.out
08049000-0804a000 r--p 00000000 08:05 525125 ? ? /home/delphi/a.out
0804a000-0804b000 rw-p 00001000 08:05 525125 ? ? /home/delphi/a.out
0969e000-096bf000 rw-p 00000000 00:00 0 ? ? ? ? ?[heap]
b7600000-b7621000 rw-p 00000000 00:00 0?
b7621000-b7700000 ---p 00000000 00:00 0?
b77db000-b77dc000 rw-p 00000000 00:00 0?
b77e9000-b77ec000 rw-p 00000000 00:00 0?
bfc94000-bfcb5000 rw-p 00000000 00:00 0 ? ? ? ? ?[stack]
已放棄

? ? ? ? 如果把多余的 free() 注釋掉，程序就能正常運行了。

void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    //free(p);    //這里多釋放了一次內存
}

? ? ? ? 輸出結果如下：

? ? ? ? 接上面的例子，討論一下 free 問題，代碼如下：

#include <stdio.h>
#include <malloc.h>
 
void test(int* p, int size)
{
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        printf("%d\n", p[i]);
    }
    
    free(p);
}
 
int main()
{
    int* p = (int*)malloc(5 * sizeof(int));
    int a[2];
    
    test(a, 2);
       
    return 0;
}

? ? ? ? ?輸出結果如下：

? ? ? ? ?因為 test(a, 2);? 調用 test() 函數時 p 所指向的內存空間是棧上面的空間，但是 free 函數的作用是釋放堆上面的空間，所以肯定會發生段錯誤。

? ? ? ? 下面再來看一個例子：

#include <stdio.h>
#include <malloc.h>
 
struct Demo
{
    char* p;
};
 
int main()
{
    struct Demo d1;
    struct Demo d2;
    
    char i = 0;
    
    for(i='a'; i<'z'; i++)
    {
        d1.p[i] = 0; 
    }
    
    d2.p = (char*)calloc(5, sizeof(char));
    
    printf("%s\n", d2.p);
    
    for(i='a'; i<'z'; i++)
    {
        d2.p[i] = i; //內存越界
    }
    
    free(d2.p);
    
    return 0;
}

? ? ? ? ?輸出結果如下：

? ? ? ? ?結構體變量里面包含指針，但是沒有初始化，就會變成野指針。所以??d1.p[i] = 0; 就會產生 bug。

六、內存操作的規則

動態內存申請之后，應該立即檢查指針值是否為 NULL，防止使用 NULL 指針

?free 指針之后必須立即賦值為 NULL

?任何與內存操作相關的函數都必須帶長度信息

?malloc 操作和 free 操作必須匹配，防止內存泄露和多次釋放。

七、小結-下?

內存錯誤的本質源于指針保存的地址為非法值

  • 指針變量未初始化，保存隨機值
  • 指針運算導致內存越界

內存泄漏源于 malloc 和 free 不匹配

  • 當 malloc 次數多于 free 時，產生內存泄漏
  • 當 malloc 次數少于 free 時，程序可能崩潰

避免內存泄漏：哪個函數里面進行的 malloc ，就在哪個函數里面 free，不要跨函數去釋放動態的內存空間。

原文鏈接：https://blog.csdn.net/weixin_43129713/article/details/124115249

欄目分類
最近更新