C标准库
 
#include<stddef.h>
#include<string.h>

#undef strcpy

#ifndef STRCPY
	#define STRCPY strcpy
#endif

/* 该函数是把src中的内容复制到dest中*/
char* STRCPY(char* dest,const char *src)
{
	return memcpy(dest,src,strlen(src) + 1);
}
 
 
#include<string.h>
#include<memcopy.h>

#undef memcpy

void *memcpy (void *dstpp, const void *srcpp, size_t len)
{
  unsigned long int dstp = (long int) dstpp;
  unsigned long int srcp = (long int) srcpp;

  /* Copy from the beginning to the end.  */

  /* If there not too few bytes to copy, use word copy.  */
  if (len >= OP_T_THRES)
    {
      /* Copy just a few bytes to make DSTP aligned.  */
      len -= (-dstp) % OPSIZ;
      BYTE_COPY_FWD (dstp, srcp, (-dstp) % OPSIZ);

      /* Copy whole pages from SRCP to DSTP by virtual address manipulation,
	 as much as possible.  */

      PAGE_COPY_FWD_MAYBE (dstp, srcp, len, len);

      /* Copy from SRCP to DSTP taking advantage of the known alignment of
	 DSTP.  Number of bytes remaining is put in the third argument,
	 i.e. in LEN.  This number may vary from machine to machine.  */

      WORD_COPY_FWD (dstp, srcp, len, len);

      /* Fall out and copy the tail.  */
    }

  /* There are just a few bytes to copy.  Use byte memory operations.  */
  BYTE_COPY_FWD (dstp, srcp, len);

  return dstpp;
}
 
 
重写实现
 
char* STRCPY(char* dest,const char *src)
{
	char *dst = dest;       //
	if(dest==NULL | src == NULL)
	{
		printf("\r\n输入的指针是空指针\r\n");
		return 0;
	}
	
	/*指针不断的增加，src不断的给dest赋值，直到把'\0'赋值给dest,跳出循环*/
	while((*dest++ = *src++)!='\0');
	return dst;
}

简单，但超级常考！！！！！！！！
 
  实现一个C语言的标准库函数：字符串拷贝 char* strcpy(char* dest, const char* src);
   strcpy 把含有 ‘\0’ 结束符的字符串复制到另一个地址空间，返回值的类型为char*。
 
  注意：src 和 dest 所指内存区域不可以重叠且 dest 必须有足够的空间来容纳 src 的字符串。
   实现如下：
 
char* strcpy(char* des, const char* source) {
	assert((des != nullptr) && (source != nullptr));
	char* r = des;
	while((*r++ = *source++) != '\0');
	return des;
}
 
  对于出现异常的情况 ANSI-C99 标准并未定义，故由实现者决定返回值，通常为NULL。实际调用如下：
 
#include <iostream>
#include <cassert>
using namespace std;

char* string_copy(char* des, const char* source) {
	assert((des != nullptr) && (source != nullptr));
	//cout << sizeof(des) << " " << sizeof(source) << endl;	// 4 4 (32位下指针大小)
	char* r = des;
	while ((*r++ = *source++) != '\0');
	return des;
}

int main() {
	char a[10] = "abcde", b[6];	// b 大小要 >= 6, 不然会崩
	//cout << sizeof(b) <<" "<< sizeof(a) << endl;	// 6 10
	string_copy(b, a);
	cout << b << endl;	// abcde
}
 
要注意的点
 
1、为什么要返回 char*
 
  返回 strDest 的原始值使函数能够支持链式表达式，也就是可以 int iLength=strlen(strcpy(strA,strB)); 或者 char * strA=strcpy(new char[10],strB);。
 
2、怎么保证传入的 char* 内存是够的？
 
  因为传入的是字符数组，数组名自动转换为指针类型，strlen 的话，也只能输出一个很奇怪的数，因为 strlen 遇到 ‘\0’ 才停；sizeof 也因为转换为指针了，会输出 4。所以没有想到什么好的办法判断，望赐教。
   上边的例子，因为字符串默认最后会添加 ‘\0’，所以 b数组至少要 6 的大小，否则会崩。

在编写C++程序时，不可避免会遇到strcpy()函数和其安全版本strcpy_s()函数，其实之所以会推出_s版本的函数，就是为了使编程更加安全，然而为了保证安全，也就会更容易使我们编写的代码“被报错”。所以这里来简略说一下strcpy()函数和strcpy_s()函数的使用及注意事项。
 
首先，我们知道原函数strcpy()函数和安全版本strcpy_s()函数都是存在于头文件<cstring>中的，所以程序一开始必须要有以下语句：
 
#include <cstring>
 
其次，原函数strcpy()函数是存在于标准名称空间std中的成员，所以要使用strcpy()函数，还需要加上以下语句：
 
using namespace std;
 
或者：
 
using std::strcpy;
 
或者在每次使用strcpy()函数时，前面加上名称空间：
 
std::strcpy(str1, str2);
 
但是对于最新的编辑器，往往你正常使用strcpy()函数，还是会报错，例如下面这个简单的例子：
 
// strcpy.cpp -- test the strcpy function and strcpy_s function

#include "stdafx.h"
#include <iostream>
#include <cstring>


int main()
{
    char str1[20];
    char str2[20];
    std::cout << "Please enter str2: ";
    std::cin.get(str2, 20);
    std::strcpy(str1, str2);
    std::cout << "str1 is " << "\" " << str1 << "\".\n";
    system("pause");
    return 0;
}
 
正常来说，语法上没有任何问题，但是运行时，Visual Studio 2017 会报错，显示如下：
 
 
意义很简单，就是告诉你，strcpy()函数不安全，必须改为使用strcpy_s()函数，首先不管改成strcpy_s()函数之后会发生什么后续问题，其实从理论上来说，上面的代码语法上和逻辑上来说都是对的，那么怎么避免编辑器强制要求你使用安全版本呢？
 
其实解决方法有很多，单单是避免上图中的错误代码4996的情况，可以使用编辑器的选择性提供warning功能，在include语句前面加上下句：
 
#pragma warning( disable : 4996)
 
但是这种解决方法有时候不能解决问题，例如VS2017我就试过好像不行，那么我们就索性关闭warning功能就好了，完成这个任务的方法是在#include<stdio.h>的前面加上一句，如下所示：
  
 
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
 
VS2017里面，这句应该是加在头文件“stdafx.h”里面。
 
加完之后，再次运行相同的程序，就可以正常运行了，显示结果如下图所示：
 
那么解决了不使用安全版本的问题，接下来就来说一下使用安全版本的情况。
 
如果我们选择相信编辑器，那么我们就会把strcpy()函数改成使用strcpy_s()函数，改完之后运行首先会遇到以下错误：
 
 
这是因为之前使用strcpy()函数时，我们知道该函数是标准名称空间std的成员，而安全版本strcpy_s并不是该名称空间的成员，所以“std::”应该被去掉，去掉之后再次运行，就会正常运行了。
 
但是有时候，编辑器在你去掉“std::”还是会出现错误，错误说明是：1.没有与参数列表匹配的 重载函数"strcpy_s"实例；2."strcpy_s":函数不接受2个参数。
 
如下图所示：
 
 
这是因为strcpy_s()函数是有两个版本，用两个参数、三个参数都可以，只要可以保证缓冲区大小。
 三个参数时：
 errno_t strcpy_s( 
 char *strDestination, 
 size_t numberOfElements, 
 const char *strSource 
 );
 两个参数时：
 errno_t strcpy_s( 
 char (&strDestination)[size], 
 const char *strSource 
 ); // C++ only 
 
所以，若我们使用new来分配储存空间时，就会出现上面说的不能保证缓冲区大小的问题了。
 
看下面的代码：
  
 
char * str;
str = new char[4];
strcpy_s(str, "C++");
 
语法来说没有什么问题，但是因为str的储存空间是使用new临时分配的，所以并不能保证缓冲区大小，点击运行就会出现上述的两种错误了。
 
这种情况的解决方法其实很简单，那就是不符合2个参数的版本就使用3个参数的版本呗。在两个str之间，加上一个参数，标识长度。
 
所以完整代码如下：
 
// strcpy.cpp -- test the strcpy function and strcpy_s function

#include "stdafx.h"
#include <iostream>
#include <cstring>


int main()
{
    char str1[20];
    char str2[20];
    std::cout << "Please enter str2: ";
    std::cin.get(str2, 20);
    strcpy_s(str1, str2);
    std::cout << "str1 is " << "\"" << str1 << "\".\n";
    char * str;
    str = new char[20];
    strcpy_s(str, strlen(str1)+1, str1);
    std::cout << "str is " << "\"" << str << "\".\n";
    system("pause");
    return 0;
}
 
这里分别使用了2个参数和3个参数的strcpy_s()函数版本。
 
后面使用3个参数的版本时，一般的做法就是将长度定为被复制的字符串长度+1，因为strlen()返回字符串长度，但是不包括字符串末尾的空字符，所以+1。
 
上述代码运行结果如下图所示：
 
 
以上就是strcpy()函数和strcpy_s()函数的基本使用和注意事项了，希望对大家有所帮助~

strcpy简单使用： 
 
#include <stdio.h>
#include <string.h>

struct Student {
	int sid;
	char name[20];
	int age;

} st;  //此处分号不可省略

int main(void) {

	struct Student st = {1000,"zhangsan",20};

	printf("%d  %s  %d\n", st.sid, st.name, st.age);

	st.sid = 500;
	// st.name="lisi"  //error
	strcpy(st.name,"lisi");
	st.age=20;

	while(true){}

}
 
 
 
头文件：#include <string.h> 和 #include <stdio.h>
 
功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间
 
说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。返回指向dest的指针。
 
//C语言标准库函数strcpy的一种典型的工业级的最简实现。 
//返回值：目标串的地址。
//对于出现异常的情况ANSI-C99标准并未定义，故由实现者决定返回值，通常为NULL。
//参数：des为目标字符串，source为原字符串。
char* strcpy(char* des,const char* source) {　
 char* r=des;    
 assert((des != NULL) && (source != NULL));
while((*r++ = *source++)!='\0');　
  return des;　
}
//while((*des++=*source++));的解释：赋值表达式返回左操作数，所以在赋值'\0'后，循环停止。
 
举例： 
 
char a[10],b[]={"COPY"};
//定义字符数组a,b
strcpy(a,b);
//将b中的COPY复制到a中
 
Strcpy函数中的缓冲区溢出问题和防范
 
C 语言和 C++语言风格轻松、灵活，语法限制宽松，因而受到各类程序员的欢迎，是比较通用的编程语言，同时也是各大院校计算机专业的基本语言课程。strcpy 函数由于不对数组边界进行检查，而非常容易造成各种缓冲区溢出的漏洞。这些漏洞很容易被利用，而造成严重的系统问题。在使用 strcpy 函数时，要小心谨慎。
 以下就 Strcpy 函数中的缓冲区溢出问题和防范进行讨论。 [1] 
 
 
缓冲区溢出问题
 
缓冲区的溢出就是程序在动态分配的缓冲区中写入了太多的数据，使这个分配区发生了溢出。一旦一个缓冲区利用程序能将运行的指令放在有 root权限的内存中，运行这些指令，就可以利用 root 权限来控制计算机了。 [1] 
 
 
Strcpy函数的安全编码
 
在编程时，加入错误检查，就可及时发现错误，并且对出现的异常进行处理。在编写 strcpy 函数时，首先尽量使目的缓冲区长度足够长，另外要检测目的缓冲区和源缓冲区。如果目的缓冲区或源缓冲区是空，就要在异常处理中结束程序。如果，源字符串比目的缓冲区长度不长，也要在异常处理中结束程序，以防止出现溢出情况。任何程序都很难说是绝对安全，只能以尽可能安全的方式来处理 strcpy 函数。只要输入的字符串不以空字符结束，函数就会随时终止。这种检测容易实现。但是这样的检测也并不能确定函数一定安全。 [1] 
 
另外，每添加一个错误检查，就会使程序更复杂，而且可能产生很多的 bug，增加很多的工作量。最重要的是，即使设计程序时非常仔细，也有可能会忽略一些细节问题，导致不可弥补的错误。所以，在编写程序时，最安全的方法，就是尽可能不去使用 strcpy 函数。可以在程序的开头加上 #define strcpy Unsafe_strcpy。这样，就会使 strcpy 函数在编译时产生错误，从而使我们在编程时可以完全摒弃strcpy 函数。在完全丢弃 strcpy 函数的同时，也就丢掉了众多依附于 strcpy 函数的 bug。 [1]
 
特例说明
 
已知strcpy函数的原型是：
 
char * strcpy(char * strDest,const char * strSrc);
 
1.不调用库函数，实现strcpy函数。
 
2.解释为什么要返回char *。
 
 
不调用库函数如何实现strcpy函数
 
strcpy的实现代码
 
char * strcpy(char * strDest,const char * strSrc){
if ((NULL==strDest) || (NULL==strSrc)) 
  //[1]
  throw "Invalid argument(s)"; 
  //[2]
  char * strDestCopy = strDest; 
  //[3]
  while ((*strDest++=*strSrc++)!='\0'); 
  //[4]
  return strDestCopy;
}
 
错误的做法[1]：
 
(A）不检查指针的有效性，说明答题者不注重代码的健壮性。
 
（B）检查指针的有效性时使用（（！strDest)||(!strSrc））或（！（strDest&&strSrc）），说明答题者对C语言中类型的隐式转换没有深刻认识。在本例中char *转换为bool即是类型隐式转换，这种功能虽然灵活，但更多的是导致出错概率增大和维护成本升高。所以C++专门增加了bool、true、false三个关键字以提供更安全的条件表达式。
 
（C）检查指针的有效性时使用（（strDest==0)||(strSrc==0）），说明答题者不知道使用常量的好处。直接使用字面常量（如本例中的0）会减少程序的可维护性。0虽然简单，但程序中可能出现很多处对指针的检查，万一出现笔误，编译器不能发现，生成的程序内含逻辑错误，很难排除。而使用NULL代替0，如果出现拼写错误，编译器就会检查出来。
 
错误的做法[2]：
 
（A)return new string("Invalid argument(s)")；，说明答题者根本不知道返回值的用途，并且他对内存泄漏也没有警惕心。从函数中返回函数体内分配的内存是十分危险的做法，他把释放内存的义务抛给不知情的调用者，绝大多数情况下，调用者不会释放内存，这导致内存泄漏。
 
（B)return 0；，说明答题者没有掌握异常机制。调用者有可能忘记检查返回值，调用者还可能无法检查返回值（见后面的链式表达式）。妄想让返回值肩负返回正确值和异常值的双重功能，其结果往往是两种功能都失效。应该以抛出异常来代替返回值，这样可以减轻调用者的负担、使错误不会被忽略、增强程序的可维护性。
 
错误的做法[3]：
 
（A）忘记保存原始的strDest值，说明答题者逻辑思维不严密。
 
错误的做法[4]：
 
（A）循环写成while (*strDestCopy++=*strSrc++）；，同[1]（B）。
 
（B）循环写成while (*strSrc!='\0') *strDest++=*strSrc++；，说明答题者对边界条件的检查不力。循环体结束后，strDest字符串的末尾没有正确地加上'\0'。
 
 
解释为什么要返回char *
 
返回strDest的原始值使函数能够支持链式表达式，增加了函数的“附加值”。同样功能的函数，如果能合理地提高的可用性，自然就更加理想。
 
链式表达式的形式如：
 
int iLength=strlen(strcpy(strA,strB));
 
又如：
 
char * strA=strcpy(new char[10],strB);
 
返回strSrc的原始值是错误的。其一，源字符串肯定是已知的，返回它没有意义。其二，不能支持形如第二例的表达式。其三，为了保护源字符串，形参用const限定strSrc所指的内容，把const char *作为char *返回，类型不符，编译报错。
 
在上面的语句中，循环语句
 
while ((*strDestCopy++=*strSrc++)!='\0'）;
 
较难理解，可以把这句理解为以下操作。
 
第一种：
 
while( 1 ){    
  char temp;    
  *strDestCopy = *strSrc;  
  temp = *strSrc; 
  strDestCopy++;    
  strSrc++;   
  if( '\0' == temp )      
  break;
}
 
 第二种：
 
while ( *strSrc != '\0' ){
   *strDestCopy = *strSrc;
   strDestCopy++;
   strSrc++;
}
 
*strDestCopy = *strSrc;
   
也即：
 
while ( *strSrc != '\0' ){
   *strDestCopy++ = *strSrc++; 
}
 
*strDestCopy=‘\0’;
 
使用实例
 
//实例1：将一个字符串拷贝到一个足够长的字符数组中。本例中字符数组为a，长度为20。
 
//缺点：若数组长度不足以容纳整个字符串，则程序运行崩溃。
 
#include<iostream>
#include<stdlib.h> 

using namespace std; 
char * strcpy( char * strDest, const char * strSrc ){  
  char * strDestCopy = strDest;  
  if ((NULL==strDest)||(NULL==strSrc))throw "Invalid argument";
    while ( (*strDest++=*strSrc++) != '\0' );
    return strDestCopy; 
}
  
int main( int argc, char * argv[] ){   
  char a[20], c[] = "i am teacher!";  
  try{   
       strcpy(a,c);
  }catch(char* strInfo){
       cout << strInfo << endl;
     exit(-1);
  }
   
  cout << a << endl;
  return 0;
 
}
 
//实例2：预设两个字符指针，一个指向字符串，另一个为NULL，在程序运行过程中拷贝。
 
#include<iostream> 
using namespace std;
 
char *strcpy(char *strDes, const char *strSrc);
//函数声明
 
int main(){   
  const char *strSrc="helloworld";
  char *strDes=NULL;   
  strDes=strcpy(strDes,strSrc);   
  cout<<"strSrc="<<strSrc<<endl;   
  cout<<"strDes="<<strDes<<endl;   
  if(strDes!=NULL) { 
     free(strDes);
     strDes=NULL; 
  }    
  return 0; 
}
 
char *strcpy(char *strDes, const char *strSrc){   
  assert(strSrc!=NULL); 
  //若strSrc为NULL，则抛出异常。  
  strDes=(char *)malloc(strlen(strSrc)+1);
  //多一个空间用来存储字符串结束符'\0'   
  char *p=strDes;   
  while(*strSrc!='\0'){    
    *p++=*strSrc++;
  }
    
  *p='\0';  
 return strDes;
 
}
 
还有一种模拟算法：
 
char * strcpy(char *dest ,const char *src){
    char *p=dest;
    while (*src != '\0'){
        *dest = *src;
        dest++;src++;
    }
    *dest = '\0';
    return p;
}
 
与strncpy的区别
 
第一种情况：
 
char* p="how are you ?";   
char name[20]="ABCDEFGHIJKLMNOPQRS";  
    strcpy(name,p);
    //name改变为"how are you ? "====>正确！
    strncpy(name,p, sizeof(name));
    //name改变为"how are you ?" =====>正确！后续的字符将置为NULL
 
第二种情况：
 
  char* p="how are you ?";
    char name[10];
    strcpy(name,p);
    //目标串长度小于源串,错误！
    name[sizeof(name)-1]='\0';
    //和上一步组合，弥补结果，但是这种做法并不可取，因为上一步出错处理方式并不确定
    strncpy(name,p,sizeof(name));
    //源串长度大于指定拷贝的长度sizeof(name)，注意在这种情况下不会自动在目标串后面加'\0'
    name[sizeof(name)-1]='\0'; 
    //和上一步组合，弥补结果