65,186
社区成员
发帖
与我相关
我的任务
分享关于使用strcat_s出错的问题
为何以下程序运行时出错，而不是根据返回值输出对应的语句？很郁闷。
#include <iostream>
#include <cstring>
#include <cerrno> // This is included in <iostream>
using namespace std;
int main( )
{
/*
Joining Null-terminated Strings
*/
const size_t count{ 11 };
char str1[count]{"Many hands"};
const char* str2{ " make light work." };
errno_t error{ strcat_s(str1, str2) };
if (0 == error)
cout << "Strings joined successfully.\n"
<< str1 << endl;
else if (EINVAL == error)
cout << "Error! Source or destination string address is a null pointer."
<< endl;
else if (ERANGE == error)
cout << "Error! Destination string too small." << endl;
return 0;
}
...全文
请发表友善的回复…
发表回复
赵4老师 2015-03-31
- 打赏
- 举报
别人说我只会拷贝粘贴MSDN，事实确实如此。
If strDestination is a null pointer, or is not null-terminated, or if strSource is a NULL pointer, or if the destination string is too small, the invalid parameter handler is invoked, as described in Parameter Validation . If execution is allowed to continue, these functions return EINVAL and set errno to EINVAL.
In C++, using these functions is simplified by template overloads; the overloads can infer buffer length automatically (eliminating the need to specify a size argument) and they can automatically replace older, non-secure functions with their newer, secure counterparts. For more information, see Secure Template Overloads.
Parameter Validation
See Also Send Feedback
Most of the security-enhanced CRT functions and many of the preexisting functions validate their parameters. This could include checking pointers for NULL, checking that integers fall into a valid range, or checking that enumeration values are valid. When an invalid parameter is found, the invalid parameter handler is executed.
Invalid Parameter Handler Routine
The behavior of the C Runtime when an invalid parameter is found is to call the currently assigned invalid parameter handler. The default invalid parameter invokes Watson crash reporting, which causes the application to crash and asks the user if they want to load the crash dump to Microsoft for analysis. In Debug mode, an invalid parameter also results in a failed assertion.
This behavior can be changed by using the function _set_invalid_parameter_handler to set the invalid parameter handler to your own function. If the function you specify does not terminate the application, control is returned to the function that received the invalid parameters, and these functions will normally cease execution, return an error code, and set errno to an error code. In many cases, the errno value and the return value are both EINVAL, indicating an invalid parameter. In some cases, a more specific error code is returned, such as EBADF for a bad file pointer passed in as a parameter. For more information on errno, see errno, _doserrno, _sys_errlist, and _sys_nerr.
See Also
Concepts
Security Enhancements in the CRT
C Run-Time Libraries
_set_invalid_parameter_handler
Example See Also Send Feedback
Sets a function to be called when the CRT detects an invalid argument.
_invalid_parameter_handler _set_invalid_parameter_handler(
_invalid_parameter_handler pNew
);
Parameters
[in] pNew
The function pointer to the new invalid parameter handler.
Return Value
A pointer to the invalid parameter handler before the call.
Remarks
Many C run-time functions check the validity of arguments passed to them. If an invalid argument is passed, the function can set the errno error number or return an error code. In such cases, the invalid parameter handler is also called. This function allows that handler to be set to another function. Only one function can be specified as the invalid argument handler at a time.
The invalid parameter handler function must have the following prototype:
Copy Code
void _invalid_parameter(
const wchar_t * expression,
const wchar_t * function,
const wchar_t * file,
unsigned int line,
uintptr_t pReserved
);
The first argument is the argument expression
Secure Template Overloads
See Also Send Feedback
Many CRT functions have been deprecated in favor of newer, security-enhanced versions (for example, strcpy_s is the more secure replacement for strcpy). The CRT provides template overloads to help ease the transition to the more secure variants.
For example, this code generates a warning because strcpy is deprecated:
char szBuf[10];
strcpy(szBuf, "test"); // warning: deprecated
You can ignore the warning, define the symbol _CRT_SECURE_NO_WARNINGS to suppress the warning, or update the code to use strcpy_s:
char szBuf[10];
strcpy_s(szBuf, 10, "test"); // security-enhanced _s function
The template overloads provide additional choices. Defining _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES to be 1 enables template overloads of standard CRT functions that call the more secure variants automatically. If _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES is 1, then no changes to the code are necessary. Behind the scenes, the call to strcpy will be changed to a call to strcpy_s with the size argument supplied automatically.
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
...
char szBuf[10];
strcpy(szBuf, "test"); // ==> strcpy_s(szBuf, 10, "test")
_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES does not affect the functions that take a count, such as strncpy. To enable template overloads for the count functions, define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT to be 1. Before doing so, however, make sure that your code passes the count of characters, not the size of the buffer (a common mistake). Also, code that explicitly writes a null terminator at the end of the buffer after the function call is unnecessary if the secure variant is called. If you need truncation behavior, see _TRUNCATE.
Defining _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES to be 1 enables template overloads of the secure variants (names ending in "_s"). In this case, if _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES is 1, then one small change must be made to the original code:
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1
...
char szBuf[10];
strcpy_s(szBuf, "test"); // ==> strcpy_s(szBuf, 10, "test")
Only the name of the function needs to be changed (by adding "_s"); the template overload will take care of providing the size argument.
By default, _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES and _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT are defined as 0 (disabled) and _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES is defined as 1 (enabled).
Note that these template overloads only work for static arrays. Dynamically allocated buffers require additional source code changes. Revisiting the above examples:
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
...
char *szBuf = (char*)malloc(10);
strcpy(szBuf, "test"); // still deprecated; have to change to
// strcpy_s(szBuf, 10, "test");
And this:
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1
...
char *szBuf = (char*)malloc(10);
strcpy_s(szBuf, "test"); // doesn't compile; have to change to
// strcpy_s(szBuf, 10, "test");
See Also
Concepts
Security Enhancements in the CRT
C Run-Time Libraries
Send feedback on this topic to Microsoft.
赵4老师 2015-03-31
- 打赏
- 举报
额，话说赵老师没必要引用这么多东西来影响版面吧？我的VS有帮助文件的。话说不是有这样的一个strcat_s版本吗？
errno_t strcat_s(
char (&strDestination)[size],
const char *strSource
); // C++ only
那么这个版本怎么用？我1楼给的那个例子为何在目标字符数组的维数不够的时候产生运行时错误？关键是我的代码完全是从书上抄的呀！还是说这个版本的返回值其实没有任何意义？[/quote]
暴露出楼主不会使用引用，不知道引用即别名。
最主要是不会观察！
理解和讨论之前请先学会如何观察！
计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……
对学习编程者的忠告：
多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步Debug版对应汇编一行！
单步Debug版对应汇编千行不如单步Release版对应汇编一行！
单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。
VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）
理解和讨论之前请先学会如何观察！
计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……
对学习编程者的忠告：
多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！
眼过千遍不如手过一遍！
书看千行不如手敲一行！
手敲千行不如单步一行！
单步源代码千行不如单步Debug版对应汇编一行！
单步Debug版对应汇编千行不如单步Release版对应汇编一行！
单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。
VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。
对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。
（Turbo C或Borland C用Turbo Debugger调试,Linux或Unix下用GDB调试时,看每句C对应的汇编并单步执行观察相应内存和寄存器变化。）
哈利_蜘蛛侠 2015-03-30
- 打赏
- 举报
甚至，在代码的main函数前面加上
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1
运行的时候还是会出现一样的问题
哈利_蜘蛛侠 2015-03-30
- 打赏
- 举报
额，话说赵老师没必要引用这么多东西来影响版面吧？我的VS有帮助文件的。话说不是有这样的一个strcat_s版本吗？
errno_t strcat_s(
char (&strDestination)[size],
const char *strSource
); // C++ only
那么这个版本怎么用？我1楼给的那个例子为何在目标字符数组的维数不够的时候产生运行时错误？关键是我的代码完全是从书上抄的呀！还是说这个版本的返回值其实没有任何意义？
赵4老师 2015-03-24
- 打赏
- 举报
strncat_s, _strncat_s_l, wcsncat_s, _wcsncat_s_l, _mbsncat_s, _mbsncat_s_l
Example See Also Send Feedback
Append characters to a string. These are versions of strncat_s, _strncat_s_l, wcsncat_s, _wcsncat_s_l, _mbsncat_s, _mbsncat_s_l with security enhancements as described in Security Enhancements in the CRT.
errno_t strncat_s(
char *strDest,
size_t numberOfElements,
const char *strSource,
size_t count
);
errno_t _strncat_s_l(
char *strDest,
size_t numberOfElements,
const char *strSource,
size_t count,
_locale_t locale
);
errno_t wcsncat_s(
wchar_t *strDest,
size_t numberOfElements,
const wchar_t *strSource,
size_t count
);
errno_t _wcsncat_s_l(
wchar_t *strDest,
size_t numberOfElements,
const wchar_t *strSource,
size_t count,
_locale_t locale
);
errno_t _mbsncat_s(
unsigned char *strDest,
size_t numberOfElements,
const unsigned char *strSource,
size_t count
);
errno_t _mbsncat_s_l(
unsigned char *strDest,
size_t numberOfElements,
const unsigned char *strSource,
size_t count,
_locale_t locale
);
template <size_t size>
errno_t strncat_s(
char (&strDest)[size],
const char *strSource,
size_t count
); // C++ only
template <size_t size>
errno_t _strncat_s_l(
char (&strDest)[size],
const char *strSource,
size_t count,
_locale_t locale
); // C++ only
template <size_t size>
errno_t wcsncat_s(
wchar_t (&strDest)[size],
const wchar_t *strSource,
size_t count
); // C++ only
template <size_t size>
errno_t _wcsncat_s_l(
wchar_t (&strDest)[size],
const wchar_t *strSource,
size_t count,
_locale_t locale
); // C++ only
template <size_t size>
errno_t _mbsncat_s(
unsigned char (&strDest)[size],
const unsigned char *strSource,
size_t count
); // C++ only
template <size_t size>
errno_t _mbsncat_s_l(
unsigned char (&strDest)[size],
const unsigned char *strSource,
size_t count,
_locale_t locale
); // C++ only
Parameters
[out] strDest
Null-terminated destination string.
[in]numberOfElements
Size of the destination buffer.
[in]strSource
Null-terminated source string.
[in]count
Number of characters to append, or _TRUNCATE.
[in] locale
Locale to use.
Return Value
Returns 0 if successful, an error code on failure.
strDestination
numberOfElements
strSource
Return value
Contents of strDestination
NULL or unterminated
any
any
EINVAL
not modified
any
any
NULL
EINVAL
not modified
any
0, or too small
any
ERANGE
not modified
Remarks
These functions try to append the first D characters of strSource to the end of strDest, where D is the lesser of count and the length of strSource. If appending those D characters will fit within strDest (whose size is given as numberOfElements) and still leave room for a null terminator, then those characters are appended, starting at the original terminating null of strDest, and a new terminating null is appended; otherwise, strDest[0] is set to the null character and the invalid parameter handler is invoked, as described in Parameter Validation.
There is an exception to the above paragraph. If count is _TRUNCATE then as much of strSource as will fit is appended to strDest while still leaving room to append a terminating null.
For example,
char dst[5];
strncpy_s(dst, _countof(dst), "12", 2);
strncat_s(dst, _countof(dst), "34567", 3);
means that we are asking strncat_s to append three characters to two characters in a buffer five characters long; this would leave no space for the null terminator, hence strncat_s zeroes out the string and calls the invalid parameter handler.
If truncation behavior is needed, use _TRUNCATE or adjust the size parameter accordingly:
strncat_s(dst, _countof(dst), "34567", _TRUNCATE);
or
strncat_s(dst, _countof(dst), "34567", _countof(dst)-strlen(dst)-1);
In all cases, the resulting string is terminated with a null character. If copying takes place between strings that overlap, the behavior is undefined.
If strSource or strDest is NULL, or is numberOfElements is zero, the invalid parameter handler is invoked, as described in Parameter Validation . If execution is allowed to continue, the function returns EINVAL without modifying its parameters.
wcsncat_s and _mbsncat_s are wide-character and multibyte-character versions of strncat_s. The string arguments and return value of wcsncat_s are wide-character strings; those of _mbsncat_s are multibyte-character strings. These three functions behave identically otherwise.
The output value is affected by the setting of the LC_CTYPE category setting of the locale; see setlocale for more information. The versions of these functions without the _l suffix use the current locale for this locale-dependent behavior; the versions with the _l suffix are identical except that they use the locale parameter passed in instead. For more information, see Locale.
In C++, using these functions is simplified by template overloads; the overloads can infer buffer length automatically (eliminating the need to specify a size argument) and they can automatically replace older, non-secure functions with their newer, secure counterparts. For more information, see Secure Template Overloads.
The debug versions of these functions first fill the buffer with 0xFD. To disable this behavior, use _CrtSetDebugFillThreshold.
TCHAR.H routine
_UNICODE & _MBCS not defined
_MBCS defined
_UNICODE defined
_tcsncat_s
strncat_s
_mbsnbcat_s
wcsncat_s
_tcsncat_s_l
_strncat_s_l
_mbsnbcat_s_l
_wcsncat_s_l
_strncat_s_l and _wcsncat_s_l have no locale dependence; they are only provided for _tcsncat_s_l.
Requirements
Routine
Required header
strncat_s
<string.h>
wcsncat_s
<string.h> or <wchar.h>
_mbsncat_s, _mbsncat_s_l
<mbstring.h>
For additional compatibility information, see Compatibility in the Introduction.
Example
Copy Code
// crt_strncat_s.cpp
// compile with: /MTd
// These #defines enable secure template overloads
// (see last part of Examples() below)
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 1
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <crtdbg.h> // For _CrtSetReportMode
#include <errno.h>
// This example uses a 10-byte destination buffer.
errno_t strncat_s_tester( const char * initialDest,
const char * src,
int count )
{
char dest[10];
strcpy_s( dest, _countof(dest), initialDest );
printf_s( "\n" );
if ( count == _TRUNCATE )
printf_s( "Appending '%s' to %d-byte buffer dest with truncation semantics\n",
src, _countof(dest) );
else
printf_s( "Appending %d chars of '%s' to %d-byte buffer dest\n",
count, src, _countof(dest) );
printf_s( " old contents of dest: '%s'\n", dest );
errno_t err = strncat_s( dest, _countof(dest), src, count );
printf_s( " new contents of dest: '%s'\n", dest );
return err;
}
void Examples()
{
strncat_s_tester( "hi ", "there", 4 );
strncat_s_tester( "hi ", "there", 5 );
strncat_s_tester( "hi ", "there", 6 );
printf_s( "\nDestination buffer too small:\n" );
strncat_s_tester( "hello ", "there", 4 );
printf_s( "\nTruncation examples:\n" );
errno_t err = strncat_s_tester( "hello ", "there", _TRUNCATE );
printf_s( " truncation %s occur\n", err == STRUNCATE ? "did"
: "did not" );
err = strncat_s_tester( "hello ", "!", _TRUNCATE );
printf_s( " truncation %s occur\n", err == STRUNCATE ? "did"
: "did not" );
printf_s( "\nSecure template overload example:\n" );
char dest[10] = "cats and ";
strncat( dest, "dachshunds", 15 );
// With secure template overloads enabled (see #define
// at top of file), the preceding line is replaced by
// strncat_s( dest, _countof(dest), "dachshunds", 15 );
// Instead of causing a buffer overrun, strncat_s invokes
// the invalid parameter handler.
// If secure template overloads were disabled, strncat would
// append "dachshunds" and overrun the dest buffer.
printf_s( " new contents of dest: '%s'\n", dest );
}
void myInvalidParameterHandler(
const wchar_t* expression,
const wchar_t* function,
const wchar_t* file,
unsigned int line,
uintptr_t pReserved)
{
wprintf_s(L"Invalid parameter handler invoked: %s\n", expression);
}
int main( void )
{
_invalid_parameter_handler oldHandler, newHandler;
newHandler = myInvalidParameterHandler;
oldHandler = _set_invalid_parameter_handler(newHandler);
// Disable the message box for assertions.
_CrtSetReportMode(_CRT_ASSERT, 0);
Examples();
}
Copy Code
Appending 4 chars of 'there' to 10-byte buffer dest
old contents of dest: 'hi '
new contents of dest: 'hi ther'
Appending 5 chars of 'there' to 10-byte buffer dest
old contents of dest: 'hi '
new contents of dest: 'hi there'
Appending 6 chars of 'there' to 10-byte buffer dest
old contents of dest: 'hi '
new contents of dest: 'hi there'
Destination buffer too small:
Appending 4 chars of 'there' to 10-byte buffer dest
old contents of dest: 'hello '
Invalid parameter handler invoked: (L"Buffer is too small" && 0)
new contents of dest: ''
Truncation examples:
Appending 'there' to 10-byte buffer dest with truncation semantics
old contents of dest: 'hello '
new contents of dest: 'hello the'
truncation did occur
Appending '!' to 10-byte buffer dest with truncation semantics
old contents of dest: 'hello '
new contents of dest: 'hello !'
truncation did not occur
Secure template overload example:
Invalid parameter handler invoked: (L"Buffer is too small" && 0)
new contents of dest: ''
赵4老师 2015-03-24
- 打赏
- 举报
Collapse AllExpand All Code: All Code: Multiple Code: Visual Basic Code: C# Code: Visual C++ Code: J# Code: JScript
Visual Basic
C#
Visual C++
J#
JScript
Run-Time Library Reference
strcat_s, wcscat_s, _mbscat_s
Example See Also Send Feedback
Append a string. These are versions of strcat, wcscat, _mbscat with security enhancements as described in Security Enhancements in the CRT.
errno_t strcat_s(
char *strDestination,
size_t numberOfElements,
const char *strSource
);
errno_t wcscat_s(
wchar_t *strDestination,
size_t numberOfElements,
const wchar_t *strSource
);
errno_t _mbscat_s(
unsigned char *strDestination,
size_t numberOfElements,
const unsigned char *strSource
);
template <size_t size>
errno_t strcat_s(
char (&strDestination)[size],
const char *strSource
); // C++ only
template <size_t size>
errno_t wcscat_s(
wchar_t (&strDestination)[size],
const wchar_t *strSource
); // C++ only
template <size_t size>
errno_t _mbscat_s(
unsigned char (&strDestination)[size],
const unsigned char *strSource
); // C++ only
Parameters
strDestination
Null-terminated destination string buffer.
numberOfElements
Size of the destination string buffer.
strSource
Null-terminated source string buffer.
Return Value
Zero if successful; an error code on failure.
strDestination
numberOfElements
strSource
Return value
Contents of strDestination
NULL or unterminated
any
any
EINVAL
not modified
any
any
NULL
EINVAL
strDestination[0] set to 0
any
0, or too small
any
ERANGE
strDestination[0] set to 0
Remarks
The strcat_s function appends strSource to strDestination and terminates the resulting string with a null character. The initial character of strSource overwrites the terminating null character of strDestination. The behavior of strcat_s is undefined if the source and destination strings overlap.
Note that the second parameter is the total size of the buffer, not the remaining size:
Copy Code
char buf[16];
strcpy_s(buf, 16, "Start");
strcat_s(buf, 16, " End"); // Correct
strcat_s(buf, 16 – strlen(buf), " End"); // Incorrect
wcscat_s and _mbscat_s are wide-character and multibyte-character versions of strcat_s. The arguments and return value of wcscat_s are wide-character strings; those of _mbscat_s are multibyte-character strings. These three functions behave identically otherwise.
If strDestination is a null pointer, or is not null-terminated, or if strSource is a NULL pointer, or if the destination string is too small, the invalid parameter handler is invoked, as described in Parameter Validation . If execution is allowed to continue, these functions return EINVAL and set errno to EINVAL.
In C++, using these functions is simplified by template overloads; the overloads can infer buffer length automatically (eliminating the need to specify a size argument) and they can automatically replace older, non-secure functions with their newer, secure counterparts. For more information, see Secure Template Overloads.
The debug versions of these functions first fill the buffer with 0xFD. To disable this behavior, use _CrtSetDebugFillThreshold.
TCHAR.H routine
_UNICODE & _MBCS not defined
_MBCS defined
_UNICODE defined
_tcscat_s
strcat_s
_mbscat_s
wcscat_s
Requirements
Routine
Required header
strcat_s
<string.h>
wcscat_s
<string.h> or <wchar.h>
_mbscat_s
<mbstring.h>
For additional compatibility information, see Compatibility in the Introduction.
Example
See the code example in strcpy_s, wcscpy_s, _mbscpy_s.
.NET Framework Equivalent
System::String::Concat
See Also
Concepts
String Manipulation (CRT)
strncat, _strncat_l, wcsncat, wcsncat_l, _mbsncat _mbsncat_l
strncmp, wcsncmp, _mbsncmp, _mbsncmp_l
strncpy, _strncpy_l, wcsncpy, _wcsncpy_l, _mbsncpy, _mbsncpy_l
_strnicmp, _wcsnicmp, _mbsnicmp, _strnicmp_l, _wcsnicmp_l, _mbsnicmp_l
strrchr, wcsrchr, _mbsrchr, _mbsrchr_l
strspn, wcsspn, _mbsspn, _mbsspn_l
Send feedback on this topic to Microsoft.
哈利_蜘蛛侠 2015-03-23
- 打赏
- 举报
还是没有人给予解答吗？
paschen 版主 2015-03-14
- 打赏
- 举报
写成strcat_s(str1, count, str2)试下
paschen 版主 2015-03-14
- 打赏
- 举报
strcat_s需要3个输入参数
哈利_蜘蛛侠 2015-03-14
- 打赏
- 举报
看过定义了。这个函数的返回值就是if语句测试的那些。不过这个程序似乎表示，那些返回值是没有意义的……
赵4老师 2015-03-14
- 打赏
- 举报
VS IDE中，在不明白的符号上点鼠标右键，选转到定义。
哈利_蜘蛛侠 2015-03-14
- 打赏
- 举报
对了，以上程序是在Visual Studio 2013中实现的。
哈利_蜘蛛侠 2015-03-14
- 打赏
- 举报
strcat_s有好几个重载版本的。况且编译的时候没有错误，运行的时候，如果第一个参数的维数足够大，也是没有问题的。
其实最开始想要问的是strncat_s为何有类似的问题。后来发现strcat_s就有这样的问题了。
