Myujth

I have been banging my ahead on this problem for many hours now. Suppose you have a function that takes an int value as parameter. What I need to do is take this int value and interpret whatever the value is as # of bytes to be added to an address:

void* foo(int size)
 node->pointer += size; //assume node->pointer is of type void*

What the above does is actually add size*4 bytes to pointer because int is 4 bytes. casting this as (char*) i.e.

node->pointer += (char*)size; 

this does't work.
How do I do this in the most simple way?

If you don't mind using GCC extensions (Pointer arithmetic on void pointers and function pointers) and you're actually using GCC (or Clang), then you can write (more or less) what you wrote using +=:

void foo(int size)

 node->pointer += size; // Not standard — using GCC extension

It is not standard C, though, and therefore not portable. From C11 (ISO/IEC 9899:2011):

• 
  §6.2.5 Types ¶19: The void type comprises an empty set of values; it is an incomplete object type that cannot be completed.
  


• 
  §6.5.3.4 The sizeof and _Alignof operators: The sizeof operator shall not be applied to an expression that has function type or an incomplete type, to the parenthesized name of such a type, or …
  


• 
  §6.5.6 Additive operators: For addition, either both operands shall have arithmetic type, or one operand shall be a pointer to a complete object type and the other shall have integer type.
  


• 
  §6.5.6 Additive operators: For subtraction, one of the following shall hold:
  
  
  • both operands have arithmetic type;
  
  
  • both operands are pointers to qualified or unqualified versions of compatible complete object types; or
  
  
  • the left operand is a pointer to a complete object type and the right operand has integer type.
  
  


• 
  §6.5.16.2 Compound assignment ¶1: For the operators += and -= only, either the left operand shall be an atomic, qualified, or unqualified pointer to a complete object type, and the right shall have integer type; or the left operand shall have atomic, qualified, or unqualified arithmetic type, and the right shall have arithmetic type.
  

Since the void type is incomplete and cannot be completed, and therefore a void * is a pointer to an incomplete type, you can't use void with sizeof, nor can you use void * with + or - to do pointer arithmetic, and consequently you can't use void * with the compound assignments += and -= either.

The standard C equivalent would be:

void foo(int size)

 node->pointer = (char *)node->pointer + size;

This code doesn't return a value, any more than yours did (though you said it would because the return type was void *). Since node->pointer is a void *, you don't need a cast back to void *; this is C and the conversion is automatic.

writing a sample code for your reference. I used similar concept as answered above.

#include <stdio.h>

struct node
 int payload;
 void *ptr;
*n;

void foo(int x)
 n->ptr = (char *)n->ptr +x;


int main()
 n = malloc(sizeof(struct node));
 n->payload = 10; //random payload
 n->ptr = n;

 printf("%pn", n->ptr);
 foo(2); //increment by 2
 printf("%pn", n->ptr);