Examen de Metodologia de la Programació UAB 2024 · Segon Parcial (Curs 2024-2025)

Es disposa de l'especificació següent per a gestionar registres d'alumnes i estructures basades en nodes:

class Estudiant

{

public:

void setNiu(const string& niu);

void setNom(const string& nom);

private:

string m_niu;

string m_nom;

};

class NodeEstudiant

{

public:

Estudiant& getValor() const;

NodeEstudiant* getNext() const;

void setValor(const Estudiant& valor);

void setNext(NodeEstudiant* next);

private:

Estudiant m_valor;

NodeEstudiant* m_next;

};

a.

Tenint definit el vector de referències següent:

Estudiant* estudiants[MAX_ELEMENTS]; L'objectiu del fragment de codi mostrat a continuació consisteix a reservar memòria per a un nou objecte dinàmic a cadascuna de les cel·les que encara no contingui cap instància (és a dir, aquelles amb valor nullptr). Es demana esmenar exclusivament les errades sintàctiques sense incorporar instruccions addicionals ni suprimir-ne cap:

for (int i = 0; i < MAX_ELEMENTS; i++)

{

if (*estudiants[i] == nullptr)

{

*estudiants[i] = new Estudiant();

string niu, nom;

cin >> niu;

estudiants[i].setNiu(niu);

cin >> nom;

estudiants[i].setNom(nom);

}

}

b.

Es presenta una rutina dissenyada per rebre un vector estàtic d'alumnes juntament amb el seu nombre d'elements i crear-ne una rèplica exacta en format dinàmic. Reescribiu completament la funció corregint tant els problemes sintàctics com els d'execució. Tingueu present que s'ha d'emprar la mateixa aritmètica de punters que al codi font primitiu (sense recórrer a la notació d'índex array[i] ni ptrEstudiants[i]):

Estudiant* copiaArrayEstudiants(Estudiant array[], int numEstudiants)

{

Estudiant* ptrEstudiants;

ptrEstudiants = new Estudiant;

for (int i = 0; i < numEstudiants; i++)

{

ptrEstudiants = (array + i);

ptrEstudiants++;

}

delete[] array;

return ptrEstudiants;

}

Es disposa de l'especificació següent per a gestionar registres d'alumnes i estructures basades en nodes:

class Estudiant

{

public:

void setNiu(const string& niu);

void setNom(const string& nom);

private:

string m_niu;

string m_nom;

};

class NodeEstudiant

{

public:

Estudiant& getValor() const;

NodeEstudiant* getNext() const;

void setValor(const Estudiant& valor);

void setNext(NodeEstudiant* next);

private:

Estudiant m_valor;

NodeEstudiant* m_next;

};

Exercici 1. Punteres, arrays dinàmics i manipulació de nodes

c.

Considereu la seqüència encadenada de tres nodes encapçalada pel punter primer que s'il·lustra a continuació:

Representeu gràficament o descriviu detalladament com queda l'encadenament un cop executat aquest conjunt d'instruccions:

NodeEstudiant* aux = primer->getNext()->getNext();

aux->setNext(primer->getNext());

primer->getNext()->setNext(nullptr);

primer->setNext(aux);

Exercici 2 (3 punts). Gestió de memòria dinàmica i classe Assignatura

Es disposa de l'especificació següent per a gestionar registres d'alumnes i estructures basades en nodes:

class Estudiant

{

public:

void setNiu(const string& niu);

void setNom(const string& nom);

private:

string m_niu;

string m_nom;

};

class NodeEstudiant

{

public:

Estudiant& getValor() const;

NodeEstudiant* getNext() const;

void setValor(const Estudiant& valor);

void setNext(NodeEstudiant* next);

private:

Estudiant m_valor;

NodeEstudiant* m_next;

};

Fent servir la classe Estudiant establerta prèviament:

a.

Dissenyeu una funció anomenada llegeixEstudiants que sol·liciti per teclat la quantitat de registres a processar i les dades personals de cadascun (primer el NIU i tot seguit el nom), assignant-los dins d'un bloc de memòria dinàmica que la pròpia funció retornarà. Tingueu present que la xifra d'alumnes pot resultar ser 0 (en tal cas retornarà punter nul). La rutina ha de proporcionar el nombre total d'estudiants registrats a través d'un paràmetre tramès per referència.

b.

A partir de la declaració de classe següent:

class Assignatura

{

public:

void afegeixEstudiants();

private:

Estudiant* m_estudiants;

int m_numEstudiants;

};

L'atribut m_estudiants representa un array dinàmic que conté exactament els m_numEstudiants inscrits fins al moment (la mida del bloc coincideix sempre amb la quantitat real de membres).

Programeu el mètode afegeixEstudiants que s'encarregui d'afegir noves matrícules. Per fer la lectura s'ha d'invocar la funció de l'apartat anterior. Les dades obtingudes han de fusionar-se amb les prèviament existents redimensionant l'estructura mitjançant un nou bloc de memòria amb la capacitat exacta acumulada. Cal gestionar adequadament tant la possibilitat que l'assignatura estigui buida prèviament com la que no s'afegeixi cap registre nou.

Es disposa de l'especificació següent per a gestionar registres d'alumnes i estructures basades en nodes:

class Estudiant

{

public:

void setNiu(const string& niu);

void setNom(const string& nom);

private:

string m_niu;

string m_nom;

};

class NodeEstudiant

{

public:

Estudiant& getValor() const;

NodeEstudiant* getNext() const;

void setValor(const Estudiant& valor);

void setNext(NodeEstudiant* next);

private:

Estudiant m_valor;

NodeEstudiant* m_next;

};

Exercici 3 (3 punts). Operador d'assignació per a una llista encadenada

Considerant la classe NodeEstudiant de l'Exercici 1, es defineix una classe contenidor per manipular una col·lecció enllaçada senzilla:

class Llista

{

public:

Llista();

~Llista();

Llista(const Llista& l);

Llista& operator=(const Llista& l);

NodeEstudiant* insereix(const Estudiant& pt, NodeEstudiant* posicio);

Node* elimina(NodeEstudiant* posicio);

int getNElements() const;

NodeEstudiant* getInici();

bool esBuida() const;

private:

NodeEstudiant* m_primer;

};

Implementeu el cos complet de l'operador d'assignació ( operator=) per a la classe Llista, assegurant el correcte alliberament de la memòria existent i la duplicació independent (còpia profunda) de tots els nodes.

Llista& Llista::operator=(const Llista& l)

Exercici 4 (2,5 punts). Classificació de tasques amb cues i llistes STL

Es disposa de la classe següent per modelar el seguiment d'activitats vinculades a un projecte:

class Tasca

{

public:

string getNom() const;

string getData() const;

int getPrioritat() const;

private:

string m_nom;

string m_data;

int m_prioritat;

};

L'atribut m_data especifica la data de registre i m_prioritat conté un dígit enter del 0 al 5 (on 5 simbolitza la màxima urgència i 0 la mínima).

Les activitats es troben emmagatzemades en un contenidor forward_list<Tasca>, disposades exclusivament per ordre cronològic de creació.

Es necessita generar una nova llista on figurin primer les tasques de major prioritat i, per a elements que tinguin el mateix nivell d'urgència, es mantingui la cronologia originària.

Per il·lustrar-ho, donada la llista inicial següent:

[(T1, 01/01/2025, 1), (T2, 01/02/2025, 2), (T3, 01/03/2025, 1), (T4, 01/04/2025, 5), (T5, 01/05/2025, 2)]

El resultat reordenat ha de quedar així:

[(T4, 01/04/2025, 5), (T2, 01/02/2025, 2), (T5, 01/05/2025, 2), (T1, 01/01/2025, 1), (T3, 01/03/2025, 1)]

Desenvolupeu la funció indicada emprant com a estructura temporal el vector de cues per prioritats ja declarat en el seu interior:

void reordenaTasques(forward_list<Tasca>& llistaOriginal, forward_list<Tasca>& novaLlista)

{

const int MAX_PRIORITATS = 6;

queue<Tasca> cuesPrioritat[MAX_PRIORITATS];

// Completeu el cos de la funció

}