Printing a string in c using a pointer

When you return stringg, which is a pointer to the local variable string in GetString, you are returning a reference to memory that is just about to be reclaimed. This is because string "lives" in the stack frame of GetString, and the stack frame ceases to exist when the function returns. You have three options:

1. Move string to main, and pass a pointer to it to GetString.
2. Dynamically allocate string using malloc inside of GetString. Memory allocated using malloc survives until manually released using free.
3. Or, as Michael Petch pointed out below, declare string as static, meaning memory will be set aside in the global data segment of the program. However, this means that subsequent calls to GetString will clobber its contents, so if you want to save the result of a previous call to GetString you must manually copy it using strdup or similar.

Before GetString returns, the stack looks something like this:

                       (high address)
+---------------------+
|   (main's frame)    |
|        ...          |
+---------------------+
| (GetString's frame) |
|  char string[100]   |
+---------------------+ <- stack pointer
                       (low address)

As you can see, the stack pointer points to the end of GetString's frame, marking the top of the stack (notice that on most modern platforms, the stack actually grows downwards). But when GetString returns, the stack pointer moves up to the end of main's frame:

                       (high address)
+---------------------+
|   (main's frame)    |
|        ...          |
+---------------------+ <- stack pointer
| Formerly the frame  |
| of GetString, now   |
| (probably) garbage. |
+---------------------+
                       (low address)

And accessing something that is not part of the stack (i.e., in this case below the stack pointer) results in undefined behavior. (Well, not quite - see Barak Manos' comment below) In your case, you get garbage.

Returning pointer to automatic local variable invokes undefined behavior. You need to use dynamic allocation or use staticspecifier.

char *string = malloc(100);  

or

static char string[100];

You can pass the array to the GetString function

void  GetString(char string[], size_t length /* prevent overflow */)
{
    char x; // to get the chars 1 by 1
    int counter = 0;

    if (length == 0)
    {
        string[0] = '\0';
        return;
    }
    scanf("%c", &x); // i dont like do while loops

    while ((x != '\n') && (counter < length - 1))
    {
        string[counter] = x;
        scanf("%c", &x);
        counter++;
    }
    string[counter] = '\0';
}

and in main

int main()
{
    char string[100];

    GetString(string, sizeof(string));
    if (*string != '0')
        printf("%c", *(1+string));

    int j;
    for (j = 0; string[j] != '\0'; j++)
        printf("%c", *(j+string));
    int i;
    scanf("%d", &i);

    return 0;
}

[too long for a comment]

To follow up on iharob proposal to pass in the buffer, please see this:

int GetString(char * str, size_t len)
{
  int result = 0;

  if ((NULL == str) || (0 == len))
  {
    result = -1;
    errno = EINVAL;
  }
  else 
  {
    while (1 < len)
    {
      result = scanf("%c", str);
      if (EOF == result)
      {
        int errno_save = errno:

        if (ferror(stdin))
        {
          result = -1;
          errno = errno_save;
        }
        else
        {
          result = 0;
        }
      }

      if ((0 != result) || ('\n' == *str))
      {
        break;
      }

      ++str;
      --len;
    }

    *str = '\0';
  }

  return result;
}

Call this like so:

int main()
{
  char string[100];

  int result = GetString(string, sizeof(string));
  if (-1 == result)
  {
    perror("GetString()" failed");
    exit(1);
  }

  ...