Newsgroup: it.comp.lang.c++
Titolo: problemi con classi e overload funzioni

Ciao,
sto provando ad usare le classi.
Ho realizzato una classe stack, 
con cui creo uno stack (last in first out)
su cui sono definite le funzioni 
push: immetto l'elemento,
pop:  prelevo l'elemento,
top: leggo l'ultimo elemento,
is_empty, is_full : vede se e' vuoto o pieno
size: restituisce la dimensione dello stack.
Ho realizzato lo stack in modo dinamico (usando malloc)
e in modo statico (dichiarando un vettore in private).
Adesso vorrei sfruttare l'overload di funzioni e creare 2 metodi
costruttori uno per creare uno stack dinamico
e l'altro per creare uno stack statico.
Il codice della classe stackdinamico e' il seguente:
//classe stack con allocazione dinamica
#include <stdlib.h>            //contiene malloc
class stack{
   private:
      int *mem;               //puntatore allo stack
      int head;               //punta al 1° elemento vuoto
      int N_MAX;              //dimensione dello stack
   public:
      /*metodo costruttore*/
      stack(int dim);
      void push(int); // immette un elemento nello stack
      int pop();      /* preleva l'ultimo elemento immesso e  	
                         decrementa head*/
      int top();      /* preleva l'ultimo elem. immesso ma non  	
                         decrementa head*/
      int is_empty(); // vede se lo stack e' vuoto
      int is_full();  // vede se lo stack e' pieno
      int size();     //restituisce la dimensione dello stack
};
stack :: stack(int dim){
      mem = (int *)malloc(dim * sizeof(int));
      if (mem==NULL)   //se malloc e' fallita la dimensione e' 0
      	N_MAX=0;
      else
      	N_MAX=dim;    /*se malloc ha assegnato la memoria la 	 
                        dimensione e' dim*/
      head = 0;
      }
void stack :: push (int x){
      if(!is_full())
      	mem[head++]=x;
      }
int stack :: pop(){
	return mem[--head];
      }
int stack :: top(){
	return mem[head-1];
      }
int stack :: is_empty(){
	return head==0;
      }
int stack :: is_full(){
	return head == N_MAX;
      }
int stack :: size(){
	return N_MAX;
      }
per raggiungere il mio scopo volevo modificarla cosi':
#define dimstat  10   //dimensione stack statico
aggiungere in private:
      int vett[dimstat];  //vettore per lo stack statico
aggiungere in public:
      stack(); 
definito successivamente nel modo seguente:
stack :: stack(){
	mem = vett;
	N_MAX = dimstat;
	head = 0;
	}
questa soluzione non ne vuole saper di funzionare.
Il programma principale e' il seguente:
//stack dinamico con metodo costruttore
#include "stackdinamico.h" 		// contiene la classe stack
#include <stdio.h>    			// contiene printf e scanf
#include <conio.h>    		        // contiene getch()
main(){                           
   int elem;     //elemento dello stack                 
   int dim;      //dimensione dello stack
   printf("immetti la dimensione dello stack\n");
   scanf("%d",&dim);
   // definisco s come variabile di tipo stack di dimensione dim
   stack s(dim);
   dim = s.size();      // dim e' la grandezza dello stack
//controlla se lo stack e' stato inizializzato
if(dim!=0){
   //finche' non e' pieno immetto i dati
   while(!s.is_full()){
   	scanf("%d", &elem);
        s.push(elem);
      }//while
   if (s.is_full())              // se e' pieno stampa ok
   	printf ("ok\n");
   else                          // altrimenti stampa errore
   	printf("errore\n");
   // finche' non e' vuoto stampa gli elementi
   while (!s.is_empty()){
      elem=s.pop();
      printf("%d\n",elem);
      }//while
}//if
else
	printf("\nvuoi creare uno stack troppo grande");
printf("\npremi un tasto per terminare");
getch();  	      	// non fa terminare subito il programma
}//main   
se sostiutisco :  
stack s(dim);
con stack s; o stack s();
il programma non viene compilato e il borland 5.02 da i seguenti
errori:
! stackdinamico.h cannot create pre-compiled header: code in header
e 6 volte
! stackdinamico.cpp structure required on left side of . or .*
Saro' grato a chiunque possa aiutarmi.
Saluti
Nichi
ni...@libero.it
 

 
ni...@libero.it
Con il Visual c++ si compila benissimo!
Attento che  un costruttore senza parametri come stack( ) va invocato cosě :
stack s;  //  e non  stack s( )  !!
Non so perchč ma pare che stack s() venga comunque compilato ma non invoca
di certo un costruttore.
Chi ne sa qualcosa?
Ciao.

 Chi ne sa qualcosa?
stack s();
e' la dichiarazione di una funzione che si chiama s che ritorna uno
stack. Se un'istruzione puo' essere interpretata sia come una
dichiarazione che come la chiamata di una funzione, il compilatore e'
tenuto a riconoscerla come dichiarazione.
Ciao,
Nicola

 [CUT]
Il tuo programma presenta vari problemi risolvibili
con la lettura di un buon manuale di C++.
Manlio Perillo