Pointer question: return makes pointer from integer without a cast

If you want to return a pointer from a function, you need to make sure that it points to valid memory.

Here are two ways you can make sure of that :

1) by allocating memory outside of the function, and passing it as an argument :

        int *add(int *psum, int *pa, int *pb) {
            *psum = *pa + *pb;
            return psum;
        }

     and you can call it like this :

        int a = 10, b = 50;
        int sum = 0;
        int *psum = 0;

        psum = add(&sum, &a, &b);

        printf("  sum : %d\n  sum via pointer : %d\n", sum, *psum);

     note that sum will contain the result of the function, and psum will point to that SAME value. In other words, if after calling the function, we change sum :

        sum = 20;

        printf("  sum : %d\n  sum via pointer : %d\n", sum, *psum);

     then psum will also point to 20.


2) by allocating memory inside of the function :

        int *add(int *pa, int *pb) {
            int *psum = (int*) calloc(1, sizeof(int));
            *psum = *pa + *pb;
            return psum;
        }

     The calloc call allocates memory dynamically for the return value. This memory will still be valid after the function returns, which is what we need.

     and you can call it like this :

        int a = 10, b = 50;
        int *psum = 0;

        psum = add(&a, &b);

        printf("  sum via pointer : %d\n", *psum);

        free(psum);

     note that psum will point to the result of the addition.

     The call to free is ABSOLUTELY needed once we don't need the result any more ... otherwise there is a memory leak.

>> Can i assume that a pointer needs   to point to something

A pointer can point to nothing, but in that case it's illegal to dereference it. For example :

      int *ptr = 0;    /* <--- this pointer points to nothing */
      int a = *ptr;   /* <--- this is illegal, and will generate a runtime error */

In the above, you're trying to dereference a pointer that points to nothing. In other words : you're trying to get a value that is not there - that's illegal.

However, if the pointer points to something, like this :

      int a = 10;
      int *ptr = &a;     /* <--- we make the pointer point to the value a */
      int b = *ptr;       /* <--- this is OK : b will now have the same value as a */

then it's OK.

Similarly, we can do this :

      int *ptr = (int*) calloc(1, sizeof(int)); /* <--- we make the pointer point to a valid memory location */
      *ptr = 20;    /* <--- this is OK : we can dereference the pointer, and place a value in the memory it points to */
      free(ptr);     /* <--- once we don't need that value any more, we free it */
      int a = *ptr;     /* <--- this is now illegal. We just cleaned up ptr, so it doesn't point to valid memory any more */



And, now with some drawings that might make things a bit clearer.

1) this line :

      int *ptr = 0;

    has this as result :

        ptr -->

    ie. ptr points to nothing

2) this line :

      int *ptr = (int*) calloc(1, sizeof(int));

    makes ptr point to an empty memory block :

                   ----------
        ptr --> |          |
                   ----------

    this memory block might contain any value (we don't know which), so we give it a value :

      *ptr = 20;

    which has this as result :

                   ----------
        ptr --> |   20   |
                   ----------

3) this line :

      int a = 10;

    has this as result :

                   ----------
                   |   10   |
                   ----------

    ie. there's an int somewhere in memory with the value 10.

    When we do this :

      int *ptr = &a;

    we let ptr point to that int :

                   ----------
        ptr --> |   10   |
                   ----------

    so, if we do this :

      *ptr = 20;

    then we change the value of a :

                   ----------
        ptr --> |   20   |
                   ----------


Does that make things a bit clearer ?