error de tipos conflictivos en C

Para el siguiente código C (para intercambiar dos números) recibo el error “tipos en conflicto” para la función de swap .

 #include  #include  void main() { int a,b; printf("enter the numbers to be swapped"); scanf("%d%d",&a,&b); printf("before swap"); printf("a=%d,b=%d",a,b); swap(&a,&b,sizeof(int)); printf("after swap"); printf("a=%d,b=%d",a,b); getch(); } void swap(void *p1,void *p2,int size) { char buffer[size]; memcpy(buffer,p1,size); memcpy(p1,p2,size); memcpy(p2,buffer,size); return(0); } 

¿Alguien puede decir por qué viene ese error?
¿Cuál es la solución para eso?

El problema es que el swap no fue declarado antes de ser usado. Por lo tanto, se le asigna una “firma predeterminada”, una que en este caso no coincidirá con su firma real. Cita a andrey t :

Los argumentos se pasan a través de un conjunto de conversiones estrictamente definidas. int * punteros int * se pasarán como punteros int * , por ejemplo. En otras palabras, los tipos de parámetros se “deducen” temporalmente de los tipos de argumentos. Solo se asume que el tipo de retorno es int .

Aparte de eso, su código produce un montón de otras advertencias. Si usa gcc , compile con -Wall -pedantic (o incluso con -Wextra ), y asegúrese de corregir cada advertencia antes de continuar progtwigndo una funcionalidad adicional. Además, puede querer decirle al comstackdor si está escribiendo ANSI C ( -ansi ) o C99 ( -std=c99 ).

Algunas observaciones:

  • Pon espacios después de comas.
  • Hacer main retorno un int .
    • Y haz que return 0 o return EXIT_SUCCESS .
  • Importe la definición de getch : #include .
    • O simplemente use getchar .
  • Importe la definición de memcpy : #include .
  • No devuelva algo en una función de void .
  • Es posible que desee utilizar malloc para asignar un búfer de tamaño variable. Eso también funcionará con comstackdores más viejos:

     void swap(void *p1, void *p2, int size) { void *buffer = malloc(size); memcpy(buffer, p1, size); memcpy(p1, p2, size); memcpy(p2, buffer, size); free(buffer); } 

Necesitas declarar swap antes de usarlo. Por ejemplo, coloque swap sobre main, o agregue un prototipo para swap como este:

 void swap(void *,void *,int); int main () 

Por cierto, main debe ser int no void y normalmente devuelve el valor cero, a menos que haya un error.

En primer lugar, el mensaje de error real no haría daño.

En segundo lugar, crear un búfer de [tamaño] solo funciona en algunos comstackdores (esa es una característica nueva, no todos los comstackdores lo tienen todavía). ¿Estás seguro de que el tuyo?

En tercer lugar, debe declarar swap antes de llamarlo. Agrega un prototipo en la parte superior del archivo:

 void swap(void *p1,void *p2,int size); 

No pudo declarar su swap explícitamente, forzando al comstackdor a hacer suposiciones sobre la función en el punto de la llamada. El comstackdor, de acuerdo con las reglas de C, asumirá que el swap es

 int swap(int *, int *, size_t) 

Después declaras tu canje como

 void swap(void *, void *, int) 

lo que obviamente es diferente de lo que asumió el comstackdor. Este es el conflicto del que te habla el comstackdor.

Además, su void swap intenta return 0 . ¿Qué estabas tratando de lograr con eso?

PS Es int main , no void main .

PPS No se garantiza que el progtwig produzca ninguna salida si su salida no termina en un carácter de nueva línea.

Puede que se pregunte por qué el progtwig se comstack sin un prototipo para swap (), y eso es porque el comstackdor es más que una herramienta C99. También comstack progtwigs C89 y K&R C.

C89 agregó los prototipos. Antes de C89, el comstackdor no necesitaba ver la statement (el prototipo) de una función a menos que devolviera algo distinto de int y los comstackdores no conocían los tipos de parámetros formales. El comstackdor acaba de llamar a todas las funciones con los tipos de argumentos reales, que recibieron un conjunto de promociones de argumentos predeterminadas para simplificar las cosas. El progtwigdor ejecutaría la utilidad de lint para verificar los parámetros reales y formales. Este progtwig todavía se envía con las distribuciones BSD.

El comstackdor sigue aceptando los progtwigs K&R y sus estilos de código correspondientes, de modo que cuando ve una función para la que no hay ningún prototipo disponible, simplemente continúa y lo llama de todos modos.

En este caso, cambia los paradigmas entre la llamada y la definición de la función. Las suposiciones de K&R C que hizo el comstackdor sobre la función no declarada cuando tuvo que generar una llamada resultó no ser válida. Incluso si hubiera escrito todo el progtwig en el estilo K&R, el comstackdor habría hecho las mismas quejas cuando descubrió los tipos reales de los argumentos de la función.

Con GCC, esto es una advertencia,
cuando no declara una función antes de usarla, el comstackdor intenta adivinar la statement utilizando el tipo de llamada realizada a esa función. De esta manera, el comportamiento.

Bueno, se comstack en http://codepad.org (después de eliminar el getch() , que es irrelevante). ¿Tal vez su comstackdor se queja sobre el uso de memcpy en punteros no restringidos?

En swap() p1 y p2 no se garantiza que no sean alias. Este es un error real en espera de suceder: llamar a swap en &a[i] y &a[j] puede explotar memcpy cuando i==j . Utilice memmove (que se garantiza que no explotará en áreas superpuestas) o declare los punteros restricted .