Ajuda com meu código C++ P.O.O.

[isaiasbd]

Estou com dúvida de fazer o int main não estou conseguindo passar da classe para o programa principal. Alguém pode me ajudar? Segue abaixo o exercício e o código.

Exercício:

Um protozoário é um animal simples, porém completo. A partir do seu nascimento, cada protozoário tem um número ****** único, conhecido como individualidade, que nunca pode mudar e nunca poderá ser associado a outro protozoário. O genótipo de um protozoário é composto por 10 genes, sendo que cada um pode ter valores de 0 a 3. Um protozoário pode se reproduzir por replicação ou por cópula com outro protozoário*. Um protozoário nascido através da replicação de outro é uma cópia idêntica do pai, exceto por sua individualidade. Já se for gerado por cópula, receberá os genes randomicamente de cada indivíduo, com uma chance de 50% do gene vir de um ou de outro. De vez em quando (em 7% dos casos), pode haver mutação no genótipo, que altera um único gene no protozoário.

Modele a classe Protozoario, que deve possuir os seguintes métodos:

a) public Protozoario(): cria um protozoário com o genótipo [0,0,0,0,0,0,0,0,0,0];

B) public Protozoario(int[] genotipo): cria um protozoário com o genótipo fornecido;

c) public void mutate(): causa uma mutação no genótipo;

d) public Protozoario getClone(): retorna um novo protozoário criado por replicação;

e) public void print(): imprime uma representação do protozoário;

f) Permita que o usuário saiba quantos objetos protozoários estão em memória em um dado momento.

#ifndef PROTOZOARIOS_H
#define PROTOZOARIOS_H
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int MaxElementos = 512; // máximo de protozoários
// definicao dos genes
enum Gene
{
Adenina = 0, //aminoácidos reais representados de 0 a 3
Citosina = 1,
Guanina = 2,
Timina = 3
};
// classe Principal aqui
class Protozoario
{
private:
int Serial;
Gene Genotipo[10];
public:
Protozoario();
Protozoario(Gene genotipo[10]);
void mutate();
Protozoario getClone();
void print();
// criada por mim
Protozoario GetCopula(Protozoario Parceiro);
};
namespace RunTime
{
int LastSerial = 0;
int NovoSerial()
{
// se quiser randômico é só implementar, porém tome cuidado:
// cada serial é único
return ++LastSerial;
}
Gene NovoGene()
{
srand(time(NULL));
int select = rand() % 4;
switch(select)
{
case 0:
{
return Adenina; // uma aminoácido
}
break;
case 1:
{
return Citosina; // uma aminoácido
}
break;
case 2:
{
return Guanina; // uma aminoácido
}
break;
case 3:
{
return Timina; // uma aminoácido
}
break;
default:
{
return Adenina; // caso algum erro
}
break;
}
return Adenina; // impossível chegar aqui, mas está presete
}
// lista de ponteiros para os protozoários criados
Protozoario *Lista[MaxElementos];
} // RunTime namespace
// isso vai no .cpp
// #include "protozoario.h"
Protozoario::Protozoario()
{
this->Serial = RunTime::NovoSerial();
for(int n = 0; n != 10; n++)
{
this->Genotipo[n] = Adenina;
}
}
Protozoario::Protozoario(Gene genotipo[10])
{
this->Serial = RunTime::NovoSerial();
for(int n = 0; n != 10; n++)
{
this->Genotipo[n] = genotipo[n]; //cópia do genótipo como parâmetro
}
// 7% dos casos tem uma mutação
srand(time(NULL));
int esp = rand() % 100;
if(esp <= 7)
{
this->mutate();
}
}
Protozoario Protozoario::getClone()
{
Protozoario temp;
temp.Serial = RunTime::NovoSerial();
for(int n = 0; n != 10; n++)
{
temp.Genotipo[n] = this->Genotipo[n];
}
return temp;
}
// retorna um protozoário através de combinação
Protozoario Protozoario::GetCopula(Protozoario Parceiro)
{
Protozoario ret; // retorno
bool est = false;
srand(time(NULL));
ret.Serial = RunTime::NovoSerial();
// para os genes aleatórios
for(int n = 0; n != 10; n++)
{
est = rand() % 2; // idealiza a randomização de true ou false
if(est == true)
{
ret.Genotipo[n] = this->Genotipo[n];
}
else
{
ret.Genotipo[n] = Parceiro.Genotipo[n];
}
}
// 7% dos casos tem uma mutação
srand(time(NULL));
int esp = rand() % 100;
if(esp <= 7)
{
ret.mutate();
}
return ret;
}
void Protozoario::mutate()
{
srand(time(NULL));
int GeneAlvo = rand() % 10; // ponteiro-alvo para o gene que se modificará
Gene Antigo = this->Genotipo[GeneAlvo];
Gene Novo = RunTime::NovoGene();
while(Antigo == Novo)
{
Novo = RunTime::NovoGene();
}
this->Genotipo[GeneAlvo] = Novo;
return;
}
void Protozoario::print()
{
// expressão de saída:
// Protozoário
// Serial: 0
// Genotipo: 0120103012
printf_s("Protozoario:\nSerial: %i\nGenotipo: ", this->Serial);
for(int n = 0; n != 10; n++)
{
switch(this->Genotipo[n])
{
case Adenina:
{
printf_s("%i", 0);
}
break;
case Citosina:
{
printf_s("%i", 1);
}
break;
case Guanina:
{
printf_s("%i", 2);
}
break;
case Timina:
{
printf_s("%i", 3);
}
break;
default:
{
}
break;
}
}
printf_s("\n");
return;
}
#endif

[Marcelo Utikawa da Fonseca]

Boa tarde!

Primeiro um comentário: achei muito interessante esse enunciado. Um exercício que realmente mostra a utilidade de uma classe e sobre algo mais concreto! E o código está muito bom também... :)

Apenas dois problemas:

1- O resto da divisão por 100 é entre 0 e 99. Ou seja: 7% representa qualquer valor entre 0 e 6, não 0 e 7. Assim a comparação para mutação deve ser < 7 e não <= 7.

2- Alterei printf_s para printf pois estava dando erro na compilação. Essa versão com o _s é específica da microsoft e aqui estou usando o linux. Dê sempre preferência pelas funções ANSI pois assim seu programa funcionará em outras plataformas também. Usar o padrão é sempre bom! :)

Eu dei uma organizada no código e também dividi em dois arquivos: protozoarios.h e protozoarios.c

Eu também mudei um pouco o método mutate e print: usei do { } while(); para não precisar repetir o código, criei variável g para armazenar o valor do gene e usar apenas 1 printf e também removi o return pois não é necessário quando a função é do tipo void.

Seguem os arquivos formatados e com as mudanças que sugeri:

protozoario.h

#ifndef PROTOZOARIOS_H
#define PROTOZOARIOS_H

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

const int MaxElementos = 512; // máximo de protozoários

// definicao dos genes
enum Gene { //aminoácidos reais representados de 0 a 3
    Adenina = 0,
    Citosina = 1,
    Guanina = 2,
    Timina = 3
};

// classe Principal aqui
class Protozoario
{
    private:
        int Serial;
        Gene Genotipo[10];

    public:
        Protozoario();
        Protozoario(Gene genotipo[10]);

        void print();
        void mutate();

        Protozoario getClone();
        Protozoario GetCopula(Protozoario Parceiro);
};

namespace RunTime {

int LastSerial = 0;

int NovoSerial()
{
    // se quiser randômico é só implementar, porém tome cuidado:
    // cada serial é único
    return ++LastSerial;
}

Gene NovoGene()
{
    srand(time(NULL));
    int select = rand() % 4;

    switch(select) {
        case 0: return Adenina; break; // uma aminoácido
        case 1: return Citosina; break; // uma aminoácido
        case 2: return Guanina; break; // uma aminoácido
        case 3: return Timina ; break; // uma aminoácido
    }

    return Adenina; // Se algo der errado, retorna Adenina
}

// lista de ponteiros para os protozoários criados
Protozoario *Lista[MaxElementos];
} // RunTime namespace

#endif

protozoario.c

#include "protozoario.h"

Protozoario::Protozoario()
{
    this->Serial = RunTime::NovoSerial();

    for(int n = 0; n != 10; n++) {
        this->Genotipo[n] = Adenina;
    }
}

Protozoario::Protozoario(Gene genotipo[10])
{
    this->Serial = RunTime::NovoSerial();

    for(int n = 0; n != 10; n++) {
        this->Genotipo[n] = genotipo[n]; //cópia do genótipo como parâmetro
    }

    // 7% dos casos tem uma mutação
    srand(time(NULL));
    int esp = rand() % 100;
    if(esp < 7) {
        this->mutate();
    }
}

Protozoario Protozoario::getClone()
{
    Protozoario temp;
    temp.Serial = RunTime::NovoSerial();

    for(int n = 0; n != 10; n++) {
        temp.Genotipo[n] = this->Genotipo[n];
    }

    return temp;
}

// retorna um protozoário através de combinação
Protozoario Protozoario::GetCopula(Protozoario Parceiro)
{
    Protozoario ret; // retorno
    bool est = false;

    srand(time(NULL));

    ret.Serial = RunTime::NovoSerial();

    // para os genes aleatórios
    for(int n = 0; n != 10; n++) {
        est = rand() % 2; // idealiza a randomização de true ou false
        if(est == true) {
            ret.Genotipo[n] = this->Genotipo[n];
        } else {
            ret.Genotipo[n] = Parceiro.Genotipo[n];
        }
    }

    // 7% dos casos tem uma mutação
    srand(time(NULL));
    int esp = rand() % 100;
    if(esp < 7) {
        ret.mutate();
    }

    return ret;
}

void Protozoario::mutate()
{
    srand(time(NULL));
    int GeneAlvo = rand() % 10; // ponteiro-alvo para o gene que se modificará

    Gene Antigo = this->Genotipo[GeneAlvo];
    Gene Novo;

    do {
        Novo = RunTime::NovoGene();
    } while(Antigo == Novo);

    this->Genotipo[GeneAlvo] = Novo;
}

void Protozoario::print()
{
    int g;
    // expressão de saída:
    // Protozoário
    // Serial: 0
    // Genotipo: 0120103012
    printf("Protozoario:\nSerial: %i\nGenotipo: ", this->Serial);

    for(int n = 0; n != 10; n++) {
        switch(this->Genotipo[n]) {
        case Adenina : g = 0; break;
        case Citosina: g = 1; break;
        case Guanina : g = 2; break;
        case Timina  : g = 3; break;
        }
        printf("%i", g);
    }

    printf("\n");
}

Sobre como fazer o main: você precisa apenas incluir o protozoarios.h e usar as funções conforme quiser. Criar um menu onde o usuário solicita a criação de um novo protozoário, por exemplo... É essa sua dúvida?

O que mais diz no enunciado? O que falta ser feito?

Digo isso pois o que era solicitado já foi feito...

Abraços,

Marcelo Utikawa da Fonseca

[isaiasbd]

Opa, vlw mesmo Marcelo, ajudou muito. Minha dúvida era em criar o menu, mais suas dicas ajudaram, vou tentar fazer aqui agora! Vlw!