Je viens de remarquer que tous les langages de programmation OO modernes avec lesquels je suis au moins quelque peu familiarisé (essentiellement Java, C # et D) autorisent les tableaux covariants. Autrement dit, un tableau de chaînes est un tableau d'objets:
Object[] arr = new String[2]; // Java, C# and D allow this
Les tableaux covariants sont un trou dans le système de types statique. Elles rendent possibles les erreurs de type qui ne peuvent pas être détectées lors de la compilation. Chaque écriture dans un tableau doit donc être vérifiée à l'exécution:
arr[0] = "hello"; // ok
arr[1] = new Object(); // ArrayStoreException
Cela semble être une terrible performance si je fais beaucoup de magasins de matrices.
C ++ n'a pas de tableaux covariants, il n'est donc pas nécessaire d'effectuer une telle vérification à l'exécution, ce qui signifie qu'il n'y a aucune pénalité de performance.
Une analyse est-elle effectuée pour réduire le nombre de vérifications d'exécution nécessaires? Par exemple, si je dis:
arr[1] = arr[0];
on pourrait dire que le magasin ne peut pas échouer. Je suis sûr qu'il y a beaucoup d'autres optimisations possibles auxquelles je n'ai pas pensé.
Les compilateurs modernes effectuent-ils ce type d'optimisation ou dois-je accepter le fait que, par exemple, un Quicksort effectue toujours des vérifications d'exécution inutiles O (n log n)?
Les langages OO modernes peuvent-ils éviter les frais généraux générés par la prise en charge de tableaux de co-variantes?