Why does printing out an array of char result in random characters? - arrays

Question

I am trying to learn programming and am doing some random questions and tasks. The task is to write out the last three characters of a string and this is what I've come up with. Please do not solve this for me, I am asking about my output/result not for anyone to do the problem solving for me:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int func(char *input_1, char *input_2) {
char last_three_digits_1[3]; // define two arrays that hold the last three characters
char last_three_digits_2[3];
int x = 0;
for(int y = strlen(input_1) - 4; y < strlen(input_1) - 1; y++) {
last_three_digits_1[x] = input_1[i];
x++;
}
x = 0; // repeat for the second string
for(int z = strlen(input_2) - 4; z < strlen(input_2) - 1; z++) {
last_three_digits_2[x] = input_2[i];
x++;
}
printf("last3_1: %s, \nlast3_2: %s\n", last_three1, last_three2); // this seem to access random memory because it outputs "abc" followed by random "-???" or "-????" or "-?2?2". Same for the second array.
return 0;
}
int main(int argc, char * argv[] ) {
if(argc == 3) { // needs to be two strings. E.g: "abcd efghi"
if(strlen(argv[1]) >= 3 || strlen(argv[2]) >= 3) { // if any of the strings are less than 3 in length, e.g. "ab wadnkwa" then do not proceed.
func(argv[1], argv[2]); // send the user input to the function
}
return 0; // maybe redundant
}
return 0; // return 0 for failure
}

Answer 1

The condition in the if statement
if(strlen(argv[1]) >= 3 || strlen(argv[2]) >= 3)
means that the length of one of the strings can be less than 3. In this case the function func can invoke undefined behavior.
It seems you mean
if(strlen(argv[1]) >= 3 && strlen(argv[2]) >= 3)
Otherwise you need in the function func to make a check whether a string has length greater than or equal to 3 before outputting its last three characters.
If a string has exactly three characters then for example in this loop
for(int i = strlen(text1) - 4; i < strlen(text1) - 1; i++)
the variable i can have an implementation defined value as for example -1 and as a result this expression text1[i] invokes undefined behavior.
The return type int of the function does not have a meaning.
Pay attention to that if you are using the format %s to output a character array using printf then the array shall contain a string that is a sequence of characters terminated with the zero character '\0'.
So neither the if statement in main nor the function itself makes a sense.
To output last three (or any other number) characters of a string there is no need to create an auxiliary array. It can be done much simpler.
For example
void func( const char *text1, const char *text2, size_t n )
{
size_t n1 = strlen( text1 );
if ( !( n1 < n ) ) text1 += n1 - n;
size_t n2 = strlen( text2 );
if ( !( n2 < n ) ) text2 += n2 - n;
printf( "last%zu_1: %s, \nlast%zu_2: %s\n", n, text1, n, text2 );
}
And the function can be called like
func( argv[1], argv[2], 3 );
Using such a declaration of the function you can output any number of last characters of two strings. Also take into account that the function parameters have the qualifier const because the passed strings are not changed within the function.
Here is a demonstrative program
#include <stdio.h>
#include <string.h>
void func( const char *text1, const char *text2, size_t n )
{
size_t n1 = strlen( text1 );
if (!( n1 < n )) text1 += n1 - n;
size_t n2 = strlen( text2 );
if (!( n2 < n )) text2 += n2 - n;
printf( "last%zu_1: %s, \nlast%zu_2: %s\n", n, text1, n, text2 );
}
int main( void )
{
func( "Hello", "World", 3 );
}
The program output is
last3_1: llo,
last3_2: rld

Answer 2

char last_three1[3]; // define two arrays that hold the last three characters
char last_three2[3];
You need space to hold \0 char, because %s expects char* to be \0 terminated.
char last_three1[4];
char last_three2[4];
….
last_three1[x] = '\0';
x = 0; // repeat for the second string
for(int i = strlen(text2) - 4; i < strlen(text2) - 1; i++) {
last_three2[x] = text2[i];
x++;
}
last_three2[x] = '\0';

Answer 3

Strings in C are terminated with a single zero byte.
You're not zero-terminating the strings, so printf doesn't know where to stop printing (and you're lucky your program doesn't outright crash).
I'd refactor things like this, so you have a single function that simply copies the three last bytes and zero-terminates the string:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// out must be an array that can hold 4 bytes
// in must be >= 3 characters; otherwise this function returns non-zero
int get_last_three(char *out, const char *in) {
int len = strlen(in);
if (len < 3)
return -1;
for (int i = len - 3; i < len; i++) {
*out = in[i];
out++;
}
*out = 0; // Zero-terminate
return 0;
}
int main(int argc, char *argv[]) {
char out[4];
for (int i = 1; i < argc; i++) {
if (get_last_three(out, argv[i]) == 0) {
printf("last3_%d: %s\n", i, out);
}
}
}