How to use the strncpy_s function from visual c++? - c++

Question

I am learning some new things in C++, and I was trying to test this strncpy_s function from Visual C++. However I am running into some problems as program crashes and I dunno whats going on but I am sure it is a pretty stupid problem. The source code is something like this:
#include "stdafx.h"
#include <iostream>
#include <cstdio>
#include <cstring>
int main()
{
char *p;
p=(char *)malloc(sizeof(char)*strlen("Hello!\n"));
strncpy_s(p,strlen("Hello!\n"),"Hello!\n",strlen("Hello!\n"));
std::cout << p;
std::cout << strlen("Hello!\n") << std::endl;
return 0;
}
As I said I am not using std::string coz I want to try this new function and know how it works.

Answer 1

I take my comments back, I read the documentation more carefully. Your code is passing invalid parameters, and is invoking the invalid parameter handler. Maybe that's what's happening. Namely:
p=(char *)malloc(sizeof(char)*strlen("Hello!\n"));
This line allocates room for 7 characters, which is the length of the string, but not enough room for a null terminator. (This is generally an error)
The documentation for strncpy_s says: These functions try to copy the first D characters of strSource to strDest, where D is the lesser of count and the length of strSource. If 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 copied and a 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.
Are you possibly seeing the "invalid parameter handler"?

Answer 2

You need 1 more character for terminating character ('\0') so you need to replace strlen("Hello!\n") with strlen("Hello!\n") + 1. You could store this length in some variable instead of calling strlen again. Also since you are using C++ you could use new / delete instead of malloc / free:
int len = strlen("Hello!\n") + 1;
char *p;
p = new char[len];
strncpy_s(p, len, "Hello!\n", len);
std::cout << p << len << std::endl;
delete[] p;

Answer 3

The 'security-enhanced' string functions are essentially designed to crash if they run into a problem.
From Microsoft's docs on strncpy_s():
These functions try to copy the first D characters of strSource to
strDest, where D is the lesser of count and the length of strSource.
If 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 copied and a 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 into strDest is copied while
still leaving room for the terminating null which is always appended.
The description of the Paramter Validation is:
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. ...
Your example program provides a buffer that is too small by one char (there's no room for the null terminator).
So unless you specifically change what should happen when the strxxxx_s functions do when an error is encountered, your program will crash by design. The idea is that a crash is better than a bug that may open a security hole.

Answer 4

strlen(s) will only tell you the length of the string without the NUL terminator. To allocate space into which to copy a string, you normally use strlen(s)+1, to add space for a NUL terminator.

Answer 5

You need to allocate strlen("Hello!\n") + 1 (for the null terminator). And sizeof(char) is utterly pointless since sizeof(char) is guaranteed to be 1 on all platforms.

Answer 6

Why are you using malloc or char* if you're using C++?
std::string p = "Hello!\n";
std::cout << p;
std::cout << p.length();
or
std::string* p = new std::string("Hello!\n");
std::cout << p;
std::cout << p->length();
But to answer your original question you probably need to use strlen(p) + 1
And if you need a char* from your string you can use p.c_str()