Newsgroup: it.comp.lang.c++
Titolo: Pila ad oggetti

Salve ragazzi è da poco che ho cominciato lo studio della programmazione ad
oggetti in C++, quindi scusate la banalità delle mie domande.Devo fare un
programma che riempa una pila, usando le sole 4 funzioni che le strutture a
pila, ci consentono di usare, ovvero, una per controllare se la pila è
vuota, due per restituire l'elemento in cima alla pila, tre per costruire
la pila, quattro per levare il primo elemento della pila. Per essere più
ordinato ho diviso il programma in pila.h dove sono le intestazioni della
classe e dei suoi metodi, pila.cpp dove ci sono le operazioni che devono
svolgere i vari metodi e main.cpp dove c'è il main del programma. Il tutto
quando viene mandato in compilazione da un pò di errori, premetto che
programmo sotto linux con gcc, spero che qualcuno vorrà aiutarmi a capire
gli errori che ci sono, grazie a tutti ;-)
#ifndef __PILA__
#define __PILA__
#include<iostream>
using namespace std;
struct nodo
{
        int dato;
        struct nodo* next;
};
typedef struct nodo NODO;
class pila
{
        public:
        pila();
        ~pila();
        int empty();
        int top;
        NODO* push(int);
        NODO* pop();
        void mostra();
        private:
        NODO* head;
};
#endif
#include "pila.h"
        pila::pila(NODO* head)
        {
                head=NULL;
        }
        pila::~pila(NODO* head)
        {
                NODO* aux=NULL;
                aux=head;
                while(aux)
                {
                        head=head->next;
                        delete (aux);
                        aux=head;
                }
        }
        int pila::empty(NODO* head)
        {
                return (head==0);
        }
        NODO* pila::push(int d)
        {
                NODO* aux;
                aux=new(NODO);
                aux->dato=d;
                aux->next=head;
                head=aux;
        }
        NODO* pila::pop(NODO* head)
        {
                NODO* aux=head;
                head=head->next;
                delete(aux);
                return head;
        }
        void pila::mostra(NODO* head)
        {
                while(head)
                {
                        cout << head->dato << " ";
                        head=head->next;
                }
                cout << endl;
        }
#include "pila.h"
int main()
{
        NODO* head=NULL;
        int temp;
        pila pila1;
        temp=pila1.empty(head);
        if (temp)
                cout<< "La pila  è vuota" <<endl;
        else
                cout<< "La pila non è vuota" <<endl;
        for(int i=1;i<=10;i++)
                head=pila1.push(10*i);
        pila1.mostra(head);
        cout<< "Primo elemento" << pila1.top(head) <<endl;
        head=pila1.pop(head);
        pila1.mostra(head);
        head=pila1.push(head,17);
        pila1.mostra(head);
        return 0;
}
-- 
Icq #84624356

 
Bene, a questo punto molti di voi si chiederanno: "ma perche' hai 
risposto a quello che abbastanza evidentemente sembra essere un compito 
a casa?"
La risposta e': "non lo so, spero solo che Tux (usurpatore di nomi 
celebri) abbia raggiunto un gradino leggermente piu' elevato nella scala 
evolutiva dei programmatori C++".
Per finire, dico solo a Tux che la libreria standard C++ definisce ed 
implementa una classe container (in realta' un container adapter) che si 
chiama std::stack che gia' implementa una "pila" (stack in lingua 
inglese). Maggiori informazioni, documentazione ed esempi relativi al 
suo utilizzo li trovi nella documentazione del tuo compilatore e in 
ottimi libri sul linguaggio C++ (consiglio vivamente l'acquisto dello 
Stroutrup, almeno 3a edizione).
Studiare, studiare, studiare...
-- 
Roal Zanazzi

 celebri) abbia raggiunto un gradino leggermente piu' elevato nella scala
In che senso? Chi/cosa è il Tux celebre?

 In che senso? Chi/cosa è il Tux celebre?
Hai presente il pinguino simbolo di Linux... ecco lui si chiama Tux :-)
Faby

 ha scritto nel messaggio
news:opr2d6eb...@news.tin.it...

E' il nome del pinguino simbolo di Linux.
--
Ciao!
Skunkguru.

           pila::pila(NODO* head) : head(0) {}
Una domanda: cambia qualcosa, a livello realizzativo,
se si usa l'initializer list rispetto ai classici head=0?
O è solo una questione di forma?


Per forma, e' senz'altro meglio l'initializer list.
Non ricordo se ci sono anche dei motivi piu' pratici...
-- 
/**
  * Mattia Belletti - Undergraduate student @ 
cs.unibo.it
  * ICQ: 33292311   - email: 
mbel...@cs.unibo.it
  * IRC: BluShine   - site(s): 
http://cs.unibo.it/~mbellett
  * Linux registered user 299762 @ Linux registered machine 213003
  */

 ha scritto nel messaggio
news:opr2emp3...@news.tin.it...

Se non sbaglio con l'inizializer list il valore viene assegnato
una volta sola, mentre con head=0 viene assegnato due volte.
Esempio:
class C  {
    private:
         int myvar;
     public:
          C( );
}
C::C ( ) : myvar(0) { /*...*/ }
(qui myvar assume direttamente il valore 0)
C::C ( )
{
  myvar = 0;
   /*...*/
}
(qui viene assegnato un default a myvar, che viene
poi modificato col valore 0)
--
Ciao!
Skunkguru.

...

Cambia, perche' l'initializer list specifica i valori con cui sono
inizializzati i membri della classe. Quelli non specificati vengono
comunque inizializzati di default. Se poi assegni loro un valore nel
corpo del costruttore l'inizializzazione e' sprecata.
L'uso dell'inizializer list e' ancora piu' importante in presenza di
membri dati che sono istanze di classi, perche' concorre a migliorare
il comportamento della classe che li contiene in presenza di
eccezioni.
Ciao,
Nicola