错误 C4996 'strcpy': This function or variable may be unsafe. Consider using 的解决（基于visual studio2017）

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

using namespace std;
#define use_CRT_SECURE_NO_WARNINGS
// String 类定义
class String
{
public:
	String();                             // 默认构造函数
	String(const char *content);          // 带参数的构造函数
	String(const String &cstr);           // 拷贝构造函数
	~String();                            // 析构函数
	void set(const char *content);        // 设置字符串内容
	void get(char *&dest) const;          // 获取字符串内容
	int length() const;                   // 获取字符串长度
	void print() const;                   // 打印字符串内容
	String& operator=(const String &cstr);// 重载赋值运算符=
	char& operator[](int index);          // 重载下标运算符[]，实现获取字符串中某个指定位置的字符
	String operator+(const String &cstr); // 重载加法运算符+，实现两个字符串的拼接
	String operator+(const char *cstr);   // 重载加法运算符+，实现字符串和字符指针的拼接
	String operator+(char ch);            // 重载加法运算符+，实现字符串和单个字符的拼接
	String operator-();                   // 重载负号运算符-，实现字符串中字符的逆序排列
										  // 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
	String& operator++();                 // 前置自增
	String operator++(int);               // 后置自增
										  // 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
	String& operator--();                 // 前置自减
	String operator--(int);               // 后置自减
protected:
	char *str;                            // 指向存放字符串内容的字符指针
};

// String 类成员函数实现

// 默认构造函数
String::String()
{
	str = NULL;                           // 空串
}

// 带参数的构造函数
String::String(const char *content)
{
	int len = strlen(content);
	str = new char[len + 1];
	strcpy(str, content);
}

// 拷贝构造函数
String::String(const String &cstr)
{
	str = new char[cstr.length() + 1];
	strcpy(str, cstr.str);
}

// 析构函数
String::~String()
{
	if (str != NULL)
		delete[] str;
}

// 设置字符串内容
void String::set(const char *content)
{
	if (str != NULL)
		delete[] str;                    // 释放旧空间
	int len = strlen(content);
	str = new char[len + 1];                // 申请新空间
	strcpy(str, content);
}

// 获取字符串内容
void String::get(char *&dest) const
{
	int len = strlen(str);
	dest = new char[len + 1];
	strcpy(dest, str);
}

// 获取字符串长度
int String::length() const
{
	return strlen(str);
}

// 打印字符串内容
void String::print() const
{
	cout << str << endl;
}

// 重载赋值运算符
String& String::operator=(const String &cstr)
{
	if (str != NULL)
		delete[] str;                       // 释放旧空间
	str = new char[cstr.length() + 1];         // 申请新空间
	strcpy(str, cstr.str);
	return *this;
}

// 重载下标运算符[]，实现获取字符串中某个指定位置的字符
char& String::operator[](int index)
{
	return str[index];
}

// 重载加法运算符+，实现两个字符串的拼接
String String::operator+(const String &cstr)
{
	String result;
	int len = length() + cstr.length();
	result.str = new char[len + 1];
	strcpy(result.str, str);
	strcpy(result.str + length(), cstr.str);
	return result;
}

// 重载加法运算符+，实现字符串和字符指针的拼接
String String::operator+(const char *cstr)
{
	String result;
	int len = length() + strlen(cstr);
	result.str = new char[len + 1];
	strcpy(result.str, str);
	strcpy(result.str + length(), cstr);
	return result;
}

// 重载加法运算符+，实现字符串和单个字符的拼接
String String::operator+(char ch)
{
	String result;
	int len = length() + 1;
	result.str = new char[len + 1];
	strcpy(result.str, str);
	result.str[length()] = ch;
	result.str[length() + 1] = '\0';
	return result;
}

// 重载负号运算符-，实现字符串中字符的逆序排列
String String::operator-()
{
	String result;
	result.str = new char[length() + 1];
	for (int i = 0; i<length(); ++i)
		result.str[i] = str[length() - 1 - i];
	result.str[length()] = '\0';
	return result;
}

// 重载自增运算符++，实现将字符串中的小写字母转换成大写字母
// 前置自增
String& String::operator++()
{
	for (int i = 0; i<length(); ++i)
		if (str[i] >= 'a'&&str[i] <= 'z')
			str[i] = str[i] - ('a' - 'A');
	return *this;                                // 返回类自身
}

// 后置自增
String String::operator++(int)
{
	String result(str);
	for (int i = 0; i<length(); ++i)
		if (str[i] >= 'a'&&str[i] <= 'z')
			str[i] = str[i] - ('a' - 'A');
	return result;                               // 返回旧值
}

// 重载自减运算符--，实现将字符串中的大写字母转换成小写字母
// 前置自减
String& String::operator--()
{
	for (int i = 0; i<length(); ++i)
		if (str[i] >= 'A'&&str[i] <= 'Z')
			str[i] = str[i] + ('a' - 'A');
	return *this;                               // 返回类自身
}

// 后置自减
String String::operator--(int)
{
	String result(str);
	for (int i = 0; i<length(); ++i)
		if (str[i] >= 'A'&&str[i] <= 'Z')
			str[i] = str[i] + ('a' - 'A');
	return result;                             // 返回旧值
}

int main()
{
	String str1;                               // 字符串对象（空串）
	String str2("Programming ");               // 字符串对象（非空串）
	str1.set("C++ ");                          // 设置字符串内容

	String str = str1 + str2;                  // 调用重载加法运算符
	str = str + "Language";                    // 调用重载加法运算符
	str = str + '!';                           // 调用重载加法运算符
	str.print();

	++str;                                     // 调用重载自增运算符
	str.print();
	--str;                                     // 调用重载自减运算符
	str.print();
	str = -str;                                // 调用重载负号运算符
	str.print();

	str[0] = '+';                              // 调用重载下标运算符
	str.print();
	system("pause");
	return 0;
}

这个程序是比较基础的题目，主要考察重载的运用，然而在执行过程中，报错。

严重性	代码	说明	项目	文件	行	禁止显示状态
错误	C4996	'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.	

这个问题的解决办法为在头文件下面加一行

#pragma warning(disable:4996)

编辑完成后的头文件为

#include "stdafx.h"
#include <iostream>
#include <cstring>
#pragma warning(disable:4996)
using namespace std;

这样操作后，就不会有以上问题。

但是，会弹出另外一个错误

严重性	代码	说明	项目	文件	行	禁止显示状态
错误	LNK1168	无法打开 	

目前我还不知道这个是什么原因，希望有明白人给我留言，谢谢。

补充：在c++预编译器下预编译定义下，新加一条

_CRT_SECURE_NO_WARNINGS

亲测可用。