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