Mon tableau est-il la cause de l'accumulation rapide de CPU et de mémoire?

Question

Mon MCVC est en cours de compilation mais ne fonctionne pas comme prévu. L'objectif est un algorithme génétique qui effectue les bases, c'est-à-dire le croisement, la mutation, l'évolution. Dans le code que j'ai fourni devrait imprimer les bons énoncés de travail, mais ce n'est pas le cas. Je suis un nouveau programmeur, désolé. Mes questions sont:

1) Le CPU et le RAM sont rev'ed, est cette déclaration de tableau et l'implémentation la cause de la pointe incontrôlée?

std::array<std::auto_ptr<Individual>,50>myarray; 

2) Mon processeur Intel Core 2 Duo à 2,53 GHz ne fonctionne-t-il pas?

3) Dois-je réduire la quantité de boucles?

Toute aide est toujours la bienvenue!

Individual.h

#include <stdio.h> 
#include <cstdlib> 
#include <ctime> 
#include <vector> 
#include <array> 
#include <iostream> 
class Individual 
{ 
public: 

    inline int getRandomNumber(int min = 0, int max = 1) 
    { 
     srand(static_cast<unsigned int>(time(0))); 
     static const double fraction = 1.0/(static_cast<double>(RAND_MAX) + 1.0); 
     return static_cast<int>(rand() * fraction * (max - min + 1) + min); 
    } 
private: 
    int defaultGeneLength = 64; 
    std::vector<char>genes; 
    int fitness = 0; 

public: 
    Individual() 
    { 
     std::cout<<"Good Job"; 

    } 

    //setters and getters 
    void generateIndividual(); 
    void setDefaultGeneLength(int length); 
    char getGene(int index); 
    void setGene(int index, char value); 

    //public methods 
    unsigned int size(); 
    int getFitness(); 
    std::string toString(); 
}; 

Individual.cpp

#include "Individual.h" 

void Individual::generateIndividual() 
{ 
    for (int i = 0; i < size(); i++) 
    { 
     genes.push_back(getRandomNumber()); 
    } 
} 


//setters and getters 
void Individual::setDefaultGeneLength(int length) 
{ 
    defaultGeneLength = length; 
} 


char Individual::getGene(int index) 
{ 
    return genes.at(index); 

} 


void Individual::setGene(int index, char value) 
{ 
    genes[index] = value; 
    fitness = 0; 
} 


//public methods 
unsigned int Individual::size() 
{ 
    return genes.max_size(); 
} 


int Individual::getFitness() 
{ 
    if(fitness == 0) 
    { 
     fitness = 1; 

    } return fitness; 

} 


std::string Individual::toString() 
{ 
    std::string geneString = ""; 
    for (int i = 0; i < size(); i++) 
    { 
     geneString.append(getGene(i),1); 
    } 
    return geneString; 

} 

Population.h

#include "Individual.h" 

class Population 
{ 
std::array<std::auto_ptr<Individual>,50>myarray; 

public: 


    Population(int populationSize, bool initialise) 
    { 
     std::cout<<"Good Job2"; 
     if(initialise) 
     { 
      for (int i = 0; i < populationSize; ++i) 
      { 
       std::auto_ptr<Individual>newIndividual(new Individual()); 
       myarray.at(i) = newIndividual; 
       myarray.at(i)->generateIndividual(); 
       saveIndividual(i,*(myarray.at(i))); 
      } 
     } 
     std::cout<<"Good Job 3"; 
    } 

    Individual getIndividual(int index); 
    Individual getFittest(); 
    unsigned long size(); 
    void saveIndividual (int index, Individual indiv); 

    ~Population() 
    { 

    } 
}; 

Population.cpp

#include "Population.h" 
Individual Population::getIndividual(int index) 
{ 
    return *myarray.at(index); 
} 

Individual Population::getFittest() 
{ 
    Individual fittest = *myarray.at(0); 

    for (int i = 0; i < myarray.max_size(); i++) 
    { 
     if (fittest.getFitness() <= getIndividual(i).getFitness()) 
     { 
      fittest = getIndividual(i); 
     } 
    } 
    return fittest; 
} 

unsigned long Population::size() 
{ 
    return myarray.max_size(); 
} 

void Population::saveIndividual (int index, Individual indiv) 
{ 
    *myarray.at(index) = indiv; 
} 

Main.cpp

int main(int argc, const char * argv[]) { 

    Population *mypop = new Population(2,true); 
    delete mypop; 
    mypop = nullptr; 
return 0; 
} 

Answer 1

unsigned int Individual::size() 
{ 
    return genes.max_size(); 
} 

Votre genes est un:

std::vector<char> genes; 

La norme C++ définit std::vector::max_size() comme suit:

, fin distance (begin()()) pour le plus grand conteneur possible

Il n'est pas précisé ce que signifie "le plus grand conteneur possible". "Possible" pourrait signifier n'importe quoi, comme, si le système avait un disque dur de dix téraoctets, de sorte que le système d'exploitation pourrait utiliser le disque dur entier pour signaler son espace d'adressage de mémoire virtuelle. C'est certainement "possible", dans un certain sens du mot. Mais il va sans dire que paginer dix téraoctets prendra un certain temps.

Avec 64 gcc bits, le programme simple:

#include <iostream> 
#include <vector> 

int main() 
{ 
    std::vector<char> c; 

    std::cout << c.max_size() << std::endl; 
    return 0; 
} 

produit la sortie suivante:

18446744073709551615 

Cependant, mes chances d'être en mesure de créer réellement un vecteur de cette taille ne sont pas très bon.

Mais revenons à votre code:

void Individual::generateIndividual() 
{ 
    for (int i = 0; i < size(); i++) 
    { 
     genes.push_back(getRandomNumber()); 
    } 
} 

Ok. Vous devez être assez chanceux.Vous croyez qu'il vous sera possible de créer un vector<char> gros max_size().

Êtes-vous assez sûr à ce sujet?

Je suis quelque peu sceptique.