C語言深入詳解四大記憶體函數的使用

1.memcpy

與字串函數 strcpy 類似，也是進行拷貝。但是需要注意的是，strcpy 是針對字串進行拷貝，而 memcpy 是針對記憶體進行拷貝。

如何理解呢？strcpy 進行拷貝的時候，只能一個位元組一個位元組的拷貝，但要實現 整型、浮點型等資料型別拷貝的時候，就不得不用到 memcpy 了。

我們觀察 strcpy 的函數宣告：

char * strcpy ( char * destination, const char * source );

再觀察 memcpy 的函數宣告：

void * memcpy ( void * destination, const void * source, size_t num );

可以看到 strcpy 的侷限在於只能接收 字元型 的指標，但 memcpy 對於型別可以在函數內部實現自定義。

我們瀏覽cplusplus對引數作出的解釋：

現在我們要研究如何使用：

#include <stdio.h>
#include <string.h>
int main()
{
	int dest[10] = { 0 };
	int src[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(dest, src, 20);//拷貝 20 個位元組
	return 0;
}

我們從 src 陣列中，拷貝 20 個位元組的資料放到 dest 陣列中。那麼我們通過 偵錯—視窗—監視來觀察 dest 陣列中的變化：

未經 memcpy 前：

經 memcpy 後：

可以直觀地看到， dest 陣列中前 20 個位元組的內容發生了改變。

使用起來倒是不復雜，那我們能不能用自己的程式碼去模擬實現一個 memcpy 函數？

#include <stdio.h>
void* AnalogMemcpy(void* dest, const void* src, unsigned int num)
{
	void* start = dest;//定義一個記錄 dest 初始地址的指標
	while (num--)//一個位元組一個位元組拷貝
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return start;//返回此指標
}
int main()
{
	int dest[10] = { 0 };
	int src[10] = { 1,2,3,4,5,6,7,8,9,10 };
	AnalogMemcpy(dest, src, 20);
	return 0;
}

我們的實現思路非常簡單，因為官方給出第三個引數的定義是：要複製的位元組數。那我們順水推舟一個位元組一個位元組的拷貝。

但是到這裡，可能會存在這樣一個問題： char 型別是一個位元組，我們使用 memcpy 時也是一個位元組一個位元組的拷貝，那為什麼 strcpy 不能拷貝整型？

在我們自己模擬實現 strcpy 的時候，拷貝的停止條件是什麼？是 src 字串碰到 '' 。預設我們的裝置是小端儲存模式，那麼我們使用 strcpy 進行拷貝的時候就會出現這種情況：

現在我們使用模擬實現的 memcpy 函數來執行這段程式碼：

#include <stdio.h>
void* AnalogMemcpy(void* dest, const void* src, unsigned int num)
{
	void* start = dest;//定義一個記錄 dest 初始地址的指標
	while (num--)//一個位元組一個位元組拷貝
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return start;//返回此指標
}
int main()
{
	int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
	AnalogMemcpy(dest + 3, dest, 20);
	return 0;
}

這段程式碼的意思是這樣的：

但事實上真正的結果是：

這該如何解釋呢？其實不難：

那麼我們暫且定下一個結論：

memcpy 只能處理空間不重疊的資料拷貝。

2.memmove

這個函數與 memcpy 的功能相同，都是進行資料拷貝。但是不同的點是：memmove 是用來處理空間重疊的資料拷貝的。

這是 memmove 的函數宣告：

void * memmove ( void * destination, const void * source, size_t num );

既然是處理空間重疊的情況，那我們直接對上一個程式碼進行處理：

可以看到， memmove 符合我們的預期實現了效果。

我們現在來挑戰一下如何模擬實現一個 memmove 函數：

#include <stdio.h>
void* AnalogMemmove(void* dest, const void* src, unsigned int num)
{
	void* start = dest;//定義一個記錄 dest 初始地址的指標
 
	if (src < dest)//如果 src 在 dst 的左邊
	{
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	else
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	return start;//返回這個指標
}
int main()
{
	int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
	AnalogMemmove(dest + 3, dest, 20);
	return 0;
}

乍一看，這個程式碼比較複雜，事實上，只有兩種情況。

我們來分析一下：

但是！這裡要注意了，上面使使用自己模擬的 memcpy 不能實現空間重疊拷貝的，但庫函數原裝的 memcpy 能夠實現空間重疊拷貝嗎？

我們來看庫函數 memcpy 能否實現空間重疊拷貝：

#include <stdio.h>
#include <string.h>
int main()
{
	int dest[10] = { 1,2,3,4,5,6,7,8,9,10 };
	memcpy(dest + 3, dest, 20);
	return 0;
}

這就奇了怪了！既然庫函數 memcpy 能夠實現空間重疊的拷貝，那還需要 memmove 做什麼？

事實上，對於我使用的 Visual Studio 2022 這款編譯器來說，memcpy 是可以實現空間重複拷貝的。也就是說可能在其他的編譯器上實現不了空間重疊拷貝，但 Visual Studio 2022 這款編譯器賦予了 memcpy 這項功能。

3.memcmp

與 strcmp 類似的，這個函數也是進行比較的函數，我們觀察一下它的函數宣告：

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

那麼對於這些引數以及返回值的解釋是：

因為我們學習過 strcmp ，那我們現在直接使用它：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[10] = { 1,2,3,3,4,5,6,7,8,9 };
	int ret=memcmp(arr1, arr2, 20);
	if (ret > 0)
		printf("arr1 > arr2n");
	else if (ret < 0)
		printf("arr1 < arr2n");
	else
		printf("arr1 == arr2n");
	return 0;
}

與 strcmp 的原理是一致的，這裡就不贅述了。

4.memset

直譯過來就是記憶體設定。事實上也是這麼回事。

觀察它的函數宣告：

void * memset ( void * ptr, int value, size_t num );

它的作用是以及引數的意義：

說白了就是：你需要提供一個指標，這個指標指向的要被填充的記憶體。然後提供一個值，這個值決定了每個位元組要被填充為什麼內容。最後提供一個數，這個數指的是你要填充多少個位元組。

我們寫一個例子：

#include <stdio.h>
#include <string.h>
int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 4);
	return 0;
}

這就奇了怪了，我們不是設定四個位元組為 1 嗎？千萬不要麼想。我們上面強調過了，這個函數是對每個位元組填充。

我們分析一下我們寫的例子：

到此這篇關於C語言深入詳解四大記憶體函數的使用的文章就介紹到這了,更多相關C語言記憶體函數內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！