Reversing strings in C - Memory Direction - c

Question

Recently I've been learning about Strings and Pointers in C and have learned that you can do some pretty cool things in C using pointer arithmetic which reversing a String is one of these things. The following is the code that I am working with:
#include <stdio.h>
#include <string.h>
void print_reverse_string(char s[])
{
size_t length = strlen(s);
char *beginning = s;
char *end = beginning + length - 1;
while(end >= beginning)
{
printf("%c", *end);
end = end - 1;
}
}
int main()
{
printf("Please enter string to reverse: ");
char input_string[20];
fgets(input_string, 20, stdin);
/* Get rid of new line character from fgets function */
input_string[strlen(input_string) - 1] = '\0';
printf("Reversed string: ");
print_reverse_string(input_string);
return 0;
}
My concern begins with the following line of code:
char *end = beginning + length - 1;
This assumes that the ending memory location of an array will always be greater than the beginning memory location. Is this something that I should be concerned about as a C programmer or can I always be guaranteed that
&randomArray[0] < &randomArray[1] < &randomArray[2] < .... < &randomArray[lastElement]
It's just that I have been reading about different memory spaces and how certain spaces grow upwards while others grow downwards, for example, the stack growing downwards and the heap growing upwards, and thought that there might be a possibility of arrays growing downward in size.
Could this occur on a certain architecture or am I overthinking this possibility?

Answer 1

char *end = beginning + length - 1; leads to undefined behavior when length == 0. Example: "ending memory location of an array will always be greater" may be true expect code wants it to be false. Pointer arithmetic such as beginning + length - 1 is only valid from the beginning of an object to 1 object past its end. So beginning + 0 - 1 is UB.
Subsequent (like in an array) objects' addresses compare in increasing order - regardless of their underlying values, but the arithmetic is valid only in a narrow range.
Better to do
char *end = beginning + length;
while(end > beginning) {
end = end - 1;
printf("%c", *end);
}
Side issue: Should the first character read via fgets() is '\0', the below code attempts input_string[SIZE_MAX] = '\0'
// do not use
input_string[strlen(input_string) - 1] = '\0';
// alternatives
if (*input_string) input_string[strlen(input_string) - 1] = '\0';
// or
input_string[strcspn(input_string, "\n")] = '\0';

Answer 2

C arrays are always allocated contiguously in memory, from lowest address to highest.

Answer 3

This assumes that the ending memory location of an array will always be greater than the beginning memory location.
Yes, your assumption is correct. An array stores its elements in contiguous memory locations and in increasing order.

Answer 4

All answers above me were correct. When you write
char input_string[20];
you get 20*sizeof(char) bytes allocated on the stack, and input_string is only a pointer pointing to the first item, and it is handled like a pointer. For example input_string[10] means *(input_string + 10), etc.
Instead of repeating others, here's a tricky solution of the same task. Recursion in C is lovely for me, or black magic for the ignorants :) Takes some time to understand it, though. Not for serious use, but for fun!
The two backsides of recursion are: danger of stack overflow, and inefficiency. Neither of them are relevant to your question.
#include <stdio.h>
void reverse()
{
int c = getchar();
if (c != '\n' && c != EOF)
{
reverse();
putchar(c);
}
else
printf("Reversed string: ");
}
int main(void)
{
printf("Please enter string to reverse: ");
reverse();
return 0;
}