Revisão para o exame. Resolução de problemas de testes/exames antigos.
Vamos usar o seguinte tipo ANSI-C. Cada nó da lista contém: uma flag que indica se o nó está ativo, o valor do nó (no caso de estar ativo), um apontador para o nó que se segue. O apontador NULL marca o final da lista. A função da direita pode ser usada para criar nós inicializados.
typedef struct Node {
bool active ;
int value ;
struct Node *next ;
} Node, *List;
Pode usar a função newNode que se oferece aqui já escrita:
List newNode(int value, List next) {
List n = malloc(sizeof(Node));
if( n == NULL ) return NULL;
n->active = true;
n->value = value;
n->next = next;
return n;
}
NOTA: Não se esqueça: neste tipo de problemas começa-se por escrever o ciclo (inicialmente de forma tentativa), e só no final se trata da inicialização e da finalização.
int length(List l)
List delete(List l, int value)
List insert(List l, int value)
#include <stdio.h>
#define N_NODES 4
typedef struct Node { int value ; struct Node *next ; } Node, *List ;
void G(List l) { // global function
for( ; l->next != NULL ; l = l->next );
// QQQ
}
int main(void) { // global function
Node nodes[N_NODES];
void F(int i) { // local function
nodes[i].value = i;
if( i == N_NODES-1 ) {
nodes[i].next = NULL;
G(&nodes[0]);
}
else {
nodes[i].next = &nodes[i+1];
F(i+1);
}
}
F(0);
return 0 ;
}
Mostre qual o estado da pilha de execução no momento em que a execução do programa atinge o ponto marcado com QQQ. Note que o array nodes ocupa 8 posições de memória. Não se esqueça dos registos de ativação das funções start e main.
Use as convenções habituais das aulas: Para efeitos da criação do registo de activação inicial, imagine que cada programa em GCC está embebido numa função sem argumentos chamada start. Depois trate todas as entidades globais do programa como sendo locais à função imaginária start. Assuma também que a primeira célula da pilha de execução é identificada como posição 0, a segunda célula da pilha de execução é identificada como posição 1, etc.
Vamos considerar espécies e relações simbióticas.
Espécies: Uma espécie é um tipo de ser vivo, que pode ser tanto animal como vegetal. Exemplos: humano, lírio, cão, raposa, peixepalhaço, anémona. Cada espécie é implementada usando uma classe com atributos que podem ser bastante variados. Contudo, existem dois atributos que são comuns a todas as espécies: name (o nome da espécie, uma string) e time (o tempo médio de vida dos membros dessa espécie em segundos, um inteiro).
Relações simbióticas: Existem diversos tipos de relações simbióticas: mutualista quando os dois participantes recolhem benefícios; comensalística quando o primeiro participante beneficia e o segundo nem beneficia nem é prejudicado (geralmente o primeiro alimenta-se dos restos deixado pelo segundo); parasítica quando o primeiro beneficia e o segundo é prejudicado. Há outros tipos de relações simbióticas conhecidas e mais poderão vir a ser descobertos no futuro.
Cada relação simbiótica envolve duas componentes, que tanto podem ser espécies como podem ser outras relações simbióticas. Por exemplo: a relação [peixepalhaço-anémona] envolve só duas espécies; a relação [humano-cão] também só envolve duas espécies; mas a relação [[humano-cão]-raposa] já envolve uma relação simbiótica (caçador + cão) e uma espécie (raposa). Cada tipo de relação simbiótica é implementado usando uma classe com atributos que podem ser bastante variados. Mas existem dois atributos que são comuns a todas as relações simbióticas: l (o primeiro participante na relação) e r (o segundo participante na relação).
Problema
O objetivo deste problema é a definição dum sistema de classes bem fatorizado e extensível, adequado à representação de aspetos da vida. Escreva código compacto, bem fatorizado e extensível. No futuro vamos querer acrescentar novas espécies e novas variedades de relações simbióticas, e o programa tem de estar preparado para isso.
Programe apenas as classes abstratas do sistema. Se escrever classes concretas para exemplificar, deixe-as ficar vazias. As funções que todos as classes devem suportar são as seguintes quatro:
Recomendamos que use as seguintes classes, já identificadas. Se preferir, pode ignorar o que se oferece e fazer diferente.
class Life { // abstrato
}
class Species extends Life { // abstrato
}
class Human extends Species {…} // concreto -- não defina
class Dog extends Species {…} // concreto -- não defina
class Fox extends Species {…} // concreto -- não defina
class Symbiosis extends Life { // abstrato
}
class Mutualism extends Symbiosis { // abstrato
}
class Commensalism extends Symbiosis { // abstrato
}
class Parasitism extends Symbiosis { // abstrato
}
class HumanDog extends Mutualism {…} // concreto -- não defina
class HumanDogFox extends Parasitism {…} // concreto -- não defina