pointer-arithmetic

here is the prototype: void *memset(void *s, int c, size_t n) first im not sure if I have to return something because when I use the memset i do for example memset(str, 'a', 5); instead of str = memset(str, 'a', 5); here is where I am with my code: void *my_memset(void *b, int c, int len) { int i; i = 0; while(b && len > 0) { b = c; b++; len--; } return(b); } int main() { char *str; str = strdup("hello"); my_memset(str, 'a', 5); printf("%s\n", str); } I dont want to use array in this function, to better understand pointer and memory, so I dont get 2 things: - how to copy the int c into a

I'm new in programming and learning about pointers in array. I'm a bit confused right now. Have a look at the program below: #include <stdio.h> int fun(); int main() { int num[3][3]={23,32,478,55,0,56,25,13, 80}; printf("%d\n",*(*(num+0)+1)); fun(num); printf("%d\n", *(*(num+0)+1)); *(*(num+0)+0)=23; printf("%d\n",*(*(num+0))); return 0; } int fun(*p) // Compilation error { *(p+0)=0; return 0; } This was the program written in my teacher's notes. Here in the main() function, in the printf() function dereference operator is being used two times because num is pointer to array so first time

This question already has answers here : How come an array's address is equal to its value in C? (6 answers) Closed 3 years ago . Look at the following code: #include <stdio.h> int main() { char str[80]; int n; scanf("%s%n",str,&n); printf("%s\t%d",str,n); putchar('\n'); getchar(); //to remove '\n' scanf("%s%n",&str,&n); printf("%s\t%d",str,n); return 0; } Here is the input and output: abc abc 3 123 123 3 As we know, scanf is a variable parametric function, so its parameters will not be cast when it's called. As a result, parameters must be passed in the type exactly what them should be.

Inspired by comments to my answer here . Is this sequence of steps legal in C standard (C11)? Make an array of function pointers Take a pointer to the first entry and cast that pointer to function pointer to void* Perform pointer arithmetic on that void* Cast it back to pointer to function pointer and dereference it. Or equivalently as code: void foo(void) { ... } void bar(void) { ... } typedef void (*voidfunc)(void); voidfunc array[] = {foo, bar}; // Step 1 void *ptr1 = array; // Step 2 void *ptr2 = (char*)ptr1 + sizeof(voidfunc); // Step 3 voidfunc bar_ptr = *(voidfunc*)ptr2; // Step 4 I

This question already has an answer here: Pointer/Address difference [duplicate] 3 answers I'm trying to find the distance in memory between two variables. Specifically I need to find the distance between a char[] array and an int. char data[5]; int a = 0; printf("%p\n%p\n", &data[5], &a); long int distance = &a - &data[5]; printf("%ld\n", distance); When I run my my program without the last two lines I get the proper memory address of the two variables, something like this: 0x7fff5661aac7 0x7fff5661aacc Now I understand, if I'm not wrong, that there are 5 bytes of distance between the two

When I executed the code of this question , I got this warning: warning: format '%d' expects argument of type 'int', but argument 2 has type 'long int' [-Wformat=] printf("P-Q: %d, P: %d, Q: %d", (p - q), p, q); ~^ ~~~~~~~ %ld As a reflex fix, I used %ld to print the subtraction of two pointers. And the compiler agreed. Fortunately, I saw a comment from another user mentioning that %td should be used, since the result type of the subtraction is ptrdiff_t . This answer confirms this claim. Now from GCC's header file of stddef.h , I can see that these types are equivalent in this case: typedef _

#include <stdio.h> int main() { int i,n; int a = 123456789; void *v = &a; unsigned char *c = (unsigned char*)v; for(i=0;i< sizeof a;i++) { printf("%u ",*(c+i)); } char *cc = (char*)v; printf("\n %d", *(cc+1)); char *ccc = (char*)v; printf("\n %u \n", *(ccc+1)); } This program generates the following output on my 32 bit Ubuntu machine. 21 205 91 7 -51 4294967245 First two lines of output I can understand => 1st Line : sequence of storing of bytes in memory. 2nd Line : signed value of the second byte value (2's complement). 3rd Line : why such a large value ? please explain the last line of

I was wondering how *(&array + 1) actually works. I saw this as an easy way to calculate the array length and want to understand it properly before using it. I'm not very experienced with pointer arithmetic, but with my understanding &array gives the address of the first element of the array. (&array + 1) would go to end of the array in terms of address. But shouldn't *(&array + 1) give the value, which is at this address. Instead it prints out the address. I would really appreciate your help to get the pointer stuff clear in my head. Here is the simple example I'm working on: int numbers[] =