¿Por qué tenemos que mencionar el tipo de datos de la variable en C

Por lo general, en C, tenemos que decirle a la computadora el tipo de datos en la declaración de variables. Por ejemplo, en el siguiente programa, quiero imprimir la suma de dos números de coma flotante X e Y.

#include<stdio.h>
main()
{
  float X=5.2;
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}

Tuve que decirle al compilador el tipo de variable X.

• ¿No puede el compilador determinar el tipo de Xpor sí mismo?

Sí, puede hacerlo si hago esto:

#define X 5.2

Ahora puedo escribir mi programa sin decirle al compilador el tipo de Xcomo:

#include<stdio.h>
#define X 5.2
main()
{
  float Y=5.1;
  float Z;
  Z=Y+X;
  printf("%f",Z);

}  

Entonces, vemos que el lenguaje C tiene algún tipo de característica, mediante la cual puede determinar el tipo de datos por sí mismo. En mi caso se determinó que Xes de tipo float.

• ¿Por qué tenemos que mencionar el tipo de datos cuando declaramos algo en main ()? ¿Por qué el compilador no puede determinar el tipo de datos de una variable por sí solo main()como lo hace en #define?

Está comparando declaraciones de variables con #defines, lo cual es incorrecto. Con a #define, crea una asignación entre un identificador y un fragmento de código fuente. El preprocesador C sustituirá literalmente cualquier aparición de ese identificador con el fragmento proporcionado. Escritura

#define FOO 40 + 2
int foos = FOO + FOO * FOO;

termina siendo lo mismo para el compilador que escribir

int foos = 40 + 2 + 40 + 2 * 40 + 2;

Piense en ello como copiar y pegar automatizado.

Además, las variables normales se pueden reasignar, mientras que una macro creada con #defineno se puede (aunque se puede reasignar #define). La expresión FOO = 7sería un error del compilador, ya que no podemos asignar "valores": 40 + 2 = 7es ilegal.

Entonces, ¿por qué necesitamos tipos? Aparentemente, algunos idiomas eliminan los tipos, esto es especialmente común en los lenguajes de secuencias de comandos. Sin embargo, generalmente tienen algo llamado "tipeo dinámico" donde las variables no tienen tipos fijos, pero los valores sí. Si bien esto es mucho más flexible, también es menos eficiente. A C le gusta el rendimiento, por lo que tiene un concepto de variables muy simple y eficiente:

Hay un tramo de memoria llamado "pila". Cada variable local corresponde a un área en la pila. Ahora la pregunta es ¿cuántos bytes tiene esta área? En C, cada tipo tiene un tamaño bien definido a través del cual puede consultar sizeof(type). El compilador necesita saber el tipo de cada variable para poder reservar la cantidad correcta de espacio en la pila.

¿Por qué las constantes creadas con #definenecesitan una anotación de tipo? No se almacenan en la pila. En cambio, #definecrea fragmentos reutilizables de código fuente de una manera ligeramente más fácil de mantener que copiar y pegar. Los literales en el código fuente, como el compilador "foo"o los 42.87almacena, ya sea en línea como instrucciones especiales o en una sección de datos separada del binario resultante.

Sin embargo, los literales tienen tipos. Un literal de cadena es a char *. 42es un intpero también se puede usar para tipos más cortos (conversión de reducción). 42.8sería a double. Si tiene un literal y desea que tenga un tipo diferente (por ejemplo, para hacer 42.8un float, o 42un unsigned long int), puede usar sufijos, una letra después del literal que cambia la forma en que el compilador trata ese literal. En nuestro caso, podríamos decir 42.8fo 42ul.

Algunos lenguajes tienen escritura estática como en C, pero las anotaciones de tipo son opcionales. Ejemplos son ML, Haskell, Scala, C #, C ++ 11 y Go. ¿Cómo funciona? ¿Magia? No, esto se llama "inferencia de tipos". En C # y Go, el compilador mira el lado derecho de una tarea y deduce el tipo de eso. Esto es bastante sencillo si el lado derecho es un literal como 42ul. Entonces es obvio cuál debería ser el tipo de variable. Otros lenguajes también tienen algoritmos más complejos que tienen en cuenta cómo se usa una variable. Por ejemplo, si lo hace x/2, xno puede ser una cadena, pero debe tener algún tipo numérico.

X en el segundo ejemplo nunca es un flotador. Se llama macro, reemplaza el valor macro definido 'X' en la fuente con el valor. Un artículo legible sobre #define está aquí .

En el caso del código suministrado, antes de la compilación, el preprocesador cambia el código

Z=Y+X;

a

Z=Y+5.2;

y eso es lo que se compila.

Eso significa que también puede reemplazar esos 'valores' con código como

#define X sqrt(Y)

o incluso

#define X Y

La respuesta corta es que C necesita tipos debido a la historia / que representa el hardware.

Historia: C se desarrolló a principios de la década de 1970 y pretendía ser un lenguaje para la programación de sistemas. El código es idealmente rápido y hace el mejor uso de las capacidades del hardware.

Habría sido posible inferir tipos en el momento de la compilación, pero los tiempos de compilación ya lentos habrían aumentado (consulte la caricatura de 'compilación' de XKCD. Esto solía aplicarse al 'hola mundo' durante al menos 10 años después de la publicación de C ). Inferir tipos en tiempo de ejecución no habría encajado con los objetivos de la programación de sistemas. La inferencia de tiempo de ejecución requiere una biblioteca de tiempo de ejecución adicional. C llegó mucho antes de la primera PC. Que tenía 256 RAM. No Gigabytes o Megabytes sino Kilobytes.

En su ejemplo, si omite los tipos

   X=5.2;
   Y=5.1;

   Z=Y+X;

Entonces, el compilador pudo haber deducido felizmente que X e Y son flotantes e hizo Z igual. De hecho, un compilador moderno también resolvería que X e Y no son necesarios y solo establecería Z en 10.3.

Suponga que el cálculo está incrustado dentro de una función. El escritor de funciones podría querer usar su conocimiento del hardware o el problema que se está resolviendo.

¿Sería un doble más apropiado que un flotador? Toma más memoria y es más lento, pero la precisión del resultado sería mayor.

Quizás el valor de retorno de la función podría ser int (o largo) porque los decimales no eran importantes, aunque la conversión de float a int no está exenta de costo.

El valor de retorno también se puede hacer doble garantizando que float + float no se desborde.

Todas estas preguntas parecen inútiles para la gran mayoría del código escrito hoy, pero fueron vitales cuando se produjo C.

C no tiene inferencia de tipos (así se llama cuando un compilador adivina el tipo de una variable para usted) porque es antigua. Fue desarrollado a principios de los años 70.

Muchos idiomas más nuevos tienen sistemas que le permiten usar variables sin especificar su tipo (ruby, javascript, python, etc.)