[Truc C++] Faire un bon singleton

Dans le cadre d'un projet à l'université, il a fallu que j'implémente le patron de conception (design pattern) singleton. Puisque je n'ai jamais fait cela en C++, j'ai parcouru la Toile afin de trouver un exemple qui semblait correct. J'ai implémenté un des exemples semblables que j'ai trouvés. Cependant, le professeur m'a dit que cela n'était pas correct parce qu'il pouvait faire fuir des ressources. Il m'a donné le lien vers son site où il expliquait une implémentation correcte. J'ai décidé de le partager puisque la plupart des exemples sur internet ne sont pas corrects.

[Truc C++] Opérations mathématiques sur des éléments d'une séquence

La méthode std::accumulate() est utile pour faire des opérations mathématiques sur une suite d'élements délimitée par des itérateurs par exemple les éléments d'un vecteur. Le premier paramètre est l'itérateur de départ, le deuxième paramètre est l'itérateur de fin. Le troisième élement est la valeur de départ, souvent 0 pour une somme et 1 pour une multiplication. Le quatrième paramètre, qui est optionnel, est une opération binaire à appliquer, par défaut c'est la somme. Avec cette méthode, on se rapproche de la programmation fonctionnelle!

#include <iostream>
#include <vector>
#include <iterator>
#include <numeric>
#include <functional> // pour la multiplication

using std::vector;
using std::cout;
using std::accumulate;

int main()
{
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);

    cout << accumulate(v.begin(), v.end(),0) << std::endl;
    cout << accumulate (v.begin (), v.end (), 1,
                         std::multiplies<int>());

    return 0;
}

Tout bon mathématicien du dimanche pourrait prédire que les sorties de ce programme sont 10 et 24.

Développement durable

Lors d'une entrevue, un interviewer m'a dit que le stagiaire embauché pour l'été allait faire l'analyse et, si le temps le permet, l'implémentation d'un renouvellement d'un système qui avait été en production pendant une vingtaine d'années. Il est à la recherche d'un langage de programmation qui va permettre au nouveau système d'avoir une durée de vie aussi longue que l'ancien système. Ceci m'a amené à me poser la question suivante : quels langages de programmation actuels permettraient de créer un système d'une assez grande amplitude pour une aussi longue durée de vie? Essayons de trouver une technologie qui permettrait cela.

Python

J'ai été surpris que Python ait été abordé par la personne avec qui j'ai eu l'entretien ce matin. Malgré sa popularité croissante, je crois que Python n'a pas encore fait ses preuves comme langage pouvant résister au temps. Un autre point contre l'utilisation de Python comme langage durable est sa grande volatilité. En effet, la version 3 de Python qui est parue récemment n'est pas rétrocompatible avec les anciennes versions. On ne peut pas savoir si ceci va se reproduire à l'avenir. Aussi, puisque le bassin de programmeurs Python actuel est assez limité, les programmeurs Python seront d'autant plus rares dans le futur si le langage est encore fonctionnel, mais moins populaire. D'un autre côté, Python supporte plusieurs plates-formes (possibilité de changer de plate-forme durant la vie du système) et simple à apprendre.

.Net

Avec une nouvelle version tous les deux ans qui assurent une rétrocompatibilité *presque* complète est-ce que les produits créés avec la technologie de Microsoft vont vieillir avec grâce? Laissez-moi en douter. Premièrement, les logiciels vont être confinés sur des ordinateurs qui ont un système d'exploitation Windows. Le support de Microsoft pour Windows n'est pas éternel, mais il tout de même possible de continuer à l'utiliser sans support malgré les risques potentiels. Aussi, dans une vingtaine d'années, est-ce que le framework .Net 3.5 va être encore supporté ou encore utilisable alors qu'une version proche de 10.5 du framework va être sortie? Est-ce que le langage va être aussi éphémère que d'autres en provenance de Microsoft comme VB6 ou le BASIC?

C++

Ce langage de programmation est celui que je crois être en mesure de répondre aux besoins d'un environnement de production pendant une vingtaine d'années. Premièrement, C++ a déjà fait ses preuves et le standard change rarement et les changements apportés ne sont pas majeurs. Cependant, il arrive que le code source doit être modifié afin d'être compilé par un compilateur plus récent (par exemple, la transition entre GCC 3 et GCC 4). Le bassin de programmeur C++ est de grande taille.

Java

Je crois que Java est au même niveau que C++ pour la création d'applications durables : les changements de version passent souvent sans embûches et le nombre de développeurs Java est assez grand pour suffire à la demande pour les futures maintenances. De plus, contrairement aux programmes C++, les applications Java ont moins de dépendances envers des librairies externes qui peuvent être rendues obsolètes pendant la durée de vie du système.

Conclusion

Il se peut que les analystes en poste il y a vingt ans se posaient la même question et qu'ils trouvaient eux aussi que les langages de programmation de leur époque ne semblaient pas être appropriés pour un projet axé sur le long terme. Ils ont toutefois réussi à créer des systèmes qui ont su résister au temps. Peut-être que dans vingt ans, les programmeurs Java vont être une denrée rare et prisée comme le sont les programmeurs Cobol actuels. Finalement, il y a une possibilité que la qualité de l'analyse du système importe plus que le langage de programmation choisi lors de la création d'un système ayant une longue durée de vie.

[Truc C++] Lecture d'un fichier vers un vecteur et l'inverse

Le programme C++ suivant lit un fichier d'entiers et l'emmagasine dans un vecteur. Ensuite le contenu du vecteur est sauvegardé dans un autre fichier.

#include <iostream>
#include <vector>
#include <iterator>
#include <fstream>
using namespace std;

int main()
{
    ifstream is("in.txt");
    ofstream os("out.txt");

    vector<int> v (istream_iterator<int>(is), (istream_iterator<int>()));
    copy(v.begin(), v.end(), ostream_iterator<int>(os, "\n"));
    return 0;
}

Le constructeur du vecteur appelé est celui qui prend deux itérateurs comme paramètres afin d'initialiser le vecteur, un de début et un de fin. Le premier itérateur correspond à un itérateur sur le fichier alors que le deuxième est un itérateur représentant une erreur de lecture par exemple la fin du fichier.

La fonction "copy" prend trois paramètres :
- Un itérateur de début de lecture
- Un itérateur de fin de lecture
- Un itérateur d'écriture

Finalement, "is" et "os" peuvent être respectivement remplacés par "cin" et "cout" afin de lire ou écrire sur la console au lieu d'un fichier.