Comment générer et utiliser un C++ 11 std :: array avec new pour utiliser le tas au lieu de la pile?

Question

Je suis conscient que je suis supposé utiliser std :: vector si je veux générer un grand tableau sur le tas.

Cependant, dans mon cours, je dois utiliser std :: array à la place. Comme de très grands tableaux sont requis pour la tâche, je voulais forcer le compilateur à créer le tableau sur le tas au lieu de la pile.

La seule façon que j'ai obtenu mon compilateur accepte c'était:

std::array<double,10000000>* array = new array<double,10000000>; 

Cependant, le programme se bloque une fois que j'essaie de l'utiliser, car il semble causer des fuites de mémoire. Y a-t-il un moyen de contourner ce problème?

modifier:

Voici une partie des choses que j'essaie de faire: je dois générer un grand tableau, puis générer des nombres aléatoires et trouver le minimum. Je pense que le reste devrait fonctionner avec la même mécanique:

à Main:

std::array<double,10000000>* array = new array<double,10000000>; 

genrate_array(*array); 
std::cout<<"Minimum one loop:" << std::endl; 
std::cout<<" " << std::endl; 
time_measure<start_size, double>(plain_minimum, *array); 

La première fonction du modèle:

template<std::size_t N, typename T> 
void genrate_array(std::array<T, N>& test_arr){ 
    //generate the array 
    std::random_device rd; 
    std::mt19937 mt(rd()); 
    std::uniform_real_distribution<T> dist_int(0.0,500.0); 

    for(std::size_t i = 0; i< test_arr.size() ; i++) 
    { 
     test_arr[i] = dist_int(mt); 
    } 
} 

La deuxième fonction du modèle:

template<std::size_t N, typename T> 
T plain_minimum(std::array<T,N>& arr, std::size_t start_index,std::size_t end_index) 
{ 
    T min = arr[start_index]; 

    for(std::size_t i = start_index+1; i< end_index ; i++){ 
     if(min > arr[i]) 
     { 
      min = arr[i]; 
     } 
    } 
    return min; 
} 

Cela compile mais se bloque presque immédiatement.

Answer 1

il semble provoquer des fuites de mémoire

Si vous allouez manuellement la mémoire avec new, vous devez désaffecter avec delete. Si vous oubliez de supprimer la mémoire que vous avez allouée, il y aura toujours une fuite.

Une meilleure approche est d'utiliser un pointeur intelligent qui prendra soin de la désaffectation:

std::unique_ptr<std::array<double,10000000>> pointer(new std::array<double,10000000>); 

---

PS. Il est bon que vous reconnaissiez que std::vector serait plus approprié pour cela. Je vous invite à demander à votre instructeur de clarifier quelles sont les connaissances que vous êtes censé tirer de cet exercice.