Salve ragazzi ho ancora necessità di alcuni vostri consigli che per molti di voi saranno stupidi.
Abbiate pietà di me ma sto passando un brutto periodo e la mia conoscenza della programmazione ad oggetti (anche grazie ad un prof inutile) è davvero precaria.
Non riesco a capire come impostare questo esercizio.
Ho la seguente implementazione della struttura dati Pila fatta da me:
#include <iostream>
#include <assert.h>
using namespace std;
template <class T>
class Pila {
public:
//Costruttori e Distruttore
Pila();
Pila(int n);
~Pila();
//Metodi delle specifiche
void creaPila();
bool pilaVuota() const;
T leggiPila() const;
void fuoriPila();
void inPila(T nuovo);
private:
T *elementi;
int MAX;
int testa;
};
template <class T>
Pila<T>::Pila(){
elementi = new T[100];
MAX = 100;
creaPila();
}
template <class T>
Pila<T>::Pila(int n){
elementi = new T[n];
MAX = n;
creaPila();
}
template <class T>
Pila<T>::~Pila(){
delete[] elementi;
}
template <class T>
void Pila<T>::creaPila(){
testa = 0;
}
template <class T>
bool Pila<T>::pilaVuota() const {
return testa == 0;
}
template <class T>
T Pila<T>::leggiPila() const {
assert(testa > 0);
return elementi[testa - 1];
}
template <class T>
void Pila<T>::fuoriPila(){
if(!pilaVuota())
testa--;
else
cout << "Nessun elemento nella lista" << endl;
}
template <class T>
void Pila<T>::inPila(T nuovo){
if(testa == MAX)
cout << "Raggiunta capienza massima" << endl;
else
{
elementi[testa] = nuovo;
testa++;
}
}
Fin qui tutto bene, utilizzando questa struttura dati dovrei svolgere il seguente esercizio:
TRACCIA ESERCIZIO:
Progettare ed implementare un classe MultipleStack che fornisca la gestione di m stack. La dichiarazione della classe dovrebbe essere simile a qualcosa del genere:
class MultipleStack
{
// ...
public:
MultipleStack (unsigned int);
void Push (Object&, unsigned int);
Object& Pop (unsigned int);
// ...
};
- Il costruttore ha in input un argomento di tipo intero che specifica il numero di stack da gestire
- la funzione Push ha due argomenti. Il primo è l'oggetto da inserire e il secondo specifica lo stack in cui inserirlo
- la funzione Pop ha in input un solo intero che specifica lo stack da cui eliminare un oggetto
Scegliere una delle seguenti implementazioni:
- tenere tutti gli stack in un solo array
- usare un array di oggetti di tipo Stack
- usare una lista collegata di oggetti di tipo Stack
FINE TRACCIA
Quello che mi chiedo è:
1. Questa classe deve essere un espansione della mia classe Pila? o deve essere una classe totalmente nuova che usa la struttura dati Pila grazie ad un #include "Pila.h" ???
2. il prof nella traccia ha definito il tipo "Object" senza mai averne accennato, ora mi chiedo: si tratta di un oggetto generico esattamente come funziona per Java? Se si, in quale libreria si trova dato che il compilatore non riconosce il tipo?
Se invece "Object" è solo un modo per farmi capire che devo usare la mia struttura dati mi chiedo: come faccio a passare una classe template per riferimento in una classe totalemente nuova??
Spero di aver esposto bene i miei dubbi, mi rendo conto che potrebbero essere un pò confusi (ma del resto io sono confuso!), potete darmi delle dritte (anche senza scrivere codice) sul come impostare questo esercizio?