Nous nous restreignons pour l'instant à des types dénotant des valeurs numériques et supportant nativement une conversion soit implicite soit explicite d'un type entier supporté par le générateur de nombre aléatoire et le type des valeurs stockées dans le tableau dynamique.

Lorsque nous nous intéressons au prototype de la fonction populate_with_randoms monomorphes :

void populate_with_randoms(
        std::vector<int>& theVector,
      	int theNumberOfValues, int theMinValue, int theMaxValue);

Il serait tentant de remplacer toutes les instances de int par un paramètre de type T.
Ceci donnerait la signature suivante :

template<typename T>
void populate_with_randoms(
        std::vector<T>& theVector,
      	T theNumberOfValues, T theMinValue, T theMaxValue)
{
    std::random_device rd;
    std::minstd_rand gen(rd());
    std::uniform_int_distribution<T> distribution(theMinValue, theMaxValue);
    theVector.clear();
    for(;
        theNumberOfValues > 0;
        theNumberOfValues --)
    {
        theVector.push_back(
        (T)distribution(gen));
    }
}

qui en fait serait totalement inadaptée.
En effet, pour le type T=double, nous nous retrouverons avec la signature :

void populate_with_randoms<double>(
        std::vector<double>& theVector,
      	double theNumberOfValues, double theMinValue, double theMaxValue)
{
        std::random_device rd;
        std::minstd_rand gen(rd());
        std::uniform_int_distribution<double> 
            distribution(theMinValue, theMaxValue);
            // !!!! l'instantiation uniform_int_distribution<double> 
            // n'est pas supportée
        theVector.clear();
        for(;
            theNumberOfValues > 0;
            theNumberOfValues --)
            // Fonctionne mais theNumberOfValues n'est pas 
            // a priori une valeur flottante mais un entier !
        {
            theVector.push_back(
                (double)distribution(gen));
        }
}

Il est donc nécessaire de bien séparer les différents types des paramètres :

• std::vector<int>& theVector ⇒ nous pouvons étendre le support de la fonction à tous les types T génériques correspondant à des types numériques.
• int theNumberOfValues ⇒ cet élément reste un nombre entier, éventuellement nous pouvons y substituer le type size_t.
• int theMinValue, int theMaxValue ⇒ le support de la fonction peut être étendu à tous les types supportés par la classe std::uniform_int_distribution.

Dans ce cas, nous pouvons redéfinir le patron de la fonction comme suit :

namespace generic 
{
    template<typename T, typename genType>
    void populate_with_randoms(
        std::vector<T>& theVector,
      	size_t theNumberOfValues,
        genType theMinValue, genType theMaxValue)
    {
        std::random_device rd;
        std::minstd_rand gen(rd());
        std::uniform_int_distribution<genType> distribution(theMinValue, theMaxValue);
        theVector.clear();
        for(;
            theNumberOfValues > 0;
            theNumberOfValues --)
        {
            theVector.push_back(
                (genType)distribution(gen));
        }
    }
}

Pour les fonctions print_vector et simple_sort, la généralisation est simple, puisqu'il n'y a qu'un paramètre à généraliser qui est le type des valeurs stockées dans le tableau dynamique.

namespace generic
{
    ...
 
    template<typename T>
    void print_vector(const std::vector<T>& anArray)
    {
        int length = anArray.size();
        std::cout << "[";
        for(int index = 0; index < length - 1; index ++)
            std::cout << anArray[index] << ", ";
        std::cout << anArray[length - 1] << "]" << std::endl;
    }
    template<typename T>
    void simple_sort(std::vector<T>& theValues)
    {
        int length = theValues.size();
        for(int i = 0; i < length-1; i ++)
        {
            for(int j= i+1; j < length; j++)
            {
                if(theValues[i] > theValues[j])
                    std::swap(theValues[i], theValues[j]);
            }
        }
    }
}