字符串拷贝方法以及存在陷阱

前言

在实际项目开发中，字符串拷贝是个很常见用法。方式有很多种，在我们使用过程中，一般不会出现什么问题，或者说是一般编译器不会编译报错，甚至运行报错。但一些潜在的陷阱是经常存在的，如在使用VS 2017开发时，会发现很多语法编译器检测会更严谨，以前如vs2010不会报错的，vs2017会编译不过，或编译成功了，运行报错。

废话：在刚参加工作时，觉得只要功能能实现，便是完成任务了。随着经验的积累，很多东西就喜欢去深究，去思考，为什么要这么用，这么用有什么好处，效率会不会更高，性能会不会更优。

好了，废话多说无益，下面正式开讨论今天的主题。

拷贝方式

字符串拷贝的方式有很多种，下面我主要说说memcpy、strcpy、string::copy这三种。

内存拷贝memcpy

函数原型

	void* __cdecl memcpy(
    _Out_writes_bytes_all_(_Size) void* _Dst,
    _In_reads_bytes_(_Size)       void const* _Src,
    _In_                          size_t      _Size
    );

简单点：

void *memcpy(void *dest, const void *src, size_t count);

参数这里不细说。

例子：

std::string CopyString(const std::string &strBody)
{
	int nLen = strBody.length();
	char *cBody = new char(nLen);
	memcpy(cBody, strBody.c_str(), nLen);
	std::cout << "FONCTION:" << cBody << std::endl;
	return cBody;
}

int main()
{
	std::string strBody = "This is a Test!";
	std::string strReturn = CopyString(strBody);
	std::cout << "MAIN:" << strReturn.c_str() << std::endl;
	system("pause");
	return 0;
}

上面函数，大多数情况下都不会出现报错的，但存在一个潜在陷阱。

陷阱

内存拷贝不会对字符串结束符'\0'进行检查

结果

拷贝结束后，在字符串末尾会出现乱码。

解决方案

申请内存时多申请一个字节内存，以保证将字符串结束符拷贝进去。

std::string CopyString(const std::string &strBody)
{
	int nLen = strBody.length();
	char *cBody = new char(nLen + 1);
	memcpy(cBody, strBody.c_str(), nLen + 1);
	std::cout << "FONCTION:" << cBody << std::endl;
	return cBody;
}

int main()
{
	std::string strBody = "This is a Test!";
	std::string strReturn = CopyString(strBody);
	std::cout << "MAIN:" << strReturn.c_str() << std::endl;
	delete strReturn.c_str();
	system("pause");
	return 0;
}

字符串拷贝strcpy

函数原型

char* __cdecl strcpy(
    _Out_writes_z_(_String_length_(_Source) + 1) char*       _Dest,
    _In_z_                                       char const* _Source
    );

简单点：

char *strcpy(char *dst, const char *src);

例子

std::string CopyString(const std::string &strBody)
{
	int nLen = strBody.length();
	char *cBody = new char(nLen);
	strcpy(cBody, strBody.c_str());
	std::cout << "FONCTION:" << cBody << std::endl;
	return cBody;
}

int main()
{
	std::string strBody = "This is a Test!";
	std::string strReturn = CopyString(strBody);
	std::cout << "MAIN:" << strReturn.c_str() << std::endl;
	delete strReturn.c_str();
	system("pause");
	return 0;
}

说明

strcpy是专用于字符串拷贝的函数，与memcpy的区别就是，它会检测结束符'\0'，所以在申请内存时不用做多余申请。

string方法拷贝string::copy

原型

	size_type copy(_Out_writes_(_Count) _Elem * const _Ptr,
		size_type _Count, const size_type _Off = 0) const
		{	// copy [_Off, _Off + _Count) to [_Ptr, _Ptr + _Count)
		auto& _My_data = this->_Get_data();
		_My_data._Check_offset(_Off);
		_Count = _My_data._Clamp_suffix_size(_Off, _Count);
		_Traits::copy(_Ptr, _My_data._Myptr() + _Off, _Count);
		return (_Count);
		}

还是简单点：

size_t copy (char* s, size_t len, size_t pos = 0) const;

这里解释一下这几个参数：
s
指向一组字符的指针。
该数组应包含足够的存储空间用于复制的字符。
len
要复制的字符数（如果字符串较短，则复制尽可能多的字符）。
pos
要复制的第一个字符的位置。
如果这大于字符串长度，则抛出out_of_range。
注意：字符串中的第一个字符由值0（不是1）表示。

例子

// string::copy
#include <iostream>
#include <string>

int main ()
{
  char buffer[20];
  std::string str ("This is a Test");
  std::size_t length = str.copy(buffer,6,5);
  std::cout << "buffer contains: " << buffer << '\n';
  return 0;
}

陷阱&结果

因为这里copy最终调用的函数仍然是memcopy，所以陷阱一样，拷贝完成后，会在字符串后面带上一串乱码

解决方案

在拷贝结束后，加上结束符'\0'。

// string::copy
#include <iostream>
#include <string>

int main ()
{
  char buffer[20];
  std::string str ("This is a Test");
  std::size_t length = str.copy(buffer,6,5);
  buffer[length]='\0';
  std::cout << "buffer contains: " << buffer << '\n';
  return 0;
}

这里还有一种方式，但是这种方式待讨论，因为我目前的结果是正确的。那就是在申请内存后，第一时间进行初始化，这样拷贝也不会出现乱码。
例如：

std::string CopyString(const std::string &strBody)
{
	char *cBody = NULL;
	int nLen = strBody.size();
	cBody = (char *)malloc(nLen);
	memset(cBody, 0, nLen);
	strBody.copy(cBody, nLen, 0);
	std::cout << "FONCTION:" << cBody << std::endl;
	return cBody;
}

int main()
{
	std::string strBody = "This is a Test!";
	std::string strReturn = CopyString(strBody);
	std::cout << "MAIN:" << strReturn.c_str() << std::endl;
	system("pause");
	return 0;
}

后语

在我们开发过程中，很多细节需要我们去推敲，不注意细节，不出问题倒好，一出问题，连问题都不好找，特别是在大型项目中。

转载于:https://www.cnblogs.com/SunkingYang/p/11049090.html