Question

C语言自己写strcpy函数怎么写

Answer 1

#include <stdio.h>
#define LEN 1024
/* copy */
static void *memcpy(void *d, const void * s, size_t n);
static void *memmove(void *d, const void *s, size_t n);
static char *strcpy(char *d, const char *s);
static char *strncpy(char *d, const char *s, size_t n);
/* link */
static char *strcat(char *s1, const char *s2);
static char *strncat(char *s1, const char *s2, size_t n);
/* len*/
static size_t strlen(const char *s);
/* cmp */
int strcmp(const char *s1, const char *s2);
int strncmp(const char *s1, const char *s2, size_t n);
int memcmp(const void *s1, const void *s2, size_t n);
/* find */
void *memchr(const void *s, int key_char, size_t n);
char *strchr(const char *s, int key_char);
char *strstr(const char *s, const char *key_str);
size_t strcspn(const char *s1, const char *s2);
size_t strspn(const char *s1, const char *s2);
char *strpbrk(const char *s1, const char *s2);
/* other */
char *strtok(char *s1, const char *s2);
void *memset(void *s, int c, size_t n);
int main(void)
{
char buf[LEN] ;
char *src = "world";
char *ss = "oucch";

printf("strlen -> src[len] = %d\n", strlen(src));
printf("memcpy ->%s\n", (char *)memcpy(buf, src, strlen(src) + 1));
printf("buf -> %s\n", buf);
printf("memmove->%s\n", (char *)memmove(buf + 3,buf, strlen(buf) + 1));
printf("buf -> %s\n", buf);
printf("strcpy -> %s\n", strcpy(buf, src));
printf("buf -> %s\n", buf);
printf("strncpy -> %s\n", strncpy(buf, ss, 1));
printf("buf -> %s\n", buf);
printf("strcat -> %s\n", strcat(buf, src));
printf("buf -> %s\n", buf);
printf("strncat-> %s\n", strncat(buf, src, 1));
printf("buf -> %s\n", buf);
printf("strcmp : %d\n", strcmp("123", "1234"));
printf("strncmp : %d\n", strncmp("123", "1234", 3));
printf("strncmp : %d\n", strncmp("123", "1234", 5));
printf("memcmp: %d\n", memcmp("123", "1235", 4));
printf("strcspn: %d\n" ,strcspn("wangtianqing", "ang"));

return 0;}
static void * memcpy(void *d, const void *s, size_t n)
{
char *d1;
const char *s1;

for(d1 = d, s1 = s; 0 < n; --n)
*d1++ = *s1++;
return (d);
}
static void *memmove(void *d, const void *s, size_t n)
{
char *d1;
const char *s1;

d1 = d;
s1 = s;
if (s1 < d1 && s1 < d1 + n)
for(s1 += n, d1 +=n; 0 < n; --n)
*--d1 = *--s1;
else
for(; 0 < n; --n)
*d1++ = *s1++;
return (d);
}
static char *strcpy(char *d, const char *s)
{
char *d1;
const char *s1;

for(d1 = d, s1 = s; (*d1++ = *s1++) != '\0';)
;
return (d);
}
static char *strncpy(char *d, const char *s, size_t n)
{
char *d1;
const char *s1;

for(d1 = d, s1 = s; 0 < n && *s1 != '\0'; --n) {
*d1++ = *s1++;
}
for(; 0 < n; --n)
*d1++ = '\0';
return (d);
}
static size_t strlen(const char *s)
{
const char *s1;

for(s1 = s; *s1 != '\0'; ++s1)
;
return (s1 - s);
}
static char *strcat(char *s1, const char *s2)
{
char *st1;
const char *st2;

for(st1 = s1 ; *st1 != '\0'; ++st1)
;
for(st2 = s2; (*st1++ = *st2++) != '\0';)
;
return (s1);
}
static char *strncat(char *s1, const char *s2, size_t n)
{
char *st1;
const char *st2;

for(st1 = s1; *st1 != '\0'; ++st1)
;
for(st2 = s2; 0 < n && (*st1++ = *st2++) != '\0'; --n)
;
return (s1);
}
int strcmp(const char *s1, const char *s2)
{
for(; *s1 == *s2; ++s1, ++s2)
if(*s1 == '\0')
return (0);
return ((*(unsigned char *) s1 < *(unsigned char *) s2 ) ? -1: +1);
}
int strncmp(const char *s1, const char *s2, size_t n)
{
for(; 0 < n && *s1 == *s2; ++s1, ++s2)
if( *s1 == '\0')
return (0);
return (*(unsigned char *) s1 > *(unsigned char *) s2 ? -1 : +1);
}
int memcmp(const void *s1, const void *s2, size_t n)
{
const unsigned char *st1;
const unsigned char *st2;

for(st1 = s1, st2 = s2; 0 < n; ++st1, ++st2, --n)
if( *st1 != *st2)
return (*st1 < *st2 ? -1 : +1);
return 0;
}
void *memchr(const void *s, int key_char, size_t n)
{
const unsigned char uc = key_char;
const unsigned char *us;

for( us = s; 0 < n; --n, ++us)
if( uc == *us)
return ((void *)us);
return (NULL);
}
char *strchr(const char *s, int key)
{
const char *s1 = s;

for(; *s1 != '\0'; ++s1)
if(*s1 == key)
return ((char *)s1);
return (NULL);
}

size_t strcspn(const char *s1, const char *s2)
{
const char *sc1, *sc2;

for(sc1 = s1; *sc1 != '\0'; ++sc1)
for(sc2 = s2; *sc2 != '\0'; ++sc2)
if(*sc1 == *sc2)
return (sc1 - s1);
return (sc1 - s1);
}
size_t strspn(const char *s1, const char *s2)
{
const char *sc1;
const char *sc2;

for(sc1 = s1; *sc1 != '\0'; ++sc1) {
for(sc2 = s2; *sc2 != '\0'; ++sc2)
if(*sc1 == *sc2)
break;
if(*sc2 == '\0')
return (sc1 - s1);
}
return (sc1 - s1);
}
char *strpbrk(const char *s1, const char *s2)
{
const char *sc1, *sc2;

for( sc1 = s1; *sc1 != '\0'; ++sc1)
for( sc2 = s2; *sc2 != '\0'; ++sc2)
if (*sc1 == *sc2)
return ((char *)sc1);
return (NULL);
}
char *strstr(const char *s, const char *key_str)
{
if (*key_str == '\0')
return ((char *) s);
for(; (s = strchr(s, *key_str)) != NULL; ++s) {
const char *sc1, *sc2;

for (sc1 = s, sc2 = key_str; ;) {
if( *++sc2 == '\0')
return ((char *)s);
else if( *++sc1 != *sc2)
break;
}

}
return (NULL);
}
char *strtok(char *s1, const char *s2)
{
char *sbegin, *send;
static char *ssave = "";

sbegin = s1 ? s1 : ssave;
sbegin += strspn(sbegin, s2);
if( *sbegin == '\0') {
ssave = "";
return (NULL);
}
send = sbegin + strcspn(sbegin, s2);
if( *send != '\0')
*send++ = '\0';
ssave = send;
return sbegin;
}
void *memset(void *s, int c, size_t n)
{
const unsigned char uc = c;
unsigned char *su;

for( su = s; 0 < n; ++su, --n)
*su = uc;
return (s);
}

所有的函数原型都在这了 你想要哪个都行
谢谢采纳

Answer 2

楼主听我细细说，这个简单,我给你写的这个比普通的strcpy还多了一个功能呢，那就是多了的话，自动截取那么源字符串那么长的子串放入源字符串。
char * strcpy(char *to, char *from)
{
char *tmpTo = to, *tmpFrom = from;

if(from == NULL || to == from)
{
return to;
}

int counter = 0;
while(counter < strlen(to) && *tmpFrom != '\0')
{
*tmpTo++ = *tmpFrom++;
counter++;

}

*tmpTo = '\0';

return to;
}

Answer 3

#include <stdio.h>
void strcopy(char *p,char *q) //这个是 copy函数
{
int i;
for(i=0;p[i]&&q[i];i++)
p[i]=q[i];
p[i]='\0';
}
int main()
{
char a[10],b[10];
printf("请输入一行字符:");
scanf("%s",a);
strcopy(b,a);
printf("a=%s\n",a);
printf("b=%s\n",b);
return 0;
}

Answer 4

void _strcpy(char *s, char *t)
{
while(*s++=*t++)
;
}