incompatible tipo de indicador de advertencia

Tengo un programa en C como la de abajo. Estoy tratando de escribir un contenedor en la parte superior de malloc con la firma int myAlloc(). Este contenedor debe devolver 1 en un éxito de asignación de memoria o de retorno de 0 si la asignación de memoria falla.

#include <stdio.h>
#include <stdlib.h>

int myAlloc(void **ptr, int size)
{
    *ptr = malloc(size);

    if (!ptr)
        return 0;
    else
        return 1;
}

void main()
{
    int *p = NULL;
    myAlloc(&p, sizeof(int));
    printf("%d\n", *p);
}

Al compilar este me sale un aviso diciendo «incompatible tipo de puntero». ¿Cómo puedo hacer que sea posible para que esta función se llama con cualquier tipo de puntero sin recibir el aviso?

Es posible quitar el casting de operación de la función real de la llamada?

Actualización

He encontrado la respuesta. Aquí es el código corregido:

#include <stdio.h>
#include <stdlib.h>

int myAlloc(void *ptr,int size)
{
    *(void **)ptr = malloc(size);

    if (!ptr)
        return 0;
    else
        return 1;

}

int main()
{
    int *p = NULL;
    myAlloc(&p, sizeof(int));
    *p = 5;
    printf("%d\n", *p);

    return 1;
}
  • Este parece no ser el estándar de c, o C++, como main no devuelve void.
  • Usted está equivocado. Leer this.
  • He leído, y mi punto sigue en pie. Yo no creo que esto es en un entorno independiente, o alojado medio ambiente.
  • ese vínculo establece claramente que el principal debe devolver int. Pero esto no viene al caso
  • Creo que te refieres no creo que sea independiente, ya que tiene que ser un o el otro. Alojado es lo que la mayoría de la gente utiliza, Linux, Windows, etc, independiente está incrustado, el núcleo de Linux y así sucesivamente. Nada de lo dispuesto en el código o pregunta parece mandato que se aloja, pero usted está probablemente en lo cierto.
  • No creo que esto es independiente o alojado?? Todos los programas que se ha escrito jamás cae en cualquiera de estas dos categorías.
  • No. Leer. Nada en este post indica si este código está alojado o independiente.
  • Es convencional para asumir que publicó el código de C está diseñado para su uso en un entorno alojado como es, con mucho, el más comentario medio ambiente y además es mucho más completamente especificado. Si usted piensa que el código es independiente del entorno a continuación, usted podría afirmar que el punto de entrada no debe ser main o no debería ser uno que es de poca ayuda a nadie. Si el objetivo es un entorno alojado, a continuación, main debe ser definido de acuerdo con el tipo de devolución int.
  • Básicamente, no se sabe si el OP del programa está alojado o independiente. Pero void main() es simplemente tonto. Y el mal: se deben al menos ser void main(void). OTOH: si fuera independiente de la aplicación, el OP no se han hecho la pregunta en el primer lugar …
  • usted debe if(!*ptr) return 0;. nota: ¿ustedes por favor, dejemos de discutir sobre main()? 🙂
  • void main() y void main(void) son sólo diferentes en declaraciones que no son parte de una definición

InformationsquelleAutor user995487 | 2012-03-23

9 Kommentare

  1. 4

    su función, myMalloc toma un puntero a un puntero a void, o void** que está pasando la dirección de un puntero a int, o int**

    Usted necesita para lanzar el puntero pasa a ser nula por ejemplo

    myAlloc((void**)&p,sizeof(int));
    • sí, esto podría resolver. Pero, ¿Es posible quitar la operación de fundición lejos de la llamada a la función ?
    • esto se traduce en un comportamiento indefinido debido a la violación de estricta aliasing en *ptr=malloc(size) (C99 6.5 §7)
    • Yo no lo creo… plantillas de hacer que se instalan fácilmente, pero si mal no recuerdo C no tiene nada como plantillas. De otro modo, la sobrecarga de todos los tipos, pero eso es sólo va a causar problemas
  2. 0

    El error real que yo veo: que no puede ser el mismo que el suyo; no podemos saberlo, ya te olvidaste que nos muestre la salida real — se parece a esto:

    src.c: In function main’:
    src.c:15:17: warning: passing argument 1 of myAlloc from incompatible pointer type [enabled by default]
    src.c:4:5: note: expected void **’ but argument is of type int **’

    Que está pasando su myAlloc función de un int ** variable, pero su función está escrito para aceptar un void ** variable. Usted puede convertir el tipo de puntero en la llamada a la función como esta:

    myAlloc((void **)&p,sizeof(int));

    Y ahora compila sin advertencias.

    Usted lo desea, puede leer la los punteros sección de El Libro De Lenguaje C, especialmente la sección 5.3.5, que explícitamente aborda algunas de las cuestiones aquí planteadas.

    • No va a dar una advertencia, pero se puede bloquear. pensar en una plataforma que ha sizeof(int*)<sizeof(void*)
    • Esa es una de las razones por las que me he apuntado en la sección 5.3.5 de la C libro. Si usted echa un vistazo verás que explica esto.
  3. 0

    Esto puede parecer muy interesante, académicamente, pero que no es su código interno en el contenedor haciendo el mismo tipo de booleanos de verificación?

    void *ptr;
    if( (ptr = malloc(1000)) )
    {
      /* Do stuff with ptr */
    }
    else
    {
      /* throw a tantrum */
    }

    Lo que realmente necesita el int código de retorno con el parámetro adicional de complejidad?

  4. 0

    En C, hay un void* tipo general puntero, pero no hay un tipo general puntero a puntero. Peor aún, el tamaño de los diferentes tipos de punteros no pueden ser iguales. Por lo tanto, si su función no se sabe qué tipo de puntero debe asignar, no solo puede «poner los datos en la dirección», debido a que el tamaño de la derecha puntero puede ser diferente del tamaño del puntero de asignar.

    Por ejemplo, el código puede bloquearse (y es UB) si sizeof(int*)<sizeof(void*).

    Debido a esto, creo que es imposible escribir un contenedor como usted desea.

  5. 0

    No hay manera de escribir como una función compatible con los estándares de C como int * y void * no son compatibles con los tipos.

    Una (en su mayoría) equivalente definición de macro podría tener este aspecto:

    #define myAlloc(PTR, SIZE) (!!(PTR = malloc(SIZE)))
  6. 0
    #include <stdio.h>
    #include <stdlib.h>
    
    int myAlloc(void *ptr,int size)
    {
        *(void **)ptr=malloc(size);
        if(!ptr) return 0;
        else return 1;
    
    }
    
    int main()
    {
        int *p=NULL;
        myAlloc(&p,sizeof(int));
        *p=5;
        printf("%d\n",*p);
        return 1;
    }
  7. -1

    p es de tipo int*, mientras que su función acepta void**.

    myAlloc((void **)&p,sizeof(int));
  8. -1

    Como por la firma de myAlloc, usted debe llamar con myAlloc((void**)&p,sizeof(int)) puesto que p es int* (ptr a int) y no void* (ptr void).

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea