내 배열은 빠른 CPU 및 메모리 구축의 원인입니까?

Question

내 MCVC가 컴파일 중이지만 의도 한대로 작동하지 않습니다. 목표는 크로스 오버, 돌연변이, 진화의 기본을 수행하는 유전 알고리즘입니다. 필자가 제공 한 코드에서 좋은 작업 문을 인쇄해야하지만 그렇지 않은 경우가 있습니다. 나는 새로운 프로그래머이다. 미안하다. 내 질문은 :

1) CPU 및 RAM이 초기화되어 있으며,이 배열 선언 및 구현이 제어되지 않은 스파이크의 원인입니까?

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

2) 내 2.53 GHz Intel Core 2 Duo는 그렇지 않은가요?

3) 루프의 양을 줄여야합니까?

도움이 언제나 환영합니다!

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; 
} 

,536 다음과 같이

이

std::vector<char> genes; 

C++ 표준은 std::vector::max_size()을 정의 : 귀하의 genes

하여 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(); 
} 

는이다

거리 (,) (끝 시작()) 가능한 가장 큰 컨테이너의 경우

"가능한 가장 큰 컨테이너"의 의미는 지정하지 않습니다. "가능한"이란 시스템에 10 테라 바이트 하드 드라이브가있는 경우 운영 체제가 전체 하드 드라이브를 사용하여 가상 메모리 주소 공간을 페이징 할 수있는 것과 같은 의미입니다. 그것은 확실하게 "가능한"것입니다, 어떤 의미에서 말이죠. 하지만 10 테라 바이트를 페이징하는 데는 어느 정도 시간이 걸릴 것입니다.

#include <iostream> 
#include <vector> 

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

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

는 다음과 같은 출력을 생성합니다 :

64 비트 GCC, 다음과 같은 간단한 프로그램을 통해 그러나

18446744073709551615 

을 실제로 같은 크기의 벡터를 생성 할 수있는 나의 기회는 없습니다 아주 좋아.

그러나 이제 다시 코드를하자 :

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

좋아. 아주 운이 좋은 느낌이 들겠군요.당신은 을 만들 수 있다고 믿습니다. 그 숫자는 max_size()입니다.

정말 확실합니까?

다소 회의적입니다.