Strcat c ошибка c4996

Dvir NaimDvir Naim

3351 gold badge3 silver badges12 bronze badges

The error message is entirely self-explanatory. It’s not clear what it is you don’t understand. For example, in your join function, terrible things would happen if the two strings together are longer than 255 characters.

Also, your join function is totally broken. It returns a pointer to a buffer that no longer exists once it returns since you allocated it on the stack that you are returning from.

answered Feb 26, 2015 at 10:23

pmgpmg

106k13 gold badges126 silver badges199 bronze badges

The first message is because strcat doesn’t check if the target storage is big enough to hold the concatenated string. You might get a buffer overflow. strcat_s has an additional parameter which is the buffer length. It will make sure there is no buffer overflow.

Regarding you second question, the code in join() is bogus.
What you do is declare a local variable that is an array of 256 char. As a local variable it will be «destroyed» when join() terminates.
You then copy s1 into this buffer. Note that the buffer could be too small and you would get a buffer overflow.

Then you call strcat with the local variable buffer as first argument. The result is that s2 will be appended to s1 in the local variable buffer.
The value return by strcat is a pointer on the buffer.
When join() returns, the buffer is «destroyed» and the pointer becomes invalid.

Note that another problem in you code is to declare the function join() inside of main. You must move this line out of the main function.

The way you defined your struct and string variable is correct. It is the way you perform the join() that is bogus.

If you are using c++, why not avoid the whole mess and use std::string. The same example without any errors would look like this:

std::string prefix = "Sector_Data\sector";
prefix += "0";
prefix += "\"

no need to worry about buffer sizes and all that stuff. And if you have an API which takes a const char *, you can just use the .c_str() member;

some_c_api(prefix.c_str());

answered Jun 1, 2009 at 20:33

Because the buffer, prefix, could have less space than you are copying into it, causing a buffer overrun.
Therefore, a hacker could pass in a specially crafted string which overwrites the return address or other critical memory and start executing code in the context of your program.

strcat_s solves this by forcing you to pass in the length of the buffer into which you are copying the string; it will truncate the string if necessary to make sure that the buffer is not overrun.

google strcat_s to see precisely how to use it.

answered Jun 1, 2009 at 20:02

You can get rid of these warning by adding:

_CRT_SECURE_NO_WARNINGS

and

_SCL_SECURE_NO_WARNINGS

to your project’s preprocessor definitions.

answered Jun 1, 2009 at 20:41

That’s one of the string-manipulation functions in C/C++ that can lead to buffer overrun errors.

The problem is that the function doesn’t know what the size of the buffers are. From the MSDN documentation:

The first argument, strDestination,
must be large enough to hold the
current strDestination and strSource
combined and a closing »;
otherwise, a buffer overrun can occur.

strcat_s takes an extra argument telling it the size of the buffer. This allows it to validate the sizes before doing the concat, and will prevent overruns. See http://msdn.microsoft.com/en-us/library/d45bbxx4.aspx

answered Jun 1, 2009 at 20:04

Because it has no means of checking to see if the destination string (prefix) in your case will be written past its bounds. strcat essentially works by looping, copying byte-by-byte the source string into the destination. Its stops when it sees a value «0» (notated by ») called a null terminal. Since C has no built in bounds checking, and the dest str is just a place in memory, strcat will continue going ad-infinidium even if it blows past the source str or the dest. str doesn’t have a null terminal.

The solutions above are platform-specific to your windows environment. If you want something platform independent, you have to wrangle with strncat:

strncat(char* dest, const char* src, size_t count)

This is another option when used intelligently. You can use count to specify the max number of characters to copy. To do this, you have to figure out how much space is available in dest (how much you allocated — strlen(dest)) and pass that as count.

answered Jun 1, 2009 at 20:02

youngyoung

2,15312 silver badges19 bronze badges

DolphinDolphin

4,6451 gold badge30 silver badges25 bronze badges