In this solution, if *inputString is a memory address (and the input is a char type) then does *inputString qualify as an array?

Question

I was solving a challenge on CodeSignal in C. Even though the correct libraries where included, I couldn't use the strrev function in the IDE, so I looked up a similar solution and modified it to work. This is good. However, I don't understand the distinction between a literal string and an array. Reading all this online has left me a bit confused. If C stores all strings as an array with each character terminated by \0 (null terminated), how can there be any such thing as a literal string? Also if it is the case that strings are stored as an array, *would inputString store the address of the array or is it an array itself of all the individual characters stored.

Thanks in advance for any clarification provided!

Here is the original challenge, C: Given the string, check if it is a palindrome.

bool solution(char * inputString) {
    // The input will be character array type, storing a single character each terminated by \0 at each index
    // * inputString is a pointer that stores the memory address of inputString. The memory address points to the user inputted string
    // bonus: inputString is an array object starting at index 0
    // The solution function is set up as a Boolean type ("1" is TRUE and the default "0" is FALSE)
   int begin;
   // The first element of the inputString array is at position 0, so is the 'counter'
   int end = strlen(inputString) - 1;
   // The last element is the length of the string minus 1 since the counter starts at 0 (not 1) by convention
   while (end > begin) {
       if (inputString[begin++] != inputString[end--]) {
           return 0;
       }
   } return 1;
}

Answer 1

A string is also an array of symbols. I think that what you don't understand is the difference between a char pointer and a string. Let me explain in an example:

Imagine I have the following:

char str[20]="helloword";

str is the address of the first symbol of the array. In this case str is the address of h. Now try to printf the following:

printf("%c",str[0]);

You can see that it has printed the element of the addres that is 'h'.

If now I declare a char pointer, it will be poining to whatever char adress I want:

char *c_pointer = str+1;

Now print the element of c_pointer:

printf("%c",c_pointer[0]);

You can see that it will print 'e' as it is the element of the second adress of the original string str.

In addition, what printf("%s", string) does is to printf every elemet/symbol/char from the starting adress(string) to the end adress where its element is '\0'.

Answer 2

The linked question/answers in the comments pretty much cover this, but saying the same thing a slightly different way helps sometimes.

A string literal is a quoted string assigned to a char pointer. It is considered read only. That is, any attempts to modify it result in undefined behavior. I believe that most implementations put string literals in read-only memory. IMO, it's a shortcoming of C (fixed in C++) that a const char* type isn't required for assigning a string literal. Consider:

int main(void)
{
  char* str = "hello";
}

str is a string literal. If you try to modify this like:

#include <string.h>
... 

str[2] = 'f'; // BAD, undefined behavior
strcpy(str, "foo"); // BAD, undefined behavior

you're broken the rules. String literals are read only. In fact, you should get in the habit of assigning them to const char* types so the compiler can warn you if you try to do something stupid:

const char* str = "hello"; // now you should get some compiler help if you
                           // ever try to write to str

In memory, the string "hello" resides somewhere in memory, and str points to it:

str
  |
  |
  +-------------------> "hello"

If you assign a string to an array, things are different:

int main(void)
{
  char str2[] = "hello";
}

str2 is not read only, you are free to modify it as you want. Just take care not to exceed the buffer size:

#include <string.h>
...

str2[2] = 'f'; // this is OK
strcpy(str2, "foo"); // this is OK
strcpy(str2, "longer than hello"); // this is _not_ OK, we've overflowed the buffer

In memory, str2 is an array

str2 = { 'h', 'e', 'l', 'l', '0', '\0' }

and is present right there in automatic storage. It doesn't point to some string elsewhere in memory.

In most cases, str2 can be used as a char* because in C, in most contexts, an array will decay to a pointer to it's first element. So, you can pass str2 to a function with a char* argument. One instance where this is not true is with sizeof:

sizeof(str) // this is the size of pointer (either 4 or 8 depending on your
            // architecture). If _does not matter_ how long the string that
            // str points to is
sizeof(str2) // this is 6, string length plus the NUL terminator.