#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");
}
malloc returns a void pointer to the allocated space, or NULL if there is insufficient memory available. To return a pointer to a type other than void , use a type cast on the return value.
C malloc() method The “malloc” or “memory allocation” method in C is used to dynamically allocate a single large block of memory with the specified size. It returns a pointer of type void which can be cast into a pointer of any form.
The problem with dynamic memory allocation is that it is not deallocated itself, developer responsibility to deallocate the allocated memory explicitly. If we cannot release the allocated memory, it can because of memory leak and make your machine slow.
malloc() normally fails today for one of two reason: (1) attempt to allocate more memory then is available, or (2) memory has been previously trashed (most common reason) such as buffer overflows and using uninitialized pointers (although there are a whole host of other causes).
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, =.
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.)
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With