Template para Pilhas [RESOLVIDO]

dandrade
(usa Fedora)

Enviado em 02/10/2014 - 18:21h

/**** main exemplo

#include <iostream>

#include <cstdlib>

#include <iomanip>

#include <stdio.h>

#include <ctype.h> //biblioteca p/ as funções isalpha isdigit toupper tolower

#include <unistd.h> //sleep

#include <locale.h>

#include <string.h>

#include <stdio.h>



#include \"pilhas.h\"

#include \"template.h\"



Pilha<char> p(5); // cria uma pilha de char de tamanho 5

    p.exibe();

    cout << \"<>\";

    p.insere(\'a\');

    p.insere(\'b\');

    cout << \"  elementos=\" << p.exibe() << \"??\";   // ***** PORQUE SEQUENCIA DE EXECUCAO DA LINHA E DE TRAZ PRA FRENTE

    cout << endl << \" <<< INCOERENCIA RESULTADO ACIMA \" << endl;

    p.exibe();

    p.insere(\'c\');

//        while( !p.vazia() )  cout << p << endl;

    while( !p.vazia() )    cout << p.remove() << endl; //percorre a pilha e remove elementos

    Pilha<double> q(5); // cria uma pilha de double

    q.insere(1.2);

    q.insere(3.4);

    q.insere(5.6);

    q.exibe();

    //cout >> Pilhamenor(q);// >> \"  \" >> maior(q) >> \"pilha\";

    while( !q.vazia() )    cout << q.remove() << endl;







/*** fim main





/***** Pilha.h



/*********CLASSE DO CONTEUDO DE UMA PILHA************/

template <class Tipo>

class Pilha {

    public:

        Pilha(int);  //construtor

        ~Pilha(void); //destrutor

        //Tipo seleta(char a);

        void insere(Tipo); //insere um elemento na pilha

        Tipo remove(void); //remove um elemento na pilha

        Tipo reseta(void);

        Tipo exibe(void);

        Tipo exibir(void);

        Tipo topo(void);

        Tipo anterior(void);

        bool vazia(void);

        bool cheia(void);

    private:

        int max;

        int pos;

        int top;

        Tipo *mem;  //cria um ponteiro para Pilha

};



template <class Tipo> Pilha<Tipo>::Pilha(int n)

{

    top = -1;

    pos= -1;

    mem = new Tipo[max = n];  //aloca a memoria conforme tamanho definido em max

}

template <class Tipo> Pilha<Tipo>::~Pilha(void)

{

    delete[] mem; //deleta o ponteiro excluindo o recurso

}

template <class Tipo> Tipo Pilha<Tipo>::reseta(void)

{

    top=-1; //zera o indice resetando a pilha a tamanho nulo

    return 0;

}



template <class Tipo> void Pilha<Tipo>::insere(Tipo e)

{

    if( !cheia() )    mem[++top] = e;



}

template <class Tipo> Tipo Pilha<Tipo>::remove(void)

{

    if( !vazia() ) return mem[top--];



}

template <class Tipo> Tipo Pilha<Tipo>::topo(void)

{

    if( !vazia() )    return mem[top];

    else return 0;



}

template <class Tipo> Tipo Pilha<Tipo>::anterior(void)

{

    if( !vazia() )   return mem[top-1];

    else return 0;



}

template <class Tipo> bool Pilha<Tipo>::vazia(void)

{

    if(top==-1)return true;

    else return false;

}

template <class Tipo> bool Pilha<Tipo>::cheia(void)

{

    if(top==max-1)return true;

    else return false;

    // PORQUE NAO FUNCIONA TERNARIO   top == max -1 ? return true : return false;



}

template <class Tipo> Tipo Pilha<Tipo>::exibe(void)

{

    int count=top;



    if(!vazia())for(;count>-1;count--)cout << mem[count];// << \"   Posição=\" << count << endl;

    else cout << \"Pilha vazia\" << endl;

    return 0;

}

// FUNCAO RECURSIVA EXIBIÇÃO

template <class Tipo> Tipo Pilha<Tipo>::exibir(void)

{



    if(pos<0)pos=top; //inicializa na entrada da chamada



    //pos>0 ? cout << mem[pos--],exibir() : return 0;   //no final pos=-1 condição inicial



}

/***** FIM pilha.h

/****** TEMPLATES GENERICOS  **** Template.h

#ifndef TEMPLATE_H_INCLUDED

#define TEMPLATE_H_INCLUDED



template <class T, int N>

int vetorsize( T (&tab)[N] ) {  // aplicação => int x= vetorsize(array variavel);

  return N;  //retorna o tamanho do array

  }



  // Somatoria dos elementos

template <class T, int N>

T somatoria(T (&vetor)[N]){

    int register c;

    T acum=0; //cria variavel do mesmo tipo da chamada



    for(c=0;c<N;c++)acum+=vetor[c];

    //printf(\"\\nTAM %d vetor=%d acum=%d \",N,vetor[c],acum);

    return acum;

}



//******************* COM RECURSÃO ***************************



// somatoria dos elementos com recursão chamada acumulado(array, elementos a somar);

template <class T, int N>

T acumulador(T (&vetor),int k){



    int register c=N;

    T acum=NULL; //cria variavel do mesmo tipo da chamada com valor NEUTRO

    if(k < vetorsize(&vetor))acum+=acumulador(&vetor,k++);

    else return acum;

            // o que esta errado no ternario

//    k < vetorsize(&vetor) ? acum+=acumulador(&vetor,k++),return acum;



}





//Encontra o maior valor

template <class K, int N>

K maior(K (&vetor)[N]){

    int register c ;

    K ve[0]; //cria variavel do mesmo tipo da chamada com valor NEUTRO

    ve[0]=vetor[0]; //

    for(c=0;c<N;c++){

            if(vetor[c]>ve[0])ve[0]=vetor[c];

            }

    return ve[0];

}

//Encontra o menor valor

template <class K, int N>

K menor(K (&vetor)[N]){

    int register c ;

    K ve[0]; //cria variavel do mesmo tipo da chamada com valor NEUTRO

    ve[0]=vetor[0]; //

    for(c=0;c<N;c++){

            if(vetor[c]<ve[0])ve[0]=vetor[c];

            }

    return ve[0];

}



/******************* Fim Template.h