are heap variables global variables and what is the scope and lifetime of heap variables

Question

#include<stdio.h>
#include<conio.h>
#include<alloc.h>

int * makearray(int );
void readdata(int *,int );
void printdata(int *,int );

void main()
{
    int *a,num;
    clrscr();
    printf("enter the size of array\n");
    scanf("%d",&num);
    a=makearray(num);
    readdata(temp,num);
    printdata(a,num);
    getch();
}

int * makearray(int n)
{
    int *temp;
    temp=(int *)malloc(sizeof(int)*n);
    printf("address of temp is %x and value of temp is %d and first value of            temp is garbage i.e %d\n",&temp,temp,*temp);
    return temp;
}

void readdata(int *x,int n)
{
    for(n--; n>=0; n--)
    {
        printf("enter the value in cell[%d]\n",n);
        scanf("%d",x+n);
    }
    return;
}

void printdata(int *x,int n)
{
    for(n--; n>=0; n--)
        printf("the value in cell[%d] is %d",n,*(x+n));
    return;
}

in the following code I want to know since the scope of heap variables if for the duration of the program why is temp shown as unidentified symbol in the program?

Also I want to know what is the lifetime and scope of the heap variables.

Also I want to know that since a variable is reserved a space in memory only when it is initialized when we return the pointer temp a is initialized but what happens to temp after that ? Does it remain initialized or it is freed.

Answer 1

I think you're mixing up two concepts, scope and lifetime.

Quoting C11, chapter §6.2.1

For each different entity that an identifier designates, the identifier is visible (i.e., can be used) only within a region of program text called its scope. [...]

and

The lifetime of an object is the portion of program execution during which storage is guaranteed to be reserved for it. An object exists, has a constant address,³³⁾ and retains its last-stored value throughout its lifetime. [....]

The problem here is, the identifier temp has a block scope of function makearray(). The value held by temp (a pointer) is returned by a memory allocator functions and thus obviously it has a liferime until it's deallocated but that does not mean the temp variable itself has a file scope.

You have used another variable a to store the return value of makearray(), so use that.

Answer 2

Sourav Ghosh's answer is in some ways better than this one. In particular, it's probably easier to understand if you're not a language lawyer. I'm going to expand on what he wrote and offer some (hopefully constructive) criticism of the code in the question.

C actually has no concept of "global" variables. In fact the C standard doesn't even use the term "variable" (at least not in the usual sense). It uses the word "object", and it's not entirely clear which objects are or are not "variables".

As Sourav's answer correctly says, scope and lifetime are two different things. The scope of an identifier is the region of C program text in which that identifier is visible; it's a compile-time concept. The lifetime of an object is the period of time during which that object exists; it's a run-time concept.

Here's the relevant function from your question:

int * makearray(int n)
{
    int *temp;
    temp=(int *)malloc(sizeof(int)*n);
    // printf call skipped for now
    return temp;
}

temp is a local pointer object of type int*. The name temp is visible only from the declaration to the closing }. The lifetime of the pointer object (which has automatic storage duration) is the execution of the enclosing block; the pointer object ceases to exist when the function returns. (The return temp; is perfectly valid; it returns a copy of the value of the object, so it doesn't matter that the object itself no longer exists.)

The malloc function creates a new object. That object has no name of its own, so it has no scope. Its lifetime starts with the call to malloc and continues until the storage is explicitly deallocated by a call to free (or realloc, but we can ignore that), or until the program completes.

In main, you have:

a=makearray(num);
readdata(temp,num);

The name temp is local to your makearray function, so it's not visible in main -- and the pointer object doesn't even exist at that point. But you've just assigned the value to a. You simply need to change

readdata(temp, num);

to

readdata(a, num);

---

Now let's take a look at some of the other problems in your code.

#include<alloc.h>

This is not a standard header. The malloc function is declared in <stdlib.h>.

void main()

Some compilers will accept this, but it's non-standard. Use int main(void) instead.

temp=(int *)malloc(sizeof(int)*n);

Don't cast the result of malloc. It returns a result of type void*, which can be implicitly converted to whatever pointer type you need. The recommended idiom is:

temp = malloc(n * sizeof *temp);

By using sizeof *temp rather than sizeof(int) you avoid the risk of using the wrong type and quietly allocating the wrong size. You can write sizeof(*temp) rather than sizeof *temp if you find it more readable; either is valid.

And you should check whether the malloc call succeeded. If malloc fails, it returns a null pointer. You can add something like:

if (temp == NULL)
{
    fprintf(stderr, "malloc failed\n");
    exit(EXIT_FAILURE);
}

A small allocation like this is unlikely to fail, but you should develop good habits.

printf("address of temp is %x and value of temp is %d and first value of temp is garbage i.e %d\n",&temp,temp,*temp);

Let's split that up:

printf("address of temp is %x\n", &temp);

That prints the address of the pointer object temp (which is not particularly useful information, but curiosity is a good thing). %x requires an argument of type unsigned int. To print a pointer value, use %p, which requires an argument of type void*; use a cast if the pointer value you're printing is of some other type:

printf("address of temp is %p\n", (void*)&temp);

Moving on.

printf("value of temp is %p\n", (void*)temp);

Again, use %p to print a pointer value.

printf("first value of temp is garbage, i.e., %d\n", *temp);

This is ok. (Strictly speaking the behavior is undefined, and the information is not useful, but again curiosity is a good thing.)

You have a couple of calls to scanf, and you assume that they will successfully read valid data. scanf, if it's successful, returns the number of items it scanned. You should check that. For example:

int count = scanf("%d",&num);
if (count != 1)
{
    fprintf(stderr, "scanf failed\n");
    exit(EXIT_FAILURE);
}

A more robust program would take some corrective action (like asking again), but for now terminating on any error is ok, and better than quietly ignoring errors.