memcpy小尝试

最新推荐文章于 2021-01-12 22:55:15 发布
最新推荐文章于 2021-01-12 22:55:15 发布
阅读量302 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yeyeye200/article/details/84958936
版权

itoa

int a=10;
char b[10];
itoa(a,b,2);//二进制显示
printf("%s/n",b);

小地址←大地址的拷贝

#include<math.h>
#include<stdio.h>
#include <string.h>
#include<iostream>
using namespace std;

typedef  unsigned char u8;
typedef  unsigned short int u16;
typedef  unsigned long int u32;
typedef  unsigned long long int u64;

//memcpy逐字拷贝
//void *memcpy(void *dest, const void *src, size_t n);
//从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
void try_memcpy_1()
{
	u8 a1[10];//int8//1
	u16 a2[10];//int16//2
	u32 a4[10];//int32//int//4
	u64 a8[10];//int64//8
	
	u64 a8E1 = 0;//1 to 8 
	u64 a8E2 = 0;//2 to 8 
	u64 a8E4 = 0;//4 to 8 
	u64 a8E8 = 0;//8 to 8 
	
	char b1[1000];char b2[1000];char b4[1000];
	for(int i = 0; i<10;i++)a1[i] = 1;// = 0xf0;
	for(int i = 0; i<10;i++)a2[i] = 1;// = 0xf0f0;
	for(int i = 0; i<10;i++)a4[i] = 1;// = 0xf0f0f0f0;
	for(int i = 0; i<10;i++)a8[i] = 1;// = 0xf0f0f0f0f0;

    cout<<endl<<"big address ← small address"<<endl;
	cout<<"copy 2 bites"<<endl;//2 char to a8 , 
	memcpy ( &a8E1 ,a1 , 2 ) ;//小内存拷至大内存，大存小
	itoa(a8E1,b1,2);
	cout<<"a8E1 = "<< b1;
	cout<<" = "<< a8E1;cout<<"\t : 2 bites,2 number "<<endl;
	
	memcpy ( &a8E2 ,a2 , 2 ) ;//小内存拷至大内存
	itoa(a8E2,b2,2);
	cout<<"a8E2 = "<< b2;
	cout<<" = "<< a8E2;cout<<"\t : 2 bites,1 number "<<endl;
	
	memcpy ( &a8E4 ,a4 , 2 ) ;//小内存拷至大内存
	itoa(a8E4,b4,2);
	cout<<"a8E4 = "<< b4;
	cout<<" = "<< a8E4;cout<<"\t : 2 bites,1/2 number "<<endl;
	
	memcpy ( &a8E8 ,a8 , 2 ) ;//小内存拷至大内存
	itoa(a8E8,b4,2);
	cout<<"a8E8 = "<< b4;
	cout<<" = "<< a8E8;cout<<"\t : 2 bites,1/4 number "<<endl<<endl;

	cout<<"copy 4 bites"<<endl;
	memcpy ( &a8E1 ,a1 , 4 ) ;//小内存拷至大内存，大存小
	itoa(a8E1,b1,2);
	cout<<"a8E1 = "<< b1;
	cout<<" = "<< a8E1;cout<<"\t : 4 bites,4 number "<<endl;
	
	memcpy ( &a8E2 ,a2 , 4 ) ;//小内存拷至大内存
	itoa(a8E2,b2,2);
	cout<<"a8E2 = "<< b2;
	cout<<" = "<< a8E2;cout<<"\t : 4 bites,2 number "<<endl;
	
	memcpy ( &a8E4 ,a4 , 4 ) ;//小内存拷至大内存
	itoa(a8E4,b4,2);
	cout<<"a8E4 = "<< b4;
	cout<<" = "<< a8E4;cout<<"\t : 4 bites,1 number "<<endl;
	
	memcpy ( &a8E8 ,a8 , 4 ) ;//小内存拷至大内存
	itoa(a8E8,b4,2);
	cout<<"a8E8 = "<< b4;
	cout<<" = "<< a8E8;cout<<"\t : 4 bites,1/2 number "<<endl<<endl;

	cout<<"copy  8 bites"<<endl;
	memcpy ( &a8E1 ,a1 , 8 ) ;//小内存拷至大内存，大存小
	itoa(a8E1,b1,2);
	cout<<"a8E1 = "<< b1;
	cout<<" = "<< a8E1;cout<<"\t : 8 bites,8 number "<<endl;
	
	memcpy ( &a8E2 ,a2 , 8 ) ;//小内存拷至大内存
	itoa(a8E2,b2,2);
	cout<<"a8E2 = "<< b2;
	cout<<" = "<< a8E2;cout<<"\t : 8 bites,4 number "<<endl;
	
	memcpy ( &a8E4 ,a4 , 8 ) ;//小内存拷至大内存
	itoa(a8E4,b4,2);
	cout<<"a8E4 = "<< b4;
	cout<<" = "<< a8E4;cout<<"\t : 8 bites,2 number "<<endl;
	
	memcpy ( &a8E8 ,a8 , 8 ) ;//小内存拷至大内存
	itoa(a8E8,b4,2);
	cout<<"a8E8 = "<< b4;
	cout<<" = "<< a8E8;cout<<"\t : 8 bites,1 number "<<endl<<endl;
}

结果：
1>
1> big address ← small address
1> copy 2 bites
1> a8E1 = 100000001 = 257 : 2 bites,2 number
1> a8E2 = 1 = 1 : 2 bites,1 number
1> a8E4 = 1 = 1 : 2 bites,1/2 number
1> a8E8 = 1 = 1 : 2 bites,1/4 number
1>
1> copy 4 bites
1> a8E1 = 1000000010000000100000001 = 16843009 : 4 bites,4 number
1> a8E2 = 10000000000000001 = 65537 : 4 bites,2 number
1> a8E4 = 1 = 1 : 4 bites,1 number
1> a8E8 = 1 = 1 : 4 bites,1/2 number
1>
1> copy 8 bites
1> a8E1 = 1000000010000000100000001 = 72340172838076673 : 8 bites,8 number
1> a8E2 = 10000000000000001 = 281479271743489 : 8 bites,4 number
1> a8E4 = 1 = 4294967297 : 8 bites,2 number
1> a8E8 = 1 = 1 : 8 bites,1 number

1. 拷贝4个字节8个字节，效果一样没影响，实际数据有不一样。
2. 按字节拷贝。

大地址←小地址的拷贝

void try_memcpy_2()
{
	cout<<endl<<"small address ← big address"<<endl;
	u8 b1E2 = 0;//int8
	u8 b1E4 = 0;//int8
	u8 b1E8 = 0;//int8//1
	u16 d2=0xfa;//int16//2
	u32 d4=0xfbfa;//int32//int//4
	u64 d8=0xfdfcfbfa;//int64//8
	char c2[100];char c4[100];char c8[100];
	
	u8 n = 0;
	switch(n)
	{
		case 0:
			cout<<"copy 1 bites"<<endl;
			memcpy ( &b1E2 ,&d2 , 1 ) ;itoa(b1E2,c2,2);
			cout<<"b1E2 = "<< c2<<endl;
			memcpy ( &b1E4 ,&d4 , 1 ) ;itoa(b1E4,c4,2);
			cout<<"b1E4 = "<< c4<<endl;
			memcpy ( &b1E8 ,&d8 , 1 ) ;itoa(b1E8,c8,2);
			cout<<"b1E8 = "<< c8<<endl<<endl;
			
			n++;
			b1E2 = 0;b1E4 = 0;b1E8 = 0;
			memset(c2,0,100);memset(c4,0,100);memset(c8,0,100);//数组清空
		
		case 1:
			cout<<"copy 2 bites"<<endl;
			memcpy ( &b1E2 ,&d2 , 2 ) ;itoa(b1E2,c2,2);
			cout<<"b1E2 = "<< c2<<endl;
			memcpy ( &b1E4 ,&d4 , 2 ) ;itoa(b1E4,c4,2);
			cout<<"b1E4 = "<< c4<<endl;
			memcpy ( &b1E8 ,&d8 , 2 ) ;itoa(b1E8,c8,2);
			cout<<"b1E8 = "<< c8<<endl<<endl;
			
			n++;
			b1E2 = 0;b1E4 = 0;b1E8 = 0;
			memset(c2,0,100);memset(c4,0,100);memset(c8,0,100);//数组清空
		
		case 2:
			cout<<"copy 4 bites"<<endl;
			memcpy ( &b1E2 ,&d2 , 4 ) ;itoa(b1E2,c2,2);
			cout<<"b1E2 = "<< c2<<endl;
			memcpy ( &b1E4 ,&d4 , 4 ) ;itoa(b1E4,c4,2);
			cout<<"b1E4 = "<< c4<<endl;
			memcpy ( &b1E8 ,&d8 , 4 ) ;itoa(b1E8,c8,2);
			cout<<"b1E8 = "<< c8<<endl;
			cout<<"high address overflow ... "<<endl;

	}

}

结果：
1> small address ← big address
1> copy 1 bites
1> b1E2 = 11111010
1> b1E4 = 11111010
1> b1E8 = 11111010
1>
1> c2[0]=1
1> c2[0]= copy 2 bites
1> b1E2 = 11111010
1> b1E4 = 11111010
1> b1E8 = 11111010
1>
1> c2[0]=1
1> c2[0]= copy 4 bites
1> b1E2 = 11111010
1> b1E4 = 11111010
1> b1E8 = 11111010
1> high address overflow …

拷贝一个大地址到小地址，高位溢出，只剩下低位的数据

向前拷贝&&向后拷贝

//csdn上借鉴的代码
void try_memcpy_3()
{
	u8 buf[15] = {0};
	u8 buf1[15] = {0};
	u8 dst_buf[15] = {0};
 
	for(u8 i = 0; i < 15; i ++)
	{
		buf[i] = i;
		buf1[i] = i;
	}		
 
	printf("src buf  = ");
	for(int i = 0; i < 15; i ++)printf("%d ", buf[i]);

	printf("\nsrc buf1 = ");
	for(int i = 0; i < 15; i ++)printf("%d ", buf1[i]);

	//不同BUFF之间拷贝
	memcpy(dst_buf, buf, 15); 
	printf("\n\n10 from buf copy to dst buf, dst_buf = ");
	for(int i = 0; i < 15; i ++)printf("%d ", dst_buf[i]);


	//同一个BUFF向后拷贝
	memcpy(buf + 4, buf + 3, 10); //buf[3]→buf[4]
	printf("\n10 from buf + 3 copy to buf + 4, buf = ");
	for(int i = 0; i < 15; i ++){
		printf("%d ", buf[i]);
		//buf[i] = 0;
	}

	//同一个BUFF向前拷贝
	memcpy(buf1, buf1 + 3, 10);//buf[3]→buf[0]
	printf("\n*10 from buf1 + 3 copy to buf1, buf1 = ");
	for(int i = 0; i < 15; i ++)
		printf("%d ", buf1[i]);
    printf("\n向后拷贝wrong");
	
}

结果：
1> src buf = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
1> src buf1 = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
1>
1> 10 from buf copy to dst buf, dst_buf = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
向后拷贝有误：
1> 10 from buf[3] copy to buf[4], buf = 0 1 2 3 3 4 5 6 6 8 9 10 10 12 14
向前拷贝无误：
1> *10 from buf1[3] copy to buf1[0], buf1 = 3 4 5 6 7 8 9 10 11 12 10 11 12 13 14

注意向后拷贝的使用

yeyeye200
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
memcpy小尝试2
yeyeye200的博客
12-23 159
int main() { char a[100] = "01234567890123456789"; char b[100] = "01234567890123456789"; pT0p(a); try_memcpy_00(&amp;a[5],&amp;a[2],10); cout&lt;&lt;"a = "&lt;&lt;a&lt;&lt;endl; try_memcpy_
memcpy 不能使用try catch catch住
05-20 1705
那日review代码，比较引起争议的一件事。关于memcpy是否能catch的问题。 刚才小试了一下，代码如下。   结论是，是cacth不到的。搜了下，原因是，memcpy是c 而来，未进行exception 机制。。。   http://stackoverflow.com/questions/7164019/does-memcpy-not-throw-exceptions
？ 枚举 编程题＃2：拨钟问题（Coursera 程序设计与算法 专项课程4；函数memcpy的用法，switch case break 语句！）
小勇工作室
12-20 631
编程题＃2：拨钟问题 来源: POJ (Coursera声明：在POJ上完成的习题将不会计入Coursera的最后成绩。) 注意： 总时间限制: 1000ms 内存限制: 65536kB 描述 有9个时钟，排成一个3*3的矩阵。 　　　　　　　　　　 (图 1) 现在需要用最少的移动，将9个时钟的指针都拨到12点的位置。共允许有9种不同的移动。如下表所示，每个移动会将
memcpy的用法总结
热门推荐
lovemysea的专栏
02-01 18万+
1、memcpy 函数用于 把资源内存（src所指向的内存区域） 拷贝到目标内存（dest所指向的内存区域）；拷贝多少个？有一个size变量控制拷贝的字节数；函数原型：void *memcpy(void *dest, void *src, unsigned int count);用法：（1）可以拷贝任何类型的对象，因为函数的参数类型是void*（未定义类型指针），也就是说传进去的实参可以是int*
对比C语言中memccpy()函数和memcpy()函数的用法
09-03
函数会尝试在`src`指向的内存区域的前`n`个字节中找到字符`c`，并将所有这些字节（包括找到的字符`c`）复制到`dest`指向的内存区域。如果找到了字符`c`，函数返回`dest`之后第一个出现`c`的字节地址。如果没有找到，...
KEIL软件中memcpy函数的使用限制.docx
09-13
在KEIL软件中，当memcpy函数处理4字节或8字节的数据时，编译器会尝试利用更高效的汇编指令进行快速复制。对于4字节数据，编译器可能会直接使用单个汇编指令完成；对于8字节数据，可能使用双字节对齐的指令。但问题...
memcpy函数的实现代码 (2).pdf
09-14
接下来，作者尝试了一个优化的版本，但引入了额外的条件判断： ```c void memcpy(void *dest, void *src, size_t n) { char *pd = (char *)dest; char *ps = (char *)src; long len = (long)sizeof(size_t) * n;...
网络渗透——BSD的memcpy溢出利用技术
06-09
6. **权限提升**：一旦恶意代码得以执行，攻击者可能尝试进一步提升权限，如从用户权限升级到root权限，以获得更广泛的控制。 防范memcpy溢出的方法包括使用安全的内存拷贝函数，如memcpy_s或memmove，它们会检查...
C语言常用函数源码 strcmp strlen atoi atol memcpy strchr strstr printf等等
08-25
- 对主字符串中的每一个可能的起始位置，尝试与子字符串匹配。 - 如果匹配成功，返回子字符串在主字符串中的位置指针；否则返回`NULL`。 #### 八、`printf` — 输出格式化字符串 **功能**：向标准输出设备（通常是...
关于不同类型之间使用memcpy
千里之行
11-16 8279
我们知道，memcpy的原型大概是这样的： void memcpy(void*,const void *,size_t); 也就是说，相对strcpy，memcpy的可用的场合更多，至少从声明来看，可以支持任意类型之间的拷贝  之前遇到的类似这样的代码：  //为了简化说明，数字比较简单  unsigned long ulVar = 0; memcpy((&ulVar),
c++ memset 语言_memset（C++版本）
weixin_35803436的博客
01-12 314
## memset函数简介memset函数是一个实用初始化函数，它可以将一个数组的所有值都初始化成一个数。但是，有些时候你要经过复杂的换算才能得出你想要的结果。## 使用格式memset(数组名称，想要的值，sizeof(数组名称));### 举例我们要把a数组全部初始化成0：```cppmemset(a,0,sizeof(a));```这样，的所有值都变成0了。## 最简单的初始化值在memse...
memcpy(&gdt,(void*)(*((u32*)(&gdt_ptr[2]))),*((u16*)(&gdt_ptr[0])) + 1)中参数的理解
xiaominthere的专栏
01-04 2000
今天看代码时，一下子没有看懂，所以记录一下解析过程。 先看定义： PUBLIC    u8        gdt_ptr[6]; PUBLIC    DESCRIPTOR    gdt[GDT_SIZE]; PUBLIC    void*    memcpy(void* pDst, void* pSrc, int iSize); 然后看memcpy(&gdt,(void*)(*(
linux编译中error: no arguments depend on a template parameter, declaration of * must 解决
duke0226的专栏
06-29 1435
由于标题长度的限制，只截取了关键词 比较完整的错误描述是： error: there are no arguments to '*' (这里 ‘*‘ 代表某个函数名，比如 'memset') that depend on a template parameter, so a declaration of '*' must be available 接着是错误发生位置的描述。 比如
【C语言】第十章-字符串及内存操作函数
qq_41669298的博客
02-04 250
  在这一章我们重点讲解几个字符串及内存的标准库函数，这些函数都是标准库中提前准备好了的，但是我们有必要了解它们的功能，并且模拟它们的实现，这对我们将来的程序编写有很多指导性意义。 字符串函数 strlen()   这个函数我相信大家再熟悉不过了，就是普通的计算字符串长度的函数，不过我们要注意这个函数传入的参数必须是一个以空字符结尾的字符串。不然就会出现未定义行为。这个函数返回的长度是字符串不包含...
memcpy 函数圆形
最新发布
07-25
`memcpy()`函数是一个基本的内存复制函数，在C语言标准库中提供，主要用于在不改变目标内存区域原有数据的情况下，从源内存区域复制指定大小的数据到目标内存区域。 ### `memcpy()`函数简介 #### 标准定义 在ANSI C90和后续版本的标准中，`memcpy()`函数的原型通常是这样的： ```c void *memcpy(void *dest, const void *src, size_t n); ``` 这里的参数说明如下： - `dest`: 目标地址指针。 - `src`: 源地址指针。 - `n`: 需要复制的字节数。 #### 功能描述 `memcpy()`函数将`src`所指向的连续字节块复制到由`dest`指针指向的内存中。复制的长度是`n`个字节。如果`dest`和`src`之间存在交叉边界（即它们跨越了一个进程的地址空间界限），那么`memcpy()`的行为是未定义的。通常情况下，`memcpy()`不会检查是否有足够的内存空间来进行复制操作；因此，如果目标缓冲区太短而无法容纳所有数据，程序可能会损坏目标区域或其他内存，并可能导致程序崩溃或安全漏洞。 #### 使用注意事项 - **安全性**: `memcpy()`不检查缓冲区是否足够大，这有可能导致溢出。使用前应确保目标缓冲区有足够的空间接收数据。 - **性能考虑**: 对于小型数组或固定大小的数据块，直接使用位操作进行复制可能比使用`memcpy()`更快。然而，这种做法需要对底层架构有深入理解并且可能不如使用高级API直观易懂。 - **跨平台兼容性**: 虽然大多数现代操作系统上`memcpy()`的行为一致，但在某些嵌入式系统或低级环境中，其行为可能有所不同，因此编写跨平台安全的代码时需谨慎。 ### 示例代码 ```c #include <stdio.h> #include <string.h> int main() { char src[] = "Hello"; char dest; // 尝试复制字符串到目标缓冲区 if (memcpy(dest, src, sizeof(src)) != NULL) { printf("Copied string successfully.\n"); } else { printf("Failed to copy string.\n"); } printf("Source string: %s\n", src); printf("Destination string: %s\n", dest); return 0; } ``` 在这个例子中，我们尝试从`src`复制到`dest`，但由于`dest`的大小刚好等于`src`，所以实际上不需要额外的空间，这个例子仅用于演示目的。 ### 相关问题： - `memcpy()`与`memmove()`的区别是什么？ - 怎样避免在使用`memcpy()`时发生内存越界错误？ - 当我们需要复制不同类型的变量时应该注意什么？ 以上讨论了`memcpy()`函数的基础知识以及一些重要的使用细节和注意事项。了解这些可以帮助程序员更安全、更高效地使用该函数进行内存操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值