Malloc function (dynamic memory allocation) resulting in an error when it is used globally

Question

#include<stdio.h>
#include<string.h>
char *y;
y=(char *)malloc(40); // gives an error here
int main()
{
    strcpy(y,"hello world");
}

---

error: conflicting types for 'y'
error: previous declaration of 'y' was here
warning: initialization makes integer from pointer without a cast
error: initializer element is not constant
warning: data definition has no type or storage class
warning: passing arg 1 of `strcpy' makes pointer from integer without cast

Now the real question is, can't we make the dynamic memory allocation globally? Why does it show an error when I use malloc globally? And the code works with no error if I put malloc statement inside the main function or some other function. Why is this so?

#include<stdio.h>
#include<string.h>
char *y;
int main()
{
    y=(char *)malloc(40); 
    strcpy(y,"hello world");
}

Answer 1

You can't execute code outside of functions. The only thing you can do at global scope is declaring variables (and initialize them with compile-time constants).

malloc is a function call, so that's invalid outside a function.

If you initialize a global pointer variable with malloc from your main (or any other function really), it will be available to all other functions where that variable is in scope (in your example, all functions within the file that contains main).

(Note that global variables should be avoided when possible.)

Answer 2

well, it is not about using malloc globally. your malloc process must reside within any function, main or any other user defined function. Globally you can only delare the variable. As 'y' is declared globally, malloc is a function call. that must reside inside any function. Not only malloc, u can't call any function as you have called here. you can only declare function as global or local there.

Answer 3

You cannot use a function call when initializing a static or global variable. In the following code sequence, we declare a static variable and then attempt to initialize it using malloc:

static int *pi = malloc(sizeof(int));

This will generate a compile-time error message. The same thing happens with global variables but can be avoided for static variables by using a separate statement to allocate memory to the variable as follows. We cannot use a separate assignment statement with global variables because global variables are declared outside of a function and executable code, such as the assignment statement, must be inside of a function: static int *pi; pi = malloc(sizeof(int));

From the compiler standpoint, there is a difference between using the initialization operator, =, and using the assignment operator, =.