Memory allocation and changing values

Question

I am very new to C so sorry in advance if this is really basic. This is related to homework.

I have several helper functions, and each changes the value of a given variable (binary operations mostly), i.e.:

void helper1(unsigned short *x, arg1, arg2) --> x = &some_new_x

The main function calls other arguments arg3, arg4, arg5. The x is supposed to start at 0 (16-bit 0) at first, then be modified by helper functions, and after all the modifications, should be eventually returned by mainFunction.

Where do I declare the initial x and how/where do I allocate/free memory? If I declare it within mainFunc, it will reset to 0 every time helpers are called. If I free and reallocate memory inside helper functions, I get the "pointer being freed was not allocated" error even though I freed and allocated everything, or so I thought. A global variable doesn't do, either.

I would say that I don't really fully understand memory allocation, so I assume that my problem is with this, but it's entirely possible I just don't understand how to change variable values in C on a more basic level...

Answer 1

Functions receive a value-wise copy of their inputs to locally scoped variables. Thus a helper function cannot possibly change the value it was called with, only its local copy.

void f(int n)
{
    n = 2;
}

int main()
{
    int n = 1;
    f(n);
    return 0;
}

Despite having the same name, n in f is local to the invocation of f. So the n in main never changes.

The way to work around this is to pass by pointer:

int f(int *n)
{
    *n = 2;
}

int main()
{
    int n = 1;
    f(&n);
    // now we also see n == 2.
    return 0;
}

Note that, again, n in f is local, so if we changed the pointer n in f, it would have no effect on main's perspective. If we wanted to change the address n in main, we'd have to pass the address of the pointer.

void f1(int* nPtr)
{
    nPtr = malloc(sizeof int);
    *nPtr = 2;
}

void f2(int** nPtr)
{
    // since nPtr is a pointer-to-a-pointer,
    // we have to dereference it once to
    // reach the "pointer-to-int"
    // typeof nPtr = (int*)*
    // typeof *nPtr = int*

    *nPtr = malloc(sizeof int);

    // deref once to get to int*, deref that for int
    **nPtr = 2;
}

int main()
{
    int *nPtr = NULL;

    f1(nPtr); // passes 'NULL' to param 1 of f1.

    // after the call, our 'nPtr' is still NULL

    f2(&nPtr); // passes the *address* of our nPtr variable
    // nPtr here should no-longer be null.

    return 0;
}

---- EDIT: Regarding ownership of allocations ----

The ownership of pointers is a messy can of worms; the standard C library has a function strdup which returns a pointer to a copy of a string. It is left to the programmer to understand that the pointer is allocated with malloc and is expected to be released to the memory manager by a call to free.

This approach becomes more onerous as the thing being pointed to becomes more complex. For example, if you get a directory structure, you might be expected to understand that each entry is an allocated pointer that you are responsible for releasing.

dir = getDirectory(dirName);
for (i = 0; i < numEntries; i++) {
    printf("%d: %s\n", i, dir[i]->de_name);
    free(dir[i]);
}
free(dir);

If this was a file operation you'd be a little surprised if the library didn't provide a close function and made you tear down the file descriptor on your own.

A lot of modern libraries tend to assume responsibility for their resources and provide matching acquire and release functions, e.g. to open and close a MySQL connection:

// allocate a MySQL descriptor and initialize it.
MYSQL* conn = mysql_init(NULL);

DoStuffWithDBConnection(conn);

// release everything.
mysql_close(conn);

LibEvent has, e.g.

bufferevent_new();

to allocate an event buffer and

bufferevent_free();

to release it, even though what it actually does is little more than malloc() and free(), but by having you call these functions, they provide a well-defined and clear API which assumes responsibility for knowing such things.

This is the basis for the concept known as "RAII" in C++

Answer 2

By your description I'd suggest declaring x in your main function as a local variable (allocated from the stack) which you then pass by reference to your helper functions and return it from your main function by value.

int main()
{
    int x;       //local variable
    helper(&x);  //passed by reference
    return x;    //returned by value
}

Inside your helper you can modify the variable by dereferencing it and assigning whatever value needed:

void helper(int * x)
{
    *x = ...;    //change value of x
}

The alternative is declaring a pointer to x (which gets allocated from the heap) passing it to your helper functions and free-ing it when you have no use for it anymore. But this route requires more careful consideration and is error-prone.

Answer 3

The variable x will exist while the block in which it was declared is executed, even during helper execution, and giving a pointer to the helpers allows them to change its value. If I understand your problem right, you shouldn't need dynamic memory allocation. The following code returns 4 from mainFunction:

void plus_one(unsigned short* x)
{
  *x = *x + 1;
}

unsigned short mainFunction(void)
{
  unsigned short x = 0;
  plus_one(&x);
  plus_one(&x);
  plus_one(&x);
  plus_one(&x);
  return x;
}