如何用汇编实现strcpy+strlen的功能(拷贝一个字符串并返回拷贝的长度)?

masterz 2007-09-15 04:32:02
需要实现一个函数拷贝字符串并且返回拷贝的长度,c语言代码如下:
size_t copy_string2(char* destination, const char* source)
{
if (!source || !destination)
return 0;
size_t length = strlen(source);
strcpy(destination, source);
return length;
}
估计上面的代码对source做了2次scan,不知道能否用汇编实现一次scan同时完成拷贝和求长度的任务。c/C++的另一种实现能做到,用汇编怎么让他更快一些?请高手赐教:)
size_t copy_string(char* destination, const char* source)
{
if (!source || !destination)
return 0;
char* start_position = destination;
do
{
*destination++ = *source++;
} while(*source);
return destination-start_position;
}
...全文
673 15 打赏 收藏 转发到动态 举报
AI 作业
写回复
用AI写文章
15 条回复
切换为时间正序
请发表友善的回复…
发表回复
ahjoe 2007-09-19
  • 打赏
  • 举报
回复
先调用 StrCpy 再调用 StrLen,速度不能满足需要?

先 StrLen, 再用 CopyMemory, 可能快一点点儿
masterz 2007-09-17
  • 打赏
  • 举报
回复
抛砖引玉,下面的代码比C语言还慢。
size_t copy_string3(char* destination, const char* source)
{
__asm{
xor eax, eax
mov esi, source
test esi, esi ; check if source is valid
jz proc_end
mov edi, destination
test edi, edi ; check if destination is valid
jz proc_end
cld
copy_lable:
lodsb
stosb
test al, al
jnz copy_lable
mov ecx, [destination]
sub edi, ecx
mov eax, edi
proc_end:
}
}
masterz 2007-09-17
  • 打赏
  • 举报
回复
下面这个版本速度还可以
size_t asm_copy_string(char* destination, const char* source)
{
__asm
{
//int 3
xor eax, eax
mov edi, destination
test edi, edi
je quit
mov ecx, source
test ecx, ecx
je quit
; check if source is aligned ON 32 bits
test ecx, 3
je main_loop_entrance

src_misaligned: ; simple byte loop until string is aligned
mov dl,byte ptr [ecx]
add ecx,1
test dl,dl
je short byte_0
mov [edi],dl
add edi,1
test ecx,3
jne short src_misaligned
jmp short main_loop_entrance

main_loop: ; edx contains first dword of sorc string
mov [edi],edx ; store one more dword
add edi,4 ; kick dest pointer
main_loop_entrance:
mov edx,7efefeffh
mov eax,dword ptr [ecx] ; read 4 bytes

add edx,eax
xor eax,-1

xor eax,edx
mov edx,[ecx] ; it's in cache now

add ecx,4 ; kick dest pointer
test eax,81010100h

je short main_loop
; found zero byte in the loop
; main_loop_end:
test dl,dl ; is it byte 0
je short byte_0
test dh,dh ; is it byte 1
je short byte_1
test edx,00ff0000h ; is it byte 2
je short byte_2
test edx,0ff000000h ; is it byte 3
je short byte_3
jmp short main_loop ; taken if bits 24-30 are clear and bit
; 31 is set
byte_3:
mov [edi],edx
mov eax,destination ; return in eax pointer to dest string
sub edi, eax
mov eax, edi
add eax, 3
jmp quit;ret
byte_2:
mov [edi],dx
mov eax,destination ; return in eax pointer to dest string
mov byte ptr [edi+2],0
sub edi, eax
mov eax, edi
add eax, 2
jmp quit;ret
byte_1:
mov [edi],dx
mov eax,destination ; return in eax pointer to dest string
sub edi, eax
mov eax, edi
add eax, 1
jmp quit;ret
byte_0:
mov [edi],dl
mov eax,destination ; return in eax pointer to dest string
sub edi, eax
mov eax, edi
jmp quit
quit:
};

}
masterz 2007-09-17
  • 打赏
  • 举报
回复
To jvphxys: 我也是这么想的,就是不知道怎么写:)库函数似乎考虑到字节对齐的问题而进行优化了。
jvphxys 2007-09-17
  • 打赏
  • 举报
回复
代码不知道怎么写啊..
不过有点想法,错了别见怪..
直接一个字符一个字符地复制,设置一个计数器,进行循环复制,遇到结束标志结束.
复制完成,计数器的值应该就是长度了.
这样感觉对于整个字符串来说,只进行了一次扫描哈.
sunlin7 2007-09-16
  • 打赏
  • 举报
回复
呵呵,不知道什么原因,直接打开这个贴子后,只能看到楼主的问题,而看不到跟贴.
sunlin7 2007-09-16
  • 打赏
  • 举报
回复
up
masterz 2007-09-16
  • 打赏
  • 举报
回复
To hkbyest:谢谢你的热心,不过sizeof是不能得到字符串长度的,它只能得到编译时静态分配的数组大小。
hkbyest 2007-09-15
  • 打赏
  • 举报
回复
当然,你用跳转逐字节比较结尾的0,里面设置一个值递增来记录字符串长度也是可以的。
hkbyest 2007-09-15
  • 打赏
  • 举报
回复
我上面说的只是一种方法,

以前做过类似的东西,
伪码如下:
mov ecx,sizeof sourcestr
mov length,ecx
dec length
push ds
pop es
mov esi,sourcestr
mov edi,targetstr
rep movsb
masterz 2007-09-15
  • 打赏
  • 举报
回复
To hkbyest:你自己试一试:)
masterz 2007-09-15
  • 打赏
  • 举报
回复
To lisunlin0:2遍扫描速度慢,我测试过了,movsb这个指令我也知道,只是不善于写汇编语言。你能帮我试试用汇编实现一遍扫描吗^_^
hkbyest 2007-09-15
  • 打赏
  • 举报
回复
字符串长度吗?
直接sizeof不就行了嘛,注意处理一下结尾的字符。
sunlin7 2007-09-15
  • 打赏
  • 举报
回复
不好意思:
size_t copy_string(char* destination, const char* source)
{
int i;
if (source && destination)
return 0;
for(i = 0; destination[i] = source[i]; i++);
return i;
}
sunlin7 2007-09-15
  • 打赏
  • 举报
回复
汇编中可以用repnz movsb实现字符串拷贝,rep scasb实现字符串求长.因此也得扫描两遍.
直接用
size_t copy_string(char* destination, const char* source)
{
int i;
if (source | destination)
return 0;
for(i = 0; destination[i] = source[i]; i++);
return i;
}
也可.
看看格式,再看看大小,应该看出它的含金量,200多页吧,不多。
部分:
1.多态类中的虚函数表是Compile-Time,还是Run-Time时建立的?
答案:虚拟函数表是在编译期就建立了,各个虚拟函数这时被组织成了一个虚拟函数的入口地址的数组.而对象的隐藏成员--虚拟函数表指针是在运行期--也就是构造函数被调用时进行初始化的,这是实现多态的关键.

2.将一个 1M -10M 的文件,逆序存储到另一个文件,就是前一个文件的最后一个
字符存到新文件的第一个字符,以此类推。

3.main主函数执行完毕后,是否可能会再执行一段代码?(朗讯的一道笔试题)
答案:可以,可以用_onexit 注册一个函数,它会在main 之后执行;
如果你需要加入一段在main退出后执行的代码,可以使用atexit()函数,注册一个函数。
语法:
#include
int atexit(void (*function")(void));
#include
#include
void fn1( void ), fn2( void ), fn3( void ), fn4( void );
int main( void )
{
atexit( fn1 );
atexit( fn2 );
atexit( fn3 );
atexit( fn4 );
printf( "This is executed first.\n" );
}
void fn1()
{
printf( "next.\n" );
}
void fn2()
{
printf( "executed " );
}
void fn3()
{
printf( "is " );
}
void fn4()
{
printf( "This " );
}
结果:
This is executed first.
This is executed next.

4.一个父类写了一个virtual 函数,如果子类覆盖它的函数不加virtual ,也能实现多态?
在子类的空间里,有没有父类的这个函数,或者父类的私有变量? (华为笔试题)
答案:只要基类在定义成员函数时已经声明了virtue关键字,在派生类实现的时候覆盖该函数时,virtue关键字可加可不加,不影响多态的实现。子类的空间里有父类的所有变量(static除外)。

5.给一个字符串、例如 “ababc”要求返回“ab”. 因为“ab”连续重复出现且最长。
用C/C++语言写一函数完成该算法,给出复杂度

6.对序列1、1、2、3、5、8、13。。。。 是Fab..数列
2、3、5、13...是Fab..质数数列,因为他们与自己前面的Fab...数列都互质
给出k,返回第k小的Fab..质数

7.101个硬币100真、1假,真假区别在于重量。请用无砝码天平称两次给出真币重还是假币
重的结论。

8.完成字符串拷贝可以使用 sprintf、strcpy 及 memcpy 函数,请问这些函数有什么区别
,你喜欢使用哪个,为什么?
答案:这些函数的区别在于 实现功能 以及 操作对象 不同。
1.strcpy 函数操作的对象是 字符串,完成 从 源字符串 到 目的字符串拷贝 功能
2.snprintf 函数操作的对象不限于字符串:虽然目的对象是字符串,但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现字符串或基本数据类型)向字符串的转换功能。如果源对象是字符串,并且指定 %s 格式符,也可实现字符串拷贝功能
3.memcpy 函数顾名思义就是 内存拷贝实现一个 内存块 的内容复制到另一个 内存块 这一功能。内存块由其首地址以及长度确定。程序中出现的实体对象,不论是什么类型,其最终表现就是在内存中占据一席之地(一个内存区间或块)。因此,memcpy 的操作对象不局限于某一类数据类型,或者说可 适用于任意数据类型,只要能给出对象的起始地址和内存长度信息、并且对象具有可操作性即可。鉴于 memcpy 函数等长拷贝的特点以及数据类型代表的物理意义,memcpy 函数通常限于同种类型数据或对象之间的拷贝,其中当然也包括字符串拷贝以及基本数据类型的拷贝

对于字符串拷贝来说,用上述三个函数都可以实现,但是其实现的效率和使用的方便程度不同:
strcpy 无疑是最合适的选择:效率高且调用方便。
• snprintf 要额外指定格式符并且进行格式转化,麻烦且效率不高。
• memcpy 虽然高效,但是需要额外提供拷贝的内存长度这一参数,易错且使用不便;并且如果长度指定过大的话(最优长度是源字符串长度 + 1),还会带来性能的下降。其实 strcpy 函数一般是在内部调用 memcpy 函数或者用汇编直接实现的,以达到高效的目的。因此,使用 memcpy 和 strcpy 拷贝字符串在性能上应该没有什么大的差别。
对于非字符串类型的数据的复制来说,strcpy 和 snprintf 一般就无能为力了,可是对 memcpy 却没有什么影响。但是,对于基本数据类型来说,尽管可以用 memcpy 进行拷贝,由于有赋值运算符可以方便且高效地进行同种或兼容类型的数据之间的拷贝,所以这种情况下 memcpy 几乎不被使用。memcpy 的长处是用来实现(通常是内部实现居多)对结构或者数组的拷贝,其目的是或者高效,或者使用方便,甚或两者兼有。
9.变量的声明和定义有什么区别?
10.请写出下面代码在 32 位平台上的运行结果,并说明 sizeof 的性质:
#include
#include

int main(void)
{
char a[30];
char *b = (char *)malloc(20 * sizeof(char));
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(b));
printf("%d\n", sizeof(a[3]));
printf("%d\n", sizeof(b+3));
printf("%d\n", sizeof(*(b+4)));
return 0 ;
}

12.请完成以下题目。注意,请勿直接调用 ANSI C 函数库中的函数实现
a)请编写一个 C 函数,该函数给出一个字节中被置 1 的位的个数,并请给出该题的至少一个不同解法。
第一种unsigned int TestAsOne0(char log)
{
int i;
unsigned int num=0, val;
for(i=0; i<8; i++)
{
val = log >> i; //移位
val &= 0x01; //与1相与
if(val)
num++;
}
return num;
}
第二种unsigned int TestAsOne1(char log)
{
int i;
unsigned int num=0, val;
for(i=0; i<8; i++)
{
val = (~log) >> i; //反码?
val &= 0x00; //与0相与
if(!val)
num++;
}
return num;
}
b)请编写一个 C 函数,该函数将给定的一个字符串转换成整数。
int Invert(char *str)
{
int num=0;
while(*str!='\0')
{
int digital=*str-48;
num=num*10+digital;
str=str+1;
}
return num;
}
c)请编写一个 C 函数,该函数将给定的一个整数转换成字符串
void IntToCharChange(int num, char* pval)
{
char strval[100];
int i, j;
int val0 = 0;
int val1 = 0;

val0 = num;
for(i=0; i<100; i++)
{
val1 = val0 % 10; //取余
val0 = val0 / 10; //取整
strval[i] = val1 + 48; //数字—字符
if(val0 < 10)
{
i++;
strval[i] = val0 + 48;
break;
}
}
for(j=0; j<=i; j++) //倒置
{
pval[j] = strval[i-j];
}
pval[j] = '\0';
}
d)请编写一个 C 函数,该函数将一个字符串逆序。
void AntitoneValue(char* father, char* child)
{
int i;
char source[100];
int j = 0;

while(father[j]) //放入source,[j]为长度
{
source[j] = father[j];
j++;
if(j > 99)
{
return;
}
}
source[j] = '\0';

for(i=0; i {
child[i] = source[j-i-1]; //反序
}
child[i] = '\0';
}

e)请编写一个 C 函数,该函数在给定的内存区域搜索给定的字符,并返回该字符所在位置索引值。
int search(char *cpSource, int n, char ch) //起始地址,搜索长度,目标字符
{
int i;
for(i=0; ireturn i;
}
f)请编写一个 C 函数,该函数在一个字符串中找到可能的最长的子字符串,该字符串是由同一字符组成的。
int ChildString(char*p) //自己写
{
Char *q=p;
int stringlen=0, i=0,j=1,len=0,maxlen=1;
while(*q!=’\0’) //不能用strlen,求得长度stringlen
{
Stringlen++;
q++;
}
while( i< Stringlen )
{
if(*(p+i)==*(p+j)&&j< Stringlen)
{
len++; //统计子串长度
i++;
j++;
}
else
{
if(len>maxlen) //统计最大子串长度
{
maxlen=len+1;
len=0;
}
else {
len=0;
}
i++;
j++;

}
}
return maxlen;
}
给出演示上述函数功能一个简单程序,并请编写对应的 Makefile 文件

……
……
……
……

21,497

社区成员

发帖
与我相关
我的任务
社区描述
汇编语言(Assembly Language)是任何一种用于电子计算机、微处理器、微控制器或其他可编程器件的低级语言,亦称为符号语言。
社区管理员
  • 汇编语言
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧