La différence entre memcpy et memcpy_s, memmove et memmove_s, sprintf et sprintf_s

1. memcpy et memcpy_s:
deux prototypes de fonction:

void* memcpy(
	void *restrict s1, 
	const void *restrict s2, 
	size_t n);
	
errno_t memcpy_s(
	void *dest, // dest：目标的地址
	size_t numberOfElements, // numberOfElements：目标的size
	const void *src, // src：源地址
	size_t count); // count：要拷贝的字节数

memcpy_sPar rapport à la memcpydétection effective de débordement de mémoire (le nombre d'octets à copier dépasse le nombre que l'adresse cible peut contenir, c'est-à-dire la taille), elle peut être vérifiée par la valeur de retour. Mais memcpy ne garantit pas.memmove et memmove_s, strcpy et strcpy_s sont similaires.

Matériel de référence: l'utilisation de memcpy et memcpy_s

2. memcpy et memmove et memmove_s:
deux prototypes de fonction:

void *memcpy(void *restrict s1, const void *restrict s2, size_t n);
void *memmove(void *s1, const void *s2, size_t n);
errno_t memmove_s（void * dest，rsize_t destsz，const void * src，rsize_t count）;

Objectif deux fonctions: l' s2emplacement pointé vers les ndonnées d'octet copiées vers l' s1emplacement pointé.
La différence entre les deux fonctions:La différence réside dans le mot-clé restrict, memcpy suppose qu'il n'y a pas de chevauchement de données entre les deux zones de mémoire, et memmove n'a pas cette condition préalable 。
memmove与En revanche, il memcpypeut détecter efficacement le problème de chevauchement de la zone mémoire.Memcpy copie directement, quel que soit le chevauchement de la zone mémoire; Memmove détecte d'abord le chevauchement, puis détermine la position de début de la copie.
Si vous utilisez memcpy quand il y a chevauchement entre les deux zones copiées, le résultat est imprévisible (peut réussir ou échouer). Par conséquent, pour utiliser memcpy, le programmeur doit s'assurer que les deux morceaux de mémoire ne se chevauchent pas.

Références: La différence entre memcpy et memmove
Tencent Cloud: memmove_s et memmove

3. sprintf et sprintf_s:
fichiers d'en-tête à inclure:
fonction de formatage de chaîne stdio.h , prototype:

int sprintf_s(
	char *buffer, // char型指针，指向将要写入字符串的缓冲区。
	size_t sizeOfBuffer,
	const char *format, // format：格式化字符串
	[argument...] // va_list,变参列表（任意多个任何类型的数据）
);

char buffer[200]; // 需要预先分配缓冲区
sprintf_s( buffer, sizeof(buffer), "Output:%s character count = %d\n", var1, var2);
sprintf_s(buffer, sizeof(buffer), "%s %s %s %s",path1,filepath,path3,path4);

La fonction de sprintf_s est de formater les données et de les sortir sous forme de chaîne.Le dernier paramètre est une liste de paramètres variables (n'importe quel nombre de données de n'importe quel type). sprintf_s()Oui sprintf(), la version sûre, évitez sprintf()le risque de débordement en spécifiant la longueur du tampon。

Référence: La différence entre sprintf et sprintf_s dans l' Encyclopédie Baidu c ++
: sprintf_s

Pour résumer:

1. memcpy–> memcpy_s considère le problème de débordement de mémoire; memcpy_s–> memmove_s considère le problème de chevauchement de zone mémoire, donc utiliser memmove_s est le plus sûr, mais comparé à memcpy_s, il a plus de surcharge pour détecter s'il y a chevauchement.
2. Le dernier paramètre de la fonction de formatage de chaîne sprintf_s est une liste de paramètres variables (n'importe quel nombre de données de n'importe quel type). sprintf_s()Oui sprintf(), la version de sécurité, en spécifiant la longueur du buffer pour éviter sprintf()le risque de débordement ==.