C++ scanning of written text crashes program? - arrays

Question

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char first_name[10];
char last_name[10];
printf("What is your first name? >");
scanf_s("%s\n", &first_name);
printf("What is your last name? >");
scanf_s("%s\n", &last_name);
printf("Hello and welcome %s %s!\n", first_name, last_name);
return 0;
}
If I try run this program with Ctrl+F5, I am able to enter my first name, for example alex, and then my code crashes through the rest and wants to exit?
please advise of wrong doing
thanks

Answer 1

What we generally wish for from posters, especially those like you who are looking for debugging help, is an output of the compiler and linker warnings and errors, if any. We also recommend compiling with high warning settings, e.g. -pedantic for gcc or /W4 in Visual Studio.
Visual Studio tells me the following:
Severity Code Description Project File Line Suppression State
Warning C6064 Missing integer argument to 'scanf_s' that corresponds to conversion specifier '2'. scanf-array C:\Users\Peter\source\repos\scanf-array\scanf-array.cpp 15
Warning C6064 Missing integer argument to 'scanf_s' that corresponds to conversion specifier '2'. scanf-array C:\Users\Peter\source\repos\scanf-array\scanf-array.cpp 18
Warning C4473 'scanf_s' : not enough arguments passed for format string scanf-array C:\Users\Peter\source\repos\scanf-array\scanf-array.cpp 15
Warning C4473 'scanf_s' : not enough arguments passed for format string scanf-array C:\Users\Peter\source\repos\scanf-array\scanf-array.cpp 18
So, apparently scanf_s expects another argument. I don't know that function, so I looked it up (emphasis by me):
Unlike scanf and wscanf, scanf_s and wscanf_s require you to specify buffer sizes for some parameters. Specify the sizes for all c, C, s, S, or string control set [] parameters. The buffer size in characters is passed as an additional parameter. It immediately follows the pointer to the buffer or variable. For example, if you're reading a string, the buffer size for that string is passed as follows:
char s[10];
scanf_s("%9s", s, (unsigned)_countof(s)); // buffer size is 10, width spec. is 9
Of course you can for a test simply write 10 as the last parameter, it's just less robust in case you change the array size (which should be a define anyway). And voila, it works.
#t.niese was, by he way, right that the address operator in front of the arrays is wrong. What the function expects is the address of a char that's at the beginning of a buffer large enough to take the input; it does not expect the address of an array. The reason is that the address of an array of 10 has the type char (*)[10] while the address of an array of 20 has the type char (*)[20]; the arrays have different, unrelated types. They cannot stand in for each other e.g. in parameter declarations.
This is different in languages like Java or C# where arrays carry runtime (as opposed to compile time) information with them and can simply be passed as "array of char, it will know how long": In C and C++ this is compile time information, baked into the type, making arrays of different lengths incompatible.
C programmers and library functions like scanf use the trick to simply (by convention) pass around the address of the first character (whose type is naturally the same for all array lengths — address of char, or maybe even void!) plus, often, an additional length parameter. memcpy works that way. This trick is supported by the language: arrays "decay" or, in standard language, are "adjusted" to a pointer to their first element in most expressions, for example when they are passed as parameters. This happens precisely to aid this "address of the first element" compatibility trick.
That said, the address of the array is of course the address of its first element; that is, (intptr_t)&first_name == (intptr_t)&first_name[0] holds, so while the type of the buffer address you passed was wrong, the address itself was correct, and since scanf doesn't care about types except for its first argument, it just used it as the address of the first char, which, in fact, it was.
Another remark on the side: Don't include \n in the format, it requires the user to press enter twice here.

Answer 2

use std::cin instead of scanf_s .
it shows an error : error C4996: 'scanf_s': This function or variable may be unsafe

Answer 3

The IO functions from C library (printf*, scanf* and friends) are pretty good-old thing. Because they are power and flexible. But the cost of this is that they should be used carefully, with deep understanding what you are doing.
The main attention should be drawn on that they are variadic. That is, types of the last parameters are fully on the programmer's responsibility. This functions family is build in such a way this variadic arguments should correspond to the (mandatory) argument of format string. To be more precise: to the format specifiers in it and theirs order.
So, you specified the %s. Let's read what is written in the manual about this conversion specifier:
matches a sequence of non-whitespace characters (a string)
If width specifier is used, matches up to width or until the first
whitespace character, whichever appears first. Always stores a null
character in addition to the characters matched (so the argument array
must have room for at least width+1 characters)
Here you can read the "array" word. So, the characters array (C-string) argument should be passed to the scanf for the %s specifier. But you passed the pointer to the array. We can say: the pointer to pointer. Because an array's variable in C contains a pointer to the first array's element. The &array expression gives an address of the array variable by itself, not the array. I.e., an address in the memory where the array variable is placed. In your example, the scanf faithfully tried to put a string you entered at the address you passed -- at the place where the first_name variable stored, not at the place where the array's bytes are placed.
So, to be short, the & operators are waste in your code.
But, even you'll remove them, your code still will have chances to crash your program. Because the first_name and last_name arrays are of 10 characters long, but user can enter more than 10 symbols. In such a case, the scanf also will try to place oversized tail beyond of the arrays' storage. Most probably, this will lead to the program crash. As you can read in the quote of the %s description, the length specifier may be used with this specifier and it should refer to the target array's length. In your example, the %9s conversion specifier may be used. The last byte of the string will be filled with 0 by the scanf, so the 10th byte is reserved for this purpose.
UPDATE:
And yes, the scanf_s versions expect two arguments for one %c, %s or %[ conversion specifier -- the usual pointer and a value of type rsize_t indicating the size of the receiving array, which may be 1 when reading with a %c into a single char.