Tapé vs sans type de langue

En C, nous avons un simple système de type, mais il n'est pas particulièrement sophistiqué, peut être (et c'est souvent le cas dans la pratique) contournée avec complètement incontrôlée des moulages, etc. (Pour ces raisons, C est souvent appelé "faiblement typé", qui est mal défini et généralement utilisé pour dénigrer un langage, mais au moins, dit que les types ne sont pas que important.) La taille, la disposition et alignement des types n'est pas fixe, mais il sera généralement être cohérente avec le même compilateur (version) sur la même plate-forme. Un int peut être 14 bits de large, etc., ces choses ne sont pas garantis (sauf que la C normes de certains de commande entre la base intégrales types, par exemple short ne doit pas être plus grand que int).

Le programmeur n'a pas à connaître les détails, mais le compilateur ne et en fait qui doit. Par exemple, le code exact généré pour foo.y où struct Foo { int x; short y; }; et struct Foo foo; dépend par exemple sur la taille exacte de int et short et sur le rembourrage de struct Foo, comme il compile à "prendre l'adresse de foo, ajouter le décalage de y dans struct Foo, et de l'utiliser". Même les struct Foo foo; nécessite la connaissance exacte de struct Foo (et, de manière récursive, les types, il est composé d') - le code généré doit savoir exactement sizeof(struct Foo) pour réserver le bon nombre d'octets sur la pile? De même, les déclarations de type sont nécessaires pour savoir qui opcodes à utiliser pour les mathématiques (iadd ou fadd ou plus? Doit l'un des opérandes, et de quelle taille?), comparisions, la taille de pas de quand on fait de l'arithmétique des pointeurs (p + n ajoute réellement n * sizeof(*p)), etc. Cela empêche également l'accès inexistant membres (et, par extension, la transmission de valeurs de fonctions qui seraient ensuite exécuter ce problème - c'est à dire d'incompatibilité de type), mais qui ressemble plus à une pratique d'effets secondaires, le compilateur considère comme une erreur car ne sais pas ce code d'émettre, non pas parce qu'il croit que les programmeurs sont comme des enfants qui doit être surveillé et gardé dans l'ordre.

En langage d'assemblage (habituellement pas plus tard qu'hier j'ai lu sur un projet de Recherche Microsoft qui développe un typée, verifyable langage d'assemblage pour un OS qui est sûr à l'encontre de certains bugs de la construction), vous n'avez pas vraiment des types. Vous avez octets. Vous prenez N octets à partir d'un certain endroit, de faire quelques choses pour eux, et de les stocker à un certain endroit. Ouais, les registres sont fixes pour certains la taille de mot et certains peuvent être destinés à des types particuliers de valeurs (par exemple dédié à virgule flottante registres avec 80 bits ou plus), mais, fondamentalement, vous pouvez stocker tout ce que vous aimez n'importe où. Personne ne vous empêche de stockage de 8 octets, quelque part, plus tard lecture seulement le dernier de 4 octets et en les ajoutant à votre compteur de boucle pour former une adresse pour stocker la valeur de retour à.

Dans d'autres langues, le système de type est beaucoup plus fort, tout en permettant une vaste gamme d'extensions qui permettent de programmation plus haut niveau, tels que l'abstraction les types exacts (et par conséquent, leur mise en page et de la frappe) et il suffit de prendre n'importe quel type capable de réaliser un certain contrat. Il permet la signature type comme [a] -> a, qui est une fonction prenant une liste contenant tout type de valeur (tant que c'est homogène, par exemple, d'une liste d'entiers, une liste de chaînes de caractères, une liste de listes de caractères, etc.) et renvoie l'un de ses éléments, sans "l'effacement" (par exemple, un casting pour void *) le type. (En fonction de la mise en œuvre, il peut effectivement générer plusieurs mises en œuvre, chacun à un type unique avec une mise en page, pour la performance, mais qui n'a pas de fuite à travers le programmeur.)

Oui, vous vous êtes trompé. La saisie est juste une pratique de l'abstraction. Ce qui importe est la façon dont vous utilisez le raw bits. Le typage permet de vous obliger à utiliser les bits de la manière prévue.

Mise à jour

Dans un sens, il permet de s'assurer de l'exactitude de votre programme en éliminant certaines erreurs courantes.

Disons que vous avez deux variables, char var1 = 'a' et int var2 = 10;. Si vous avez accidentellement essayé d'ajouter var1 + var2, typé langue peut générer une erreur. Si ce n'était pas tapé, il pourrait heureux de vous donner le résultat de 107 et de continuer. Il peut être difficile de savoir où 107 vient, jusqu'à ce que vous vous rendez compte que la représentation ASCII de a est de 97.

Donc sur un point, oui, il s'assure de l'exactitude de votre programme. Mais il y a évidemment de nombreuses autres erreurs (erreurs logiques et autres) qui ne peuvent être évités ou identifiés en tapant seul.