Comparação de CHAR's - C

[Exgerth]

Fala galera...

o código abaixo é pra excluir todas as letras a de uma sequência, por exemplo.

se o a está no começo, exclui numa boa.

se está no meio ou no final, continua numa boa...

se puderem me ajudar eu fico imensamente grato!

char comp;

char teste[20];

Pilha p;

for (i=0; teste != '\0'; i++) {

comp = teste;

if (comp != 'a')

{

empilha(&p,&teste);

}

}

[Plateu]

Sinceramente não entendi sua dúvida.Qual seria o erro no seu código?

Se puder, poste, usando as tags de spoiler ,o conteúdo da header Pilha.h, pois sem ela não posso entender o funcionamento de nada.Abraços.

edit:Pelo seu título, acho que você quer buscar certo caracter e elimina-lo da pilha, correto?

[Exgerth]

Exato. eu quero eliminar um caracter da string.

é meio vergonhoso isso, porque é uma dúvida bem *****...

os códigos são:

PILHA.H

/*

* quantidade máxima de elementos que podem

* estar contidos em uma pilha

*/

#define TAM_MAX_PILHA 100

/* constantes para trabalhar com tipo "booleano" */

#define BOOLEAN int

#define TRUE 1

#define FALSE 0

/*

* Estrutura que representa uma pilha (utiliza o

* paradigma LIFO "last in first out").

*/

typedef struct Pilha {

int topo;

void* pilha[TAM_MAX_PILHA];

} Pilha;

/*

* Devolve TRUE se a pilha "p" estiver vazia,

* e devolve FALSE caso contrário.

*/

BOOLEAN estaVazia(Pilha* p);

/*

* Devolve TRUE se a pilha "p" estiver cheia,

* e devolve FALSE caso contrário.

*/

BOOLEAN estaCheia(Pilha* p);

/*

* Insere o "elemento" no topo da pilha "p".

*/

void empilha(Pilha* p, void* elemento);

/*

* Remove e devolve o elemento que está no topo da pilha "p".

*/

void* desempilha (Pilha* p);

/*

* Devolve o elemento que está no topo da pilha "p".

*/

void* topo (Pilha* p);

/*

* Inicializa a pilha "p" (inicialmente a pilha "p" está vazia).

*/

void inicializa(Pilha* p);

PILHA.C

#include "pilha.h"

#include <stdio.h>

#include <assert.h>

void* topo (Pilha* p) {

assert(!estaVazia(p));

return p->pilha[p->topo];

}

BOOLEAN estaVazia(Pilha* p) {

return p->topo == -1;

}

BOOLEAN estaCheia(Pilha* p) {

return p->topo == TAM_MAX_PILHA - 1;

}

void empilha(Pilha* p, void* elemento) {

assert(!estaCheia(p));

p->pilha[++p->topo] = elemento;

}

void* desempilha (Pilha* p) {

assert(!estaVazia(p));

return p->pilha[p->topo--];

}

void inicializa(Pilha* p) {

p->topo = -1;

}

MAIN

#include <stdio.h>

#include <stdlib.h>

#include "pilha.h"

#include <string.h>

int main()

{

Pilha p;

char teste[20],

char* teste2;

char* temp;

char comp;

int i,j;

inicializa(&p);

scanf("%s", &teste);

comp = 'a';

for (i=0; teste =! '\0' ; i++) {

if (teste != comp){

empilha(&p, &teste);

}

}

while ( estaVazia(&p) != TRUE ) {

temp = desempilha(&p);

if (*temp != '(') {

teste2 = temp;

}

}

printf("%s\n", teste2);

system("PAUSE");

return 0;

}

[Plateu]

Pelo que vi, você esta tentando implementar pilhas na linguagem C. Em C++ isso é até simples de se fazer, pelo fato de trabalharmos com orientação a objetos;mas em C acho que fica um pouco inviável.Talvez alguem já tenha feito algo parecido no C e possa te ajudar. Se puder fazer em C++, posso orientá-lo.Abraços

Exato. eu quero eliminar um caracter da string.

é meio vergonhoso isso, porque é uma dúvida bem *****...

os códigos são:

PILHA.H

/*

* quantidade máxima de elementos que podem

* estar contidos em uma pilha

*/

#define TAM_MAX_PILHA 100

/* constantes para trabalhar com tipo "booleano" */

#define BOOLEAN int

#define TRUE 1

#define FALSE 0

/*

* Estrutura que representa uma pilha (utiliza o

* paradigma LIFO "last in first out").

*/

typedef struct Pilha {

int topo;

void* pilha[TAM_MAX_PILHA];

} Pilha;

/*

* Devolve TRUE se a pilha "p" estiver vazia,

* e devolve FALSE caso contrário.

*/

BOOLEAN estaVazia(Pilha* p);

/*

* Devolve TRUE se a pilha "p" estiver cheia,

* e devolve FALSE caso contrário.

*/

BOOLEAN estaCheia(Pilha* p);

/*

* Insere o "elemento" no topo da pilha "p".

*/

void empilha(Pilha* p, void* elemento);

/*

* Remove e devolve o elemento que está no topo da pilha "p".

*/

void* desempilha (Pilha* p);

/*

* Devolve o elemento que está no topo da pilha "p".

*/

void* topo (Pilha* p);

/*

* Inicializa a pilha "p" (inicialmente a pilha "p" está vazia).

*/

void inicializa(Pilha* p);

PILHA.C

#include "pilha.h"

#include <stdio.h>

#include <assert.h>

void* topo (Pilha* p) {

assert(!estaVazia(p));

return p->pilha[p->topo];

}

BOOLEAN estaVazia(Pilha* p) {

return p->topo == -1;

}

BOOLEAN estaCheia(Pilha* p) {

return p->topo == TAM_MAX_PILHA - 1;

}

void empilha(Pilha* p, void* elemento) {

assert(!estaCheia(p));

p->pilha[++p->topo] = elemento;

}

void* desempilha (Pilha* p) {

assert(!estaVazia(p));

return p->pilha[p->topo--];

}

void inicializa(Pilha* p) {

p->topo = -1;

}

MAIN

#include <stdio.h>

#include <stdlib.h>

#include "pilha.h"

#include <string.h>

int main()

{

Pilha p;

char teste[20],

char* teste2;

char* temp;

char comp;

int i,j;

inicializa(&p);

scanf("%s", &teste);

comp = 'a';

for (i=0; teste =! '�' ; i++) {

if (teste != comp){

empilha(&p, &teste);

}

}

while ( estaVazia(&p) != TRUE ) {

temp = desempilha(&p);

if (*temp != '(') {

teste2 = temp;

}

}

printf("%sn", teste2);

system("PAUSE");

return 0;

}

[Exgerth]

Posso fazer em c++ sem problemas.