Resolução de Prova de Avaliação:

2ª Chamada, 1999/2000, 10/7/2000

1/

Erros:

1. Linha 6: Não se pode inicializar membros-dado na parte privada da classe. Essa tarefa deve ser atribuída ao construtor. Esta linha deve ficar: T position[2];.
2. Linha 9: Membros-constantes (length e height) não podem ser inicializados no corpo do constructor, mas sim no cabeçalho. A linha pode ficar então:

: length(lengthRect), height(heightRect) { setPosition()}
3. Linha 13: Deve ser  return height*length  em vez de Area = height*`length
4. Linhas 14 e 16: o tipo de retorno da função deve ser  rectangle &  e o retorno deve ser  return *this
5. Linha 14: A função não deve ser declarada com o atributo const uma vez que vai alterar membros-dado do objecto invocador
6. Linha 15: A variável  position é um array e tal deve ser indicado. Deve ficar então:   position[2]={x, y];
7. Linha 23: R2 é um array de objectos do tipo rectangle. Deve pois ser indicado um índice para aceder a uma das posições desse array (a um dos dois objectos constituíntes do array). Deve então ficar (por exemplo): R2[0].setPosition(1,3);
8. Linha 24: Ilegal, porque height é privado e, além disso, é constante. Uma solução é escrever: R1 = rectangle(2, 2);
9. Linha 25: Para fazer esta operação seria necessário ter feito o overload do operador  = .
10. Linha 26: A função Area() não recebe parâmetros. Devem ser os objectos R1 e R3 a invocar a função do modo seguinte:  cout << "Area(R1)="<< R1.Area()<< "\nArea(R3) = "<< R3.Area() << endl;

Area(R1) = 4  (supondo que a linha 24 foi corrigida de acordo com o proposto)
Area(R3) = 1  (supondo que a linha 25 foi eliminada)

2/

double calc_bin_op(Queue<CalcElement> & dados)
{
  Stack<CalcElement> tmp(dados.Length());

  while(! dados.IsEmpty()) {
    CalcElement X;
    dados.Delete(X);
    if (X.IsValue())
      tmp.Add(X);
    else {
      CalcElement Arg1, Arg2;
      tmp.Delete(Arg2);
      tmp.Delete(Arg1);
      CalcElement Res(calc_bin_op(X.Operator(), Arg1.Value(), Arg2.Value());
      tmp.Add(Res);
    }
  }
  CalcElement Resultado;
  tmp.Delete(Resultado);
  return Resultado.Value();
}

3/

template <class T>
BinaryTree<T> & BinaryTree<T>::Mirror(void)
{
  Mirror(root);
  return *this;
}

template <class T>
void BinaryTree<T>::Mirror(BinaryTreeNode<T>* t)
{
  if(! t)
    return;
  BinaryTreeNode<T> * dummy = t->LeftChild;
  t->LeftChild = t->RightChild;
  t->RightChild = dummy;
  Mirror(t->LeftChild);
  Mirror(t->RightChild);
}

4/

Utilizaria um grafo para representar a referida rede. Nesse grafo, os nós representam os comutadores e os vértices representam as ligações físicas. Sendo as ligações Ethernet bidirectionais, utiliaria um grafo não dirigido (quando uma ligação Ethernet é inibida, o tráfego é impedido em ambos os sentidos).
Os vértices, além de indicarem a existência de uma ligação física, deverão também poder indicar o estado de activação das mesmas. Isto é fácil de implementar tanto num grafo representado por uma matriz de adjacências como por um grafo representado por um vector de listas ligadas. A escolha de um tipo ou outro é, portanto, pouco relevante.

A determinação das ligações que deverão ser inibidas pode ser obtida através de uma variante de um algoritmo de pesquisa do grafo, quer seja do tipo BFS, quer seja do tipo DFS. Nesta variante, sempre que um nó ainda não visitado é atingido através de um determinada ligação, esta é marcada como activa; sempre que um nó já visitado é atingido atraves de uma determinada ligação, esta é marcada como inactiva.
Todos os nós dos quais partam ligações ainda não marcadas pertencem a pedaços de rede isolados de outros já analisados. Assim, esta variante do algoritmo de pesquisa deve ser invocada para cada nó que ainda tenha ligações não marcadas.