allocation

I wrote the following Code. #include<stdio.h> int main() { int x = 1 ; int *j = &x ; int y = 2 ; int *t = &y ; printf("%p\n" , (void *)j); printf("%p" , (void *)t); } Output is 0028FF14 0028FF10 . The Point I want to make is that the difference between the addresses is `4'. Whereas in this case #include<stdio.h> int main() { char x = 't' ; char *j = &x ; char y = 'f' ; char *t = &y ; printf("%p\n" , (void *)j); printf("%p" , (void *)t); } Output is 0028FF17 0028FF16 The difference is 1 . Difference In First Case is 4 . Whereas in the second case it is 1 . Why is it so? And What will I get if I

I'd /ike to know, how to pass pointers to dynamically allocated arrays using function arguments. This function is supposed to allocate array 10x10 (checks skipped for simplicity sake). Is this possible? What am i doing wrong? Thanks in advance. int array_allocate2DArray ( int **array, unsigned int size_x, unsigned int size_y) { array = malloc (size_x * sizeof(int *)); for (int i = 0; i < size_x; i++) array[i] = malloc(size_y * sizeof(int)); return 0; } int main() { int **array; array_allocate2DArray (*&array, 10, 10); } Try something like this: int array_allocate2DArray (int ***p, unsigned int

As everyone knows, the Visual C++ runtime marks uninitialized or just freed memory blocks with special non-zero markers. Is there any way to disable this behavior entirely without manually setting all uninitialized memory to zeros? It's causing havoc with my valid not null checks, since 0xFEEEFEEE != 0 . Hrm, perhaps I should explain a bit better. I create and initialize a variable (via new), and that all goes just fine. When I free it (via delete), it sets the pointer to 0xFEEEFEEE instead of NULL . When I insert a proper check for NULL , as all good programs that manage their own memory

I'm maintaining a plugin (implemented as a dll) for a big closed source application. This has been working fine for years. However, with the latest update to it's SDK the vendor overloaded global operators new and delete. This causes lots of trouble for me. What happens is that my plugin allocates a string. I pass this string into a statically linked library which modifies it (changes it's length thus reallocating it). My application crashes. The reason is of course, that the string lives on the vendor allocated custom heap. The statically linked library knows nothing about this heap and tries

I wanted to see that a dynamically loaded library (loaded with dlopen etc.) really uses its own new an delete operators and not these ones defined in the calling program. So I wrote the following library.cpp #include <exception> #include <new> #include <cstdlib> #include <cstdio> #include "base.hpp" void* operator new(size_t size) { std::printf("New of library called\n"); void *p=std::malloc(size); if (p == 0) // did malloc succeed? throw std::bad_alloc(); // ANSI/ISO compliant behavior return p; } void operator delete(void* p) { std::printf("Delete of library called\n"); std::free(p); } class

When can I get better performance using memcpy or how do I benefit from using it? For example: float a[3]; float b[3]; is code: memcpy(a, b, 3*sizeof(float)); faster than this one? a[0] = b[0]; a[1] = b[1]; a[2] = b[2]; Efficiency should not be your concern. Write clean maintainable code. It bothers me that so many answers indicate that the memcpy() is inefficient. It is designed to be the most efficient way of copy blocks of memory (for C programs). So I wrote the following as a test: #include <algorithm> extern float a[3]; extern float b[3]; extern void base(); int main() { base(); #if