#include <stdio.h>
int main()
{
  void *var;
  int i = 22;
  var = &i;
  int *i_ptr = (int *)(var);
  if(i_ptr)
    printf("i_ptr: %d\n", *i_ptr);
  double d = 22.5;
  var = &d;
  double *d_ptr = (double *)(var);
  if(d_ptr)
    printf("d_ptr: %f\n", *d_ptr);
  return 0;
}

i_ptr: 22
d_ptr: 22.500000

void *var;
int i = 22;
var = (void *)(&i);

#include <stdio.h>
int lilround(const void *arg, const char type)
{
  if(type == 0) // если передан int
    return *((int *)arg); // просто возвращаем значение целого аргумента
  // если передан double
  double a = *((double *)arg);
  int b = (int)a;
  return b == (int)(a - 0.5) // если дробная часть >= 0.5
    ? b + 1 // округляем в плюс
    : b; // отбрасываем дробную часть
}
int main()
{
  int i = 12;
  double j = 12.5;
  printf("round int: %d\n", lilround(&i, 0)); // пытаемся округлить целое число
  printf("round double: %d\n", lilround(&j, 1)); // пытаемся округлить число двойной точности
  return 0;
}

round int: 12
round double: 13

int lilround(const void *arg, const char type)
{
  return type == 0
    ? *((int *)arg)
    : ((int)*((double *)arg) == (int)(*((double *)arg) - 0.5)
      ? (int)(*((double *)arg)) + 1
      : (int)(*((double *)arg)));
}

typedef struct {
  char type;
  int value;
} iStruct;
typedef struct {
  char type;
  double value;
} dStruct;

typedef struct {
  char type;
  int value;
} iStruct;
typedef struct {
  double value;
  char type;
} dStruct;

#include <stdio.h>
#pragma pack(push, 1)
typedef struct {
  char type; // идентификатор типа структуры
  int value; // целочисленное значение
} iStruct;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct {
  char type; // идентификатор типа структуры
  double value; // значение двойной точности
} dStruct;
#pragma pack(pop)
int lilround(const void *arg)
{
  iStruct *s = (iStruct *)arg;
  if(s->type == 0) // если передан int
    return s->value; // просто возвращаем значение целого аргумента
  // если передан double
  double a = ((dStruct *)arg)->value;
  int b = (int)a;
  return b == (int)(a - 0.5) // если дробная часть >= 0.5
    ? b + 1 // округляем в плюс
    : b; // отбрасываем дробную часть
}
int main()
{
  iStruct i;
  i.type = 0;
  i.value = 12;
  dStruct j;
  j.type = 1;
  j.value = 12.5;
  printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
  printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности
  return 0;
}

#include <stdio.h>
int main()
{
  int i = 22;
  void *var = &i; // объявляем void-указатель и инициализируем его адресом переменной i
  (*(int *)var)++; // приводим void-указатель к int-указателю, разыменовываем его и производим операцию инкремента
  printf("result: %d\n", i); // выводим измененное значение i
  return 0;
}

typedef struct {
  void (*printType)(); // указатель на функцию, выводящую тип
  int (*round)(const void *); // указатель на функцию, округляющую значение
} uMethods;

#include <stdio.h>
typedef struct {
  void (*printType)(); // указатель на функцию, выводящую тип
  int (*round)(const void *); // указатель на функцию, округляющую значение
} uMethods;
#pragma pack(push, 1)
typedef struct {
  uMethods m; // структура с указателями на функции
  int value; // целочисленное значение
} iStruct;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct {
  uMethods m; // структура с указателями на функции
  double value; // значение двойной точности
} dStruct;
#pragma pack(pop)
void intPrintType() // вывод типа для iStruct
{
  printf("integer\n");
}
int intRound(const void *arg) // округление для iStruct
{
  return ((iStruct *)arg)->value; // приводим аргумент к указателю на iStruct и возвращаем значение
}
void intInit(iStruct *s) // инициализация iStruct
{
  s->m.printType = intPrintType; // задаем полю printType указатель на функцию вывода для iStruct
  s->m.round = intRound; // задаем полю round указатель на функцию округления для iStruct
  s->value = 0;
}
void doublePrintType() // вывод типа для dStruct
{
  printf("double\n");
}
int doubleRound(const void *arg) // округление для dStruct
{
  double a = ((dStruct *)arg)->value;
  int b = (int)a;
  return b == (int)(a - 0.5) // если дробная часть >= 0.5
      ? b + 1 // округляем в плюс
      : b; // отбрасываем дробную часть
}
void doubleInit(dStruct *s)
{
  s->m.printType = doublePrintType; // задаем полю printType указатель на функцию вывода для dStruct
  s->m.round = doubleRound; // задаем полю round указатель на функцию округления для dStruct
  s->value = 0;
}
int lilround(const void *arg)
{
  ((iStruct *)arg)->m.printType(); // приводим к любой структуре, в данном случае iStruct, и выводим тип
  return ((iStruct *)arg)->m.round(arg); // возвращаем округленное значение
}
int main()
{
  iStruct i;
  intInit(&i); // инициализируем целочисленную структуру
  i.value = 12;
  dStruct j;
  doubleInit(&j); // инициализируем структуру с данными двойной точности
  j.value = 12.5;
  printf("round int: %d\n", lilround(&i)); // пытаемся округлить целое число
  printf("round double: %d\n", lilround(&j)); // пытаемся округлить число двойной точности
  return 0;
}

integer
round int: 12
double
round double: 13