Preciosidades em C++

Encontrados ao corrigir testes (informática).... Deliciem-se!

AEDA - Edição 2009/2010

Identificador::Identificador(string nom): (codigo=id+2;)
{
    nome=nom;
}
---------------------------------------------
Projecto::Projecto():Identificador(nom) {
            virtual ~Projecto();
}
---------------------------------------------------
Projecto::Projecto():Identificador(nom) {
   nome.Identificador=nom;
   codigo.Identificador= 1000 + id*2;
   id.Identificador=id.Identificador++;
}
--------------------------------------------------
Investigador::adicionaProjecto (Projecto *proj) {
    for( int i=0; i < proj.size; i++ ) proj.push_back(i);
     it = proj.begin();
    while( it != proj.end() ) {
      total += *it;
      ++it;
    }
}
---------------------------------------------------

int Identificador::Codigo()const{
    id=codigo;
    return id;
    id=id+2;
}
---------------------------------------------
void adicionaProjecto(Projecto *proj)
{
    set proj;
}
---------------------------------------------
Identificador::Identificador(string nome)
{
    return id;
}
---------------------------------------------
Identificador::Identificador(string nom):Nome(nome),Codigo(codigo)
{
    Nome(nome)=nom;
    codigo=1000+(id*2);
    id++;
}
---------------------------------------------
Projecto::Projecto(Projecto:Identificador);
---------------------------------------------
Investigador::Investigador(string nom, int idade, list <int> projectos)
{
    nom = nome;
    idade = idad;
    list projectos = list projecto;
}
---------------------------------------------
Investigador(int idade, list<Projecto>());
---------------------------------------------
void Projecto::adicionaVerba(float quant)
{
    if (quantia += quant > quantia)
        quantia += quant;
}
---------------------------------------------
// class Investigador...
class Investigador(string nome, int idade)
{
    string nome;
    int idade
    void adicionaProjecto (Projecto *proj);
    virtual void Imprime();
}
------------------------------------------------
Identificador::Identificador (string nom) {
nom = nome;
set codigo;
static int id = codigo;
codigo++;
r = int fmod( int codigo, int y = 2 )
if(r != 0)
codigo++;
}
--------------------------------------------------------  
Identificador(string nom) : codigo = id {nome = nom; id+=2; };
--------------------------------------------------------
class Identificador::public Projecto : {
public:
float verba;
projecto (string nome,
float verba);
void adicionaVerba(float quantia);
};
--------------------------------------------------------
Projecto::Projecto(string nom, float verb) : Identificador::Identificador(nom)
{ verba = verb; }
-------------------------------------------------------------------
vector <Identificador*> tudo;
void
Universidade::ImprimeTudo() {
int i = tudo.first;
for(i; tudo.lenght; i++) {
tudo->i.imprime(); }
}
-------------------------------------------------------------------
Projecto::operator(const Projecto &proj2) const {
if (projecto[1] > proj2[1])
return true;
else
return false;}
-------------------------------------------------------------------
Identificador::Codigo(int codigo) {
if ()
nome = codigo;
else
return 0; }
------------------------------------------------------------------

Armazem::Armazem(int comp, int alt) {
    comprimento=comp;
    altura=alt;
    comprimento=5;
    altura=3;
}
------------------------------------------------------------------
Armazem::Armazem(int comp, int alt){
    comprimento = 5;
    altura = 3;

    comprimento = comp;
    altura = alt;
}
------------------------------------------------------------------
bool Armazem::armazemCheio(){ 
    stack<Contentor> s1 = contentores.back();
    for (unsigned int i = 0; i< s1.size(); i++){ 
        s1.pop();            
        if(s1.empty())       
            return false;    
    }
    return true; 
}
------------------------------------------------------------------
void Armazem:: descarregarCamiao(const contentor& cntr){
    for (int i = 0; contentores.size()<comprimento; i++){
        if( contentores[i].size()<altura) contentores.push(cntr);
        else if( contentores[i].size()>altura) contentores[i + 1].push(cntr);
        else if(contentores.size() == comprimento & contentores.back().size() == altura  )throw ArmazemCheio;
    }
}
------------------------------------------------------------------
void Armazem::descarregarCamiao(const Contentor& cntr){
    stack<Contentor> s1 = contentores.back();  // coloca ultima stack da fila numa stack temporaria
    for(unsigned int i=0; i<=comprimento; i++) // executa um ciclo para todos os elementos da fila
    {
        for(int y=0; y<=altura; y++) // para cada elemento da fila, executa este ciclo tantas vezes
                                                     //   quantas a altura máxima das stacks
        {
            s1.push(cntr); // coloca na stack temporaria o mesmo contentor tantas vezes
                                   // quantas as definidas por altura
            historico.push_back(RegContentor(cntr)); // idem para o historico
        }
        contentores.push(s1); // quando acaba, coloca na fila uma stack nova
                                           // cheia de contentores todos iguais
                                           // e faz isto tantas vezes quantas as definidas
                                           // pelo comprimento máximo da fila.
    }
    throw ArmazemCheio(); // não contente com tudo isto, quando o ciclo acabar
                                          // atira uma excepção de armazem cheio
// RESUMINDO: O armazém fica cheio de contentores todos iguais....
}
------------------------------------------------------------------
RegContentor::RegContentor(const Contentor & cntr)
{
    Contentor c("", 0);
    c=cntr;            
    destino=c.getDestino();
    valor=c.getValor();
}
------------------------------------------------------------------
RegContentor::RegContentor(const Contentor& cntr)
{
    this->cntr.destino = cntr.destino;
    this->cntr.valor = cntr.valor;
}
------------------------------------------------------------------
void Armazem::descarregarCamiao(const Contentor& cntr)
{
    if(armazemCheio() == true)
        throw ArmazemCheio();

    queue< stack<Contentor> >::iterator Iter;

    for(Iter it = contentores.front(); it < comprimento; it++)
        if(*it.size() == altura)
            it++;
        else
        {
            *it.top().push(cntr);
            historico.push_back(cntr);
        }
}
------------------------------------------------------------------
// O objectivo era carregar um navio com contentores que estão num armazém
// ver bem o que está marcado com (*)

Contentor& Armazem::carregarNavio() {
    if (contentores.back().empty())
        throw ArmazemVazio();
    else {
        Contentor contentor1 = contentores.front().top();
        contentores.back().push(contentor1);      (*)      
        return contentor1;
    }
}
------------------------------------------------------------------
Armazem Armazem:: (int comp, int alt){
    comp == 5 && alt == 3;
}
------------------------------------------------------------------
bool Armazem::armazemCheio(){
    int a,b ;
    if (contentores.size() >= Armazem(a,b).altura)
        return true;
}
------------------------------------------------------------------
void Armazem::imprimirRegsito(ostream& os){

    list<RegContentor>::iterator it = historico.begin();
    list<RegContentor>::iterator ite = historico.end();

    while (it =! ite)
    {
        os = historico[*it];

    }
    it++;
}
------------------------------------------------------------------
typedef hash_set<..., ..., ...> hashRegistos;

struct hash
{
    operator() (const Registo & rhs)
    {
        return "...";
    }

    operator() (const Registo & rhs, const Registo & lhs)
    {
        return rhs == lhs;
    }
}

for (hashRegistos::const_iterator it; it != registos.begin(); it++)
{
   cout << *it << endl;
}
------------------------------------------------------------------
typedef (Registos, registoHash, registohHash) hash_set;
------------------------------------------------------------------
hash_set registos();
------------------------------------------------------------------
void Biblioteca::construirRegistos(){
   
    list<Transaccao>::iterator it = transaccoes.begin();
    list<Transaccao>::iterator it2 = transaccoes.end();
    hash_set<Registo>::iterator its = registos.begin();
    hash_set<Registo>::iterator its2 = registos.end();

    inicio:

    while(it != it2){
        while(its != its2){
            if(its->getNome() == it->nome){
                its->addTransacao(it->data);
                it++;

                goto inicio;

            }else
                its++;
        }
        registos.insert(*it);
    }
}
------------------------------------------------------------------
void Biblioteca::imprimirRegistos(){
    hash_set<Registo>::iterator it = registos.begin();
    hash_set<Registo>::iterator it2 = registos.end();
    while(it != it2){
        operator<<(cout, *it);
        it++;
    }
}
------------------------------------------------------------------
void setMinPartida() {
            return minPartida=minp;
}

------------------------------------------------------------------
priority_queue( int i=0, int m=0 start,
                         horaPartida(i)=23 & minPartida(m)=59 end,
                         const Compare& comp = Compare(),
                         const Container& c = Container()
                         If(m<59)
                           {
                              m++
                           else
                              {m=0
                               i++}
                           }
                         );
------------------------------------------------------------------
    int getnrVoo{return  nrVoo;};  // Número do voo
    string getorigem{return  origem;}; // Aeroporto de partida do voo. Ex: OPO, LIS, ORY
    string getdestino{return  destino;}; // Aeroporto de destino do voo. Ex: CDG, LHR, EWR
    int gethoraPartida{return  horaPartida;}; // Hora da partida (0-23)
    int getminPartida{return  minPartida;};