Using pointers in C to print string

str[20]; exists on the stack and it is not valid to reference it after you return from aString.

char *aString(void)
{
    char *str;
    str = malloc(20);
    strcpy(str, "Hello World!");
    return str;
}

int main(int argc, char **argv)
{
    char *ptr = aString();
    printf("%s\n", ptr);
    free(ptr);
    exit(0);
}

You're thinking incorrectly about two concepts.

1. Returning an object that is local to a function is a bad idea.

   char *aString(void)
   {
       char str[20];
       strcpy(str, "Hello World!");
       return str;
   }
   

   Because the memory for str is freed after returning from aString, the pointer returned by the function may not point to valid memory anymore.

2. Copying from a pointer does not automatically copy any value it holds.

   char *ptr = malloc(20);
   ptr = aString();
   

   Ignoring the issue with aString returning a pointer to an object that no longer exists, you're essentially doing this:

   /*
    * NOT valid C syntax
    */
   ptr = AllocateMemory(ByteCount=20)
   // ptr now points to address 0x10 where at least 20 bytes are available.
   
   ptr = aString()
   // ptr now points to address 0x1010. The 20 bytes allocated above can
   // no longer be freed using ptr.
   

The first thing to do is remedy the copying situation:

// Copy a maximum of 20 bytes --
// the number of bytes allocated for the object that "ptr" points to.
strncpy(ptr, aString(), 20);
// If there were 20 bytes copied, and the last one was not the null character,
// "ptr" is not null-terminated. As a result, the string is forcibly truncated here.
// While ordinarily bad design, this is not meant to be robust.
ptr[19] = 0;

However, you're still returning the address of a function-local object, which means strncpy would attempt to copy the nonexistent string returned by astring. Here's the second attempt at fixing the problem:

char *aString (char *s, size_t n) {
    strncpy(s, "Hello World!", n);
    s[n - 1] = 0;
    return s;
}

...

char *ptr = malloc(20);
aString(ptr, 20);
printf("%s\n", ptr);

Also, you really should add a check to ensure malloc did not return a null pointer before attempting to use ptr at all. Most example code omits it for brevity. Some systems always return a non-null pointer, but it's better to be safe anyway. Always check your return values. ;-)

There is a good explanation of what the stack and heap are In this link.

Your code is creating the array str[20] on the local stack of aString.

When the function aString calls return the stack it uses is cleared. This includes the array str[20] that you are then trying to use in your main function.

If you want be able to use that array after the function has returned you will need to put the memory on the heap. Which is not cleaned up after the function returns.

Or pass a place to store the array in to the function.

I have included an example of heap allocation below:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 20
char *aString(void)
{
    /**
     * create an array of 20 characters on the heap.
     * This memory is not guaranteed to be all 0.
     * You may want to memset the memory to 0, or use calloc.
     */
    char* str = malloc( MAX_SIZE );

    /* copy a max of 20 characters into the array you just created */
    /* snprintf guarantees a null terminator, which is important. */
    snprintf( str, MAX_SIZE, "Hello World!" );

    return str;
}

int main(int argc, char **argv)
{
    char *ptr;
    ptr = aString();
    printf("%s\n", ptr);

    free(ptr); /* clear the heap memory, this is not needed for stack */
    exit(0);
}

On aString, str is allocated on the stack, and is freed automatically by stack unwinding on exit.

To be honest, I am not sure how your code compiled without a warning, but when I wrote it and tried to compile, I get a return-local-address warning. Use the -Wall flag to check for all possible warnings.

Essentially what you have done is created a char array, your str[20], and tried to return and use it outside of the scope it was declared inside.

Instead, you could let the aString() take a parameter of type char *string and strcpy into the string directly.

void aString(char *string) {
    strcpy(string, "Hello World!");
}

[Warning! too much explanation]Here is what happens in your code line by line:

char *ptr = malloc(20); memory of size 20 bytes is allocated and ptr points to it.

ptr = aString(); you said ptr no longer points to the 20byte memory that is created but points to this thing called 'aString()' [which makes your first line useless]. so now lets see what aString() has to bring since ptr is about to point to that.

char str[20]; a character array of size 20 is created and str is a pointer to it (is good to remember name of array is just a pointer to the first element).

strcpy(str, "Hello World!"); str points to the array of about 12 characters.

return str; str is returned which is address of first element of the character array. This is just address of a stack memory that holds a local variable which no longer exists once out of the function. so now back to the main

ptr = aString(); now means ptr points to address that has nothing

*ptr = *aString(); // put the content pointed by aString() to ptr 20byte memory.

This would make more sense because it will put the first character H in ptr because that is return str; brings. But if you allocate the memory in the aString function, then you have what you wanted.

char *aString(void)
{
    char *str = malloc(20);
    strcpy(str, "Hello World!");
    return str;
}
int main(int argc, char **argv)
{
    char *ptr;
    ptr = aString();
    printf("%s\n", ptr);
    free(ptr);
    exit(0);
}