Concepto de puntero vacío en programación C

¿Es posible desreferenciar un puntero vacío sin conversión de tipos en el lenguaje de programación C?

Además, ¿hay alguna forma de generalizar una función que pueda recibir un puntero y almacenarlo en un puntero vacío y, al usar ese puntero vacío, podemos hacer una función generalizada?

por ejemplo:

void abc(void *a, int b)
{
   if(b==1)
      printf("%d",*(int*)a);     // If integer pointer is received
   else if(b==2)
      printf("%c",*(char*)a);     // If character pointer is received
   else if(b==3)
      printf("%f",*(float*)a);     // If float pointer is received
}

Quiero hacer que esta función sea genérica sin usar sentencias if-else: ¿es esto posible?

Además, si hay buenos artículos en Internet que explican el concepto de un puntero nulo, sería beneficioso si pudiera proporcionar las URL.

Además, ¿es posible la aritmética de puntero con punteros vacíos?

¿Es posible desreferenciar el puntero vacío sin conversión de tipos en lenguaje de programación C ...

No, voidindica la ausencia de tipo, no es algo a lo que se pueda desreferenciar o asignar.

si hay alguna forma de generalizar una función que pueda recibir el puntero y almacenarlo en un puntero vacío y al usar ese puntero vacío podemos hacer una función generalizada.

No puede simplemente desreferenciarlo de forma portátil, ya que puede que no esté alineado correctamente. Puede ser un problema en algunas arquitecturas como ARM, donde el puntero a un tipo de datos debe estar alineado en el límite del tamaño del tipo de datos (por ejemplo, el puntero al entero de 32 bits debe estar alineado en el límite de 4 bytes para ser desreferenciado).

Por ejemplo, leyendo uint16_tde void*:

/* may receive wrong value if ptr is not 2-byte aligned */
uint16_t value = *(uint16_t*)ptr;
/* portable way of reading a little-endian value */
uint16_t value = *(uint8_t*)ptr
                | ((*((uint8_t*)ptr+1))<<8);

Además, es posible la aritmética del puntero con punteros vacíos ...

La aritmética del puntero no es posible en punteros voiddebido a la falta de valor concreto debajo del puntero y, por lo tanto, del tamaño.

void* p = ...
void *p2 = p + 1; /* what exactly is the size of void?? */

En C, a void *se puede convertir en un puntero a un objeto de un tipo diferente sin una conversión explícita:

void abc(void *a, int b)
{
    int *test = a;
    /* ... */

Sin embargo, esto no ayuda a escribir su función de una manera más genérica.

No puede desreferenciar a void *con convertirlo a un tipo de puntero diferente ya que al desreferenciar un puntero se obtiene el valor del objeto señalado. Un desnudo voidno es un tipo válido, por void *lo que no es posible desreferenciarlo .

La aritmética del puntero se trata de cambiar los valores del puntero por múltiplos de los sizeofobjetos apuntados. Nuevamente, debido a voidque no es un tipo verdadero, sizeof(void)no tiene significado, por lo que la aritmética del puntero no es válida void *. (Algunas implementaciones lo permiten, utilizando la aritmética de puntero equivalente para char *).

Debe tener en cuenta que en C, a diferencia de Java o C #, no hay absolutamente ninguna posibilidad de "adivinar" con éxito el tipo de objeto al que void*apunta un puntero. Algo similar a getClass()simplemente no existe, ya que esta información no se encuentra en ninguna parte. Por esa razón, el tipo de "genérico" que busca siempre viene con metainformación explícita, como int ben su ejemplo o la cadena de formato en la printffamilia de funciones.

Un puntero vacío se conoce como puntero genérico, que puede referirse a variables de cualquier tipo de datos.

Hasta ahora, mi comprensión del puntero vacío es la siguiente.

Cuando se declara una variable de puntero utilizando la palabra clave void, se convierte en una variable de puntero de uso general. La dirección de cualquier variable de cualquier tipo de datos (char, int, float, etc.) se puede asignar a una variable de puntero vacío.

main()
{
    int *p;

    void *vp;

    vp=p;
} 

Dado que se puede asignar otro puntero de tipo de datos al puntero vacío, entonces lo usé en la función absolut_value (el código se muestra a continuación). Para hacer una función general.

Traté de escribir un código C simple que toma un entero o flotante como argumento y trata de hacerlo + ve, si es negativo. Escribí el siguiente código,

#include<stdio.h>

void absolute_value ( void *j) // works if used float, obviously it must work but thats not my interest here.
{
    if ( *j < 0 )
        *j = *j * (-1);

}

int main()
{
    int i = 40;
    float f = -40;
    printf("print intiger i = %d \n",i);
    printf("print float f = %f \n",f);
    absolute_value(&i);
    absolute_value(&f);
    printf("print intiger i = %d \n",i);
    printf("print float f = %f \n",f);
    return 0;
}   

Pero recibía un error, así que llegué a saber que mi comprensión con el puntero de vacío no es correcta :(. Así que ahora me moveré hacia la recopilación de puntos, ¿por qué es así?

Lo que necesito entender más sobre los punteros nulos es eso.

Necesitamos encasillar la variable de puntero vacío para desreferenciarla. Esto se debe a que un puntero vacío no tiene ningún tipo de datos asociado. No hay forma de que el compilador pueda saber (¿o adivinar?) A qué tipo de datos apunta el puntero vacío. Por lo tanto, para tomar los datos señalados por un puntero vacío, los encasillamos con el tipo correcto de datos retenidos dentro de la ubicación de los punteros vacíos.

void main()

{

    int a=10;

    float b=35.75;

    void *ptr; // Declaring a void pointer

    ptr=&a; // Assigning address of integer to void pointer.

    printf("The value of integer variable is= %d",*( (int*) ptr) );// (int*)ptr - is used for type casting. Where as *((int*)ptr) dereferences the typecasted void pointer variable.

    ptr=&b; // Assigning address of float to void pointer.

    printf("The value of float variable is= %f",*( (float*) ptr) );

}

Un puntero nulo puede ser realmente útil si el programador no está seguro sobre el tipo de datos ingresados ​​por el usuario final. En tal caso, el programador puede usar un puntero vacío para apuntar a la ubicación del tipo de datos desconocido. El programa se puede configurar de tal manera que solicite al usuario que informe el tipo de datos y la conversión de tipos se puede realizar de acuerdo con la información ingresada por el usuario. A continuación se incluye un fragmento de código.

void funct(void *a, int z)
{
    if(z==1)
    printf("%d",*(int*)a); // If user inputs 1, then he means the data is an integer and type casting is done accordingly.
    else if(z==2)
    printf("%c",*(char*)a); // Typecasting for character pointer.
    else if(z==3)
    printf("%f",*(float*)a); // Typecasting for float pointer
}

Otro punto importante que debe tener en cuenta sobre los punteros vacíos es que: la aritmética del puntero no se puede realizar en un puntero vacío.

void *ptr;

int a;

ptr=&a;

ptr++; // This statement is invalid and will result in an error because 'ptr' is a void pointer variable.

Así que ahora entendí cuál fue mi error. Estoy corrigiendo lo mismo.

Referencias

http://www.antoarts.com/void-pointers-in-c/

http://www.circuitstoday.com/void-pointers-in-c .

El nuevo código es como se muestra a continuación.

#include<stdio.h>
#define INT 1
#define FLOAT 2

void absolute_value ( void *j, int *n)
{
    if ( *n == INT) {
        if ( *((int*)j) < 0 )
            *((int*)j) = *((int*)j) * (-1);
    }
    if ( *n == FLOAT ) {
        if ( *((float*)j) < 0 )
            *((float*)j) = *((float*)j) * (-1);
    }
}


int main()
{
    int i = 0,n=0;
    float f = 0;
    printf("Press 1 to enter integer or 2 got float then enter the value to get absolute value\n");
    scanf("%d",&n);
    printf("\n");
    if( n == 1) {
        scanf("%d",&i);
        printf("value entered before absolute function exec = %d \n",i);
        absolute_value(&i,&n);
        printf("value entered after absolute function exec = %d \n",i);
    }
    if( n == 2) {
        scanf("%f",&f);
        printf("value entered before absolute function exec = %f \n",f);
        absolute_value(&f,&n);
        printf("value entered after absolute function exec = %f \n",f);
    }
    else
    printf("unknown entry try again\n");
    return 0;
}   

Gracias,

No, no es posible. ¿Qué tipo debe tener el valor desreferenciado?

void abc(void *a, int b) {
  char *format[] = {"%d", "%c", "%f"};
  printf(format[b-1], a);
}

Quiero hacer que esta función sea genérica, sin usar ifs; ¿Es posible?

La única forma simple que veo es utilizar la sobrecarga ... que no está disponible en el lenguaje de programación C AFAIK.

¿Consideró el lenguaje de programación C ++ para su programa? ¿O hay alguna restricción que prohíba su uso?

Aquí hay un breve puntero sobre voidpunteros: https://www.learncpp.com/cpp-tutorial/613-void-pointers/

6.13 - Punteros vacíos

Debido a que el puntero vacío no sabe a qué tipo de objeto está apuntando, ¡no puede ser desreferenciado directamente! Por el contrario, el puntero nulo primero debe convertirse explícitamente a otro tipo de puntero antes de desreferenciarse.

Si un puntero vacío no sabe a qué apunta, ¿cómo sabemos a qué lanzarlo? En última instancia, eso depende de usted para realizar un seguimiento.

Miscelánea de puntero vacío

No es posible hacer aritmética de puntero en un puntero vacío. Esto se debe a que la aritmética del puntero requiere que el puntero sepa a qué tamaño de objeto está apuntando, por lo que puede aumentar o disminuir el puntero adecuadamente.

Suponiendo que la memoria de la máquina es direccionable por bytes y no requiere accesos alineados, la forma más genérica y atómica (más cercana a la representación a nivel de máquina) de interpretar a void*es como un puntero a un byte uint8_t*. Lanzar un void*a a uint8_t*le permitiría, por ejemplo, imprimir los primeros 1/2/4/8 / sin embargo, muchos bytes que desee a partir de esa dirección, pero no puede hacer mucho más.

uint8_t* byte_p = (uint8_t*)p;
for (uint8_t* i = byte_p; i < byte_p + 8; i++) {
  printf("%x ",*i);
}

Puede imprimir fácilmente una impresora vacía

int p=15;
void *q;
q=&p;
printf("%d",*((int*)q));

Debido a que C es un lenguaje fuertemente tipado estáticamente, debe decidir el tipo de variable antes de compilar. Cuando intentes emular genéricos en C, terminarás intentando reescribir C ++ nuevamente, por lo que sería mejor usar C ++ en su lugar.

El puntero vacío es un puntero genérico. La dirección de cualquier tipo de datos de cualquier variable puede asignarse a un puntero vacío.

int a = 10;
float b = 3.14;
void *ptr;
ptr = &a;
printf( "data is %d " , *((int *)ptr)); 
//(int *)ptr used for typecasting dereferencing as int
ptr = &b;
printf( "data is %f " , *((float *)ptr));
//(float *)ptr used for typecasting dereferencing as float

No puede desreferenciar un puntero sin especificar su tipo porque los diferentes tipos de datos tendrán diferentes tamaños en la memoria, es decir, un int es de 4 bytes, un char es de 1 byte.

Básicamente, en C, los "tipos" son una forma de interpretar los bytes en la memoria. Por ejemplo, cuál es el siguiente código

struct Point {
  int x;
  int y;
};

int main() {
  struct Point p;
  p.x = 0;
  p.y = 0;
}

Dice "Cuando ejecuto main, quiero asignar 4 (tamaño de entero) + 4 (tamaño de entero) = 8 (bytes totales) de memoria. Cuando escribo '.x' como valor de l en un valor con la etiqueta de tipo Apunte al tiempo de compilación, recupere datos de la ubicación de la memoria del puntero más cuatro bytes. Dé al valor de retorno la etiqueta de tiempo de compilación "int".

Dentro de la computadora en tiempo de ejecución, su estructura de "Punto" se ve así:

00000000 00000000 00000000 00000000 00000000 00000000 00000000

Y así es void*como se vería su tipo de datos: (suponiendo que una computadora de 32 bits)

10001010 11111001 00010010 11000101

Esto no funcionará, pero void * puede ayudar mucho a definir el puntero genérico a las funciones y pasarlo como argumento a otra función (similar a la devolución de llamada en Java) o definirlo como una estructura similar a oop.