12
#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");
}
BenMorel
  • 34,448
  • 50
  • 182
  • 322
niko
  • 9,285
  • 27
  • 84
  • 131
  • In addition to Mat's answer, don't forget to `#include ` so you get a proper declaration for `malloc()` (without it your 'working' code will be buggy on most 64-bit systems). – Michael Burr Jul 19 '11 at 06:58

3 Answers3

27

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.)

Mat
  • 202,337
  • 40
  • 393
  • 406
  • So how do i make a dynamically allocated memory as global ? no possibility to do that? – niko Jul 19 '11 at 05:58
  • 5
    Yes, your second example does just that. – Mat Jul 19 '11 at 05:59
  • To be more specific, malloc allocates memory that is "global" in the sense that it is accessible by any function that has a pointer to the address. By declaring 'y' outside of all of the functions, it is accessible by other functions. To understand the difference, suppose a function just called malloc and returned the result. When the function returns, the memory is still allocated. – Foo Bah Jul 19 '11 at 06:05
1

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, =.

Ayush Srivastava
  • 95
  • 11
1

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.

DTdev
  • 538
  • 1
  • 18
  • 32
  • and one more thing, there is nothing like "allocating memory globally". If your variable is global, like y in this case, your memory allocation will always take effect globally, where ever you call malloc function, but call malloc within any function – DTdev Jul 19 '11 at 08:14