Passing a string through a function. C [duplicate]

You've fallen for the trap of believing that a pointer and an array are the same thing. They are not.

A string, by convention in C, is normally represented as an array of char, with an additional terminator of '\0' (the so-called nul-character) appended on the end. So the string literal "AB" is represented as an array of three char with values 'A', 'B', and '\0'.

A pointer is completely different from an array and, since a string is represented using an array of char, a pointer and a string are completely separate things. A pointer is a variable that contains an address in memory.

Where things get confused is the name of an array is, in a number of contexts, converted into a pointer. For example;

 char x[] = "AB";
 char *p = x;

This assignment works, but that doesn't mean an array is a pointer, or a pointer is an array. Instead, the name x is converted into a pointer to its first character. So the initialisation is functionally equivalent to

 char *p = &x[0];

so p points to the character with value 'A' in the string "AB".

The same thing is happening in your code, so

char *getUserWord()
{
    static char str[20];
    scanf("%s", str);
    return str;
}

is equivalent to

char *getUserWord()
{
    static char str[20];
    scanf("%s", &str[0]);
    return &str[0];
}

In both cases, the pointer returned by getUserWord() has a value which is the address of str[0]. That is the value that is used to initialise baseWord in main()

char *baseWord = getUserWord();

Because baseWord now points at the first character of an array, it can be treated AS IF it is an array. In C, for a given value of i, this includes an equivalence between baseWord[i] (in main()) and str[i] (in getUserWord()). The fact that array syntax is used does not mean that a pointer and array are the same thing. It just means they can be worked on using the same syntax.

The important thing to realise, however, is that a pointer can be returned from a function (and the returned value assigned to, or used to initialise, another pointer) but an array cannot. So, in main() this is legal;

 char *p = getUserWord();
 p[0] = 'X';    /*  will change str[0] in getUserWord() */

but this will not be;

 char array[20] = getUserWord();

Arrays cannot be assigned in C. This is mandated by the C Standard¹. The lvalue in your second example is baseWord and has the type char[21] which is an array.

In your first example, when you return str, which has the type static char[20], it is converted to the type char* and can be returned from the function and assigned to pointer baseWord. Since str has static storage duration, the pointer points to a valid object.

If you want to return a non-static string, you can allocate it (using the function malloc), pass an existing string to a function or wrap the string with a struct.

¹(Quoted from: ISO:IEC 9899:201X 6.3.2.1. Lvalues, arrays, and function designators 1 )
A modifiable lvalue is an lvalue that does not have array type, does not have an incomplete type, does not have a const- qualified type, and if it is a structure or union, does not have any member (including, recursively, any member or element of all contained aggregates or unions) with a const- qualified type.

This code

char baseWord[21];
baseWord = getUserWord();

won't work because what is converted from an array is not a lvalue (N1570 6.3.2.1) while a modifiable lvalue is required for the left operand of assignment operator (N1570 6.5.16).

You can pass pointer to an array where the string read will be stored from callee.

#include <stdio.h>

void getUserWord(char* str);

int main(void)
{
    char baseWord[21] = ""; /* initialize for avoiding undefined behavior in case no data is read */
    getUserWord(baseWord);
    printf("%s", baseWord);

    return 0;
}

void getUserWord(char* str)
{
    scanf("%s", str);
}

Omitted in this example, you should check if reading is successful.