free

Memory is an issue for iphone ipad app, especially for ipad, if one wants to do something big. Well, these two snippets of codes can 1. get current available memory of the device; 2. force free memory. Can we use it in the app? Will appstore allow this? #import <mach/mach.h> #import <mach/mach_host.h> static void print_free_memory () { mach_port_t host_port; mach_msg_type_number_t host_size; vm_size_t pagesize; host_port = mach_host_self(); host_size = sizeof(vm_statistics_data_t) / sizeof(integer_t); host_page_size(host_port, &pagesize); vm_statistics_data_t vm_stat; if (host_statistics(host

void getFree(void *ptr) { if(ptr != NULL) { free(ptr); ptr = NULL; } return; } int main() { char *a; a=malloc(10); getFree(a); if(a==NULL) printf("it is null"); else printf("not null"); } Why is the output of this program not NULL? Because the pointer is copied by value to your function. You are assigning NULL to the local copy of the variable ( ptr ). This does not assign it to the original copy. The memory will still be freed, so you can no longer safely access it, but your original pointer will not be NULL . This the same as if you were passing an int to a function instead. You wouldn't

The function for freeing an instance of struct Foo is given below: void DestroyFoo(Foo* foo) { if (foo) free(foo); } A colleague of mine suggested the following instead: void DestroyFoo(Foo** foo) { if (!(*foo)) return; Foo *tmpFoo = *foo; *foo = NULL; // prevents future concurrency problems memset(tmpFoo, 0, sizeof(Foo)); // problems show up immediately if referred to free memory free(tmpFoo); } I see that setting the pointer to NULL after freeing is better, but I'm not sure about the following: Do we really need to assign the pointer to a temporary one? Does it help in terms of concurrency

Let’s consider this very short snippet of code: #include <stdlib.h> int main() { char* a = malloc(20000); char* b = realloc(a, 5); free(b); return 0; } After reading the man page for realloc, I was not entirely sure that the second line would cause the 19995 extra bytes to be freed. To quote the man page: The realloc() function changes the size of the memory block pointed to by ptr to size bytes. , but from that definition, can I be sure the rest will be freed? I mean, the block pointed by b certainly contains 5 free bytes, so would it be enough for a lazy complying allocator to just not do

Just to be clear: I do know that malloc and free are implemented in the C library, which usually allocates chunks of memory from the OS and does its own management to parcel out smaller lots of memory to the application and keeps track of the number of bytes allocated. This question is not How does free know how much to free . Rather, I want to know why free was made this way in the first place. Being a low-level language, I think it would be perfectly reasonable to ask a C programmer to keep track not only of what memory was allocated but how much (in fact, I commonly find that I end up

free(str); printf("%d\n", str->listeners); The call to printf succeeds (as do any other calls to str's members). How is this possible? You're just (un)lucky. That code exhibits undefined behavior - anything can happen, including looking like the memory wasn't freed. The memory is freed, but there is no point in actively clearing it, so its original content is likely to still be there. But you can't rely on that. Here's an analogy for you: imagine you're renting an apartment (that's the memory) and you terminate your lease but keep a duplicate of the key (that's the pointer). You might be able