memcpylinux

A. 自己在linux系统下实现memcpy的功能，我的理解是memcpy可以处理任意的数据类型非懂勿入，高手分享！

#include<stddef.h>
#include<assert.h>
void *mymemcpy(void *dest, const void *src, size_t n)
{
assert(dest!=NULL&&src!=NULL);
char* tmp=(char*)dest;
const char*s=(const char*)src;
for(size_t i=0;i<n;i++)
{
tmp[i]=s[i];
}
return dest;
}

DevC++测试通过

B. linux下应用程序和内核驱动程序间的数据交换能否用memcpy完成为什么求大师帮忙解答下

在LKM下，也就是在内核态，是可以访问用户地址空间的。也就是在LKM中你可以用memcpy，strcpy之类的实现……

在用户态是不能访问 内核地址空间的，所以……

C. LINUX 下c编程memcpy出错，求大仙指导！

报错，还有完整的变量定义。

D. 怎样的memcpy是由DMA在linux处理

#include #include void *mymemcpy(void *dest, const void *src, size_t n) { assert(dest!=NULL&&src!=NULL); char* tmp=(char*)dest; const char*s=(const char*)src; for(size_t i=0;i

E. 为什么linux下C11没法使用memcpy_s

简单的说，那就是没有呗；memcpy_s这个本身就是windows的库，而不是标准库，更不是你所说的C11的库；这个应该是windows所谓的更安全的库；

F. memcpy为什么只能用char

memcpy的原型是这样的：

void*memcpy(void*dest,constvoid*src,size_tn);

源地址和目标地址的指针都是void *型的，也就是可以传入任何类型的指针，因为这里要执行的操作和指针类型没有任何关系，只需要知道起点和大小。

这段是网络上贴的linux下的实现：

void*memcpy(void*dest,constvoid*src,size_tcount)
{
assert(dest!=NULL&&src!=NULL);
char*tmp=dest;
constchar*s=src;
for(size_ti=0;i<count;i++)
{
tmp[i]=s[i];
}
returndest;
}

采取的是逐字节复制的方法，所以就使用char *来访问，因为C里要访存必须指定一个具体的类型，告诉编译器要访问多大的空间，对void *解除引用是非法的。另外用char *比较简便，使用int *来访问的话，你无法保证要复制的大小是偶数，这样还得加个判断。

G. Linux下有没有类似windows下memcpy

Linux C编程中是可以使用memcpy函数的，因为memcpy函数是C语言标准库中的函数，凡是C标准库中的函数，不论是Linux还是Windows，都是支持的都可以使用。实际上在Linux编程中大量使用C标准库的函数，一些能用标准库完成的就不需要调用Linux函数接口（Linux函数接口叫做Linux系统调用），所以C标准库在Linux中比在Windows上反而更常用呢。

H. linux内核中memcpy和memmove函数的区别和实现

memcpy的效率会比memmove高一些，如果还不明白的话可以看一些两者的实现，平时很少有重叠的例子，所以只有特殊情况才考虑memmove

void *memmove(void *dest, const void *source, size_t count)
{
assert((NULL != dest) && (NULL != source));
char *tmp_source, *tmp_dest;
tmp_source = (char *)source;
tmp_dest = (char *)dest;
if((dest + count<source) || (source + count) <dest))
{// 如果没有重叠区域
while(count--)
*tmp_dest++ = *tmp_source++;
}
else
{ //如果有重叠
tmp_source += count - 1;
tmp_dest += count - 1;
while(count--)
*--tmp_dest = *--tmp;
}
return dest;
}

void *memcpy(void *dest, const void *source, size_t count)
{
assert((NULL != dest) && (NULL != source));
char *tmp_dest = (char *)dest;
char *tmp_source = (char *)source;
while(count --)//不对是否存在重叠区域进行判断
*tmp_dest ++ = *tmp_source ++;
return dest;
}

I. memcpy是什么意思

memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。
Windows中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

void* __cdecl memcpy(
void* dst,
const void* src,
size_t count
)
{
void*ret=dst;
#if defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC)
{
extern void RtlMoveMemory(void *,const void *,size_t count);
RtlMoveMemory(dst,src,count);
}
#else /*defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC)*/
/*
* from lower addresses to higher addresses
*/
while(count--){
*(char *)dst = *(char *)src;
dst = (char *)dst+1;
src = (char *)src+1;
}
#endif /*defined(_M_MRX000)||defined(_M_ALPHA)||defined(_M_PPC)*/
return (ret);
}

coreutils中

1
2
3
4
5
6
7
8
9
10

void* memcpy(void*destaddr,voidconst*srcaddr,size_tlen)
{
char* dest=destaddr;
char const* src=srcaddr;
while(len-->0)
{
*dest++ = *src++;
}
return destaddr;
}

Linux中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

void *memcpy(void *to, const void *from, size_t n)
{
void *xto = to;
size_t temp, temp1;

if (!n)
return xto;
if ((long)to & 1) {
char *cto = to;
const char *cfrom = from;
*cto++ = *cfrom++;
to = cto;
from = cfrom;
n--;
}
if (n > 2 && (long)to & 2) {
short *sto = to;
const short *sfrom = from;
*sto++ = *sfrom++;
to = sto;
from = sfrom;
n -= 2;
}
temp = n >> 2;
if (temp) {
long *lto = to;
const long *lfrom = from;
#if defined(CONFIG_M68000) || defined(CONFIG_COLDFIRE)
for (; temp; temp--)
*lto++ = *lfrom++;
#else
asm volatile (
" movel %2,%3\n"
" andw #7,%3\n"
" lsrl #3,%2\n"
" negw %3\n"
" jmp %%pc@(1f,%3:w:2)\n"
"4: movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
" movel %0@+,%1@+\n"
"1: dbra %2,4b\n"
" clrw %2\n"
" subql #1,%2\n"
" jpl 4b"
: "=a" (lfrom), "=a" (lto), "=d" (temp), "=&d" (temp1)
: "0" (lfrom), "1" (lto), "2" (temp));
#endif
to = lto;
from = lfrom;
}
if (n & 2) {
short *sto = to;
const short *sfrom = from;
*sto++ = *sfrom++;
to = sto;
from = sfrom;
}
if (n & 1) {
char *cto = to;
const char *cfrom = from;
*cto = *cfrom;
}
return xto;
}

程序例example1
作用：将s中的字符串复制到字符数组d中。

1
2
3
4
5
6
7
8
9
10
11
12
13

//memcpy.c
#include <stdio.h>
#include <string.h>
int main()
{
char* s="GoldenGlobalView";
char d[20];
clrscr();
memcpy(d,s,(strlen(s)+1));
printf("%s",d);
getchar();
return 0;
}

输出结果：Golden Global View
example2
作用：将s中第13个字符开始的4个连续字符复制到d中。(从0开始)

1
2
3
4
5
6
7
8
9
10
11

#include<string.h>
int main(
{
char* s="GoldenGlobalView";
char d[20];
memcpy(d,s+12,4);//从第13个字符(V)开始复制，连续复制4个字符(View)
d[4]='\0';//memcpy(d,s+12*sizeof(char),4*sizeof(char));也可
printf("%s",d);
getchar();
return 0;
}

输出结果：View
example3
作用：复制后覆盖原有部分数据

1
2
3
4
5
6
7
8
9
10
11

#include<stdio.h>
#include<string.h>
int main(void)
{
char src[]="******************************";
char dest[]="";
printf("destination before memcpy:%s\n",dest);
memcpy(dest,src,strlen(src));
printf("destination after memcpy:%s\n",dest);
return 0;
}

输出结果：
destination before memcpy:
destination after memcpy: ******************************as6