Pourquoi devons-nous mentionner le type de données de la variable en C

Habituellement en C, nous devons indiquer à l'ordinateur le type de données dans la déclaration de variable. Par exemple, dans le programme suivant, je veux imprimer la somme de deux nombres à virgule flottante X et Y.

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

}

J'ai dû dire au compilateur le type de variable X.

• Le compilateur ne peut-il pas déterminer le type de Xlui-même?

Oui, je peux le faire:

#define X 5.2

Je peux maintenant écrire mon programme sans dire au compilateur le type de X:

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

}  

Nous voyons donc que le langage C a une sorte de fonctionnalité, à l'aide de laquelle il peut déterminer lui-même le type de données. Dans mon cas, il a déterminé qu'il Xest de type float.

• Pourquoi devons-nous mentionner le type de données, lorsque nous déclarons quelque chose dans main ()? Pourquoi le compilateur ne peut-il pas déterminer seul le type de données d'une variable main()comme il le fait dans #define.

Vous comparez des déclarations de variables à #defines, ce qui est incorrect. Avec a #define, vous créez un mappage entre un identifiant et un extrait de code source. Le préprocesseur C remplacera alors littéralement toutes les occurrences de cet identifiant par l'extrait fourni. L'écriture

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

finit par être la même chose pour le compilateur que l'écriture

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

Considérez-le comme un copier-coller automatisé.

De plus, les variables normales peuvent être réassignées, alors qu'une macro créée avec #definene peut pas (bien que vous puissiez la réutiliser #define). L'expression FOO = 7serait une erreur de compilation, car nous ne pouvons pas attribuer à «rvalues»: 40 + 2 = 7est illégal.

Alors, pourquoi avons-nous besoin de types? Certains langages se débarrassent apparemment des types, ceci est particulièrement courant dans les langages de script. Cependant, ils ont généralement quelque chose appelé «typage dynamique» où les variables n'ont pas de types fixes, mais les valeurs en ont. Bien que cela soit beaucoup plus flexible, il est également moins performant. C aime les performances, il a donc un concept de variables très simple et efficace:

Il y a une partie de la mémoire appelée «pile». Chaque variable locale correspond à une zone de la pile. Maintenant, la question est de combien d’octets cette zone doit-elle avoir? En C, chaque type a une taille bien définie que vous pouvez interroger via sizeof(type). Le compilateur a besoin de connaître le type de chaque variable pour pouvoir réserver la bonne quantité d'espace sur la pile.

Pourquoi les constantes créées avec n'ont-elles pas #definebesoin d'une annotation de type? Ils ne sont pas stockés sur la pile. Au lieu de cela, #definecrée des extraits de code source réutilisables d'une manière légèrement plus maintenable que le copier-coller. Les littéraux dans le code source tels que "foo"ou 42.87sont stockés par le compilateur soit en ligne sous forme d'instructions spéciales, soit dans une section de données distincte du binaire résultant.

Cependant, les littéraux ont des types. Un littéral de chaîne est un char *. 42est un intmais peut également être utilisé pour les types plus courts (rétrécissement de la conversion). 42.8serait un double. Si vous avez un littéral et que vous voulez qu'il ait un type différent (par exemple pour créer 42.8un floatou 42un unsigned long int), vous pouvez utiliser des suffixes - une lettre après le littéral qui change la façon dont le compilateur traite ce littéral. Dans notre cas, nous pourrions dire 42.8fou 42ul.

Certaines langues ont un typage statique comme en C, mais les annotations de type sont facultatives. Les exemples sont ML, Haskell, Scala, C #, C ++ 11 et Go. Comment ça marche? La magie? Non, cela s'appelle «inférence de type». En C # et Go, le compilateur examine le côté droit d'une affectation et en déduit le type. C'est assez simple si le côté droit est un littéral tel que 42ul. Il est alors évident quel devrait être le type de la variable. D'autres langages ont également des algorithmes plus complexes qui prennent en compte la façon dont une variable est utilisée. Par exemple, si vous le faites x/2, alors xne peut pas être une chaîne mais doit avoir un certain type numérique.

X dans le deuxième exemple n'est jamais un flottant. Elle s'appelle une macro, elle remplace la valeur de macro définie «X» dans la source par la valeur. Un article lisible sur #define est ici .

Dans le cas du code fourni, avant la compilation, le préprocesseur change le code

Z=Y+X;

à

Z=Y+5.2;

et c'est ce qui est compilé.

Cela signifie que vous pouvez également remplacer ces «valeurs» par du code comme

#define X sqrt(Y)

ou même

#define X Y

La réponse courte est que C a besoin de types en raison de l'historique / représentant le matériel.

Historique: C a été développé au début des années 1970 et a été conçu comme un langage pour la programmation de systèmes. Le code est idéalement rapide et tire le meilleur parti des capacités du matériel.

L'inférence de types au moment de la compilation aurait été possible, mais les temps de compilation déjà lents auraient augmenté (voir le dessin animé de compilation de XKCD. Cela s'appliquait au `` bonjour le monde '' pendant au moins 10 ans après la publication de C ). L'inférence de types lors de l'exécution n'aurait pas correspondu aux objectifs de la programmation des systèmes. L'inférence à l'exécution nécessite une bibliothèque d'exécution supplémentaire. C est venu bien avant le premier PC. Qui avait 256 RAM. Pas des gigaoctets ou mégaoctets mais des kilo-octets.

Dans votre exemple, si vous omettez les types

   X=5.2;
   Y=5.1;

   Z=Y+X;

Ensuite, le compilateur aurait pu comprendre que X & Y sont des flottants et faire de Z la même chose. En fait, un compilateur moderne déterminerait également que X & Y ne sont pas nécessaires et définirait simplement Z à 10,3.

Supposons que le calcul soit intégré dans une fonction. L'auteur de la fonction peut vouloir utiliser ses connaissances du matériel ou résoudre le problème.

Un double serait-il plus approprié qu'un flotteur? Prend plus de mémoire et est plus lent mais la précision du résultat serait plus élevée.

Peut-être que la valeur de retour de la fonction pourrait être int (ou longue) car les décimales n'étaient pas importantes, bien que la conversion de float en int ne soit pas sans coût.

La valeur de retour pourrait également être rendue double en garantissant que flotteur + flotteur ne déborde pas.

Toutes ces questions semblent inutiles pour la grande majorité du code écrit aujourd'hui, mais étaient vitales lorsque C a été produit.

C n'a pas d'inférence de type (c'est ce qu'on appelle quand un compilateur devine le type d'une variable pour vous) car il est ancien. Il a été développé au début des années 1970

De nombreux langages récents ont des systèmes qui vous permettent d'utiliser des variables sans spécifier leur type (ruby, javascript, python, etc.)