Jump to content
gimguba++c++

erro de código, estou as aranhas.

Recommended Posts

gimguba++c++

Tenho que entregar trabalho ate as 12h de amanha.

Calculadora usando Listas e pilhas, com aplicação em win32.

erros

Quando:

chama case 18 " resultado das operaçoes"

chama case 19 " para limpar"

main.cpp

-------------------------------------------------------------------------

#define _WIN32_IE 0x500
#include <windows.h>
#include <commctrl.h>
#include <stdio.h>
#include "Pilha.c"
#include "ListasSL.c"
#include <math.h>
#include "Pilha.h"
#include "ListasSL.h"

#define ID_Botao_Zero 1000
#define ID_Botao_Um 1001
#define ID_Botao_Dois 1002
#define ID_Botao_Tres 1003
#define ID_Botao_Quatro 1004
#define ID_Botao_inco 1005
#define ID_Botao_Seis 1006
#define ID_Botao_Sete 1007
#define ID_Botao_Oito 1008
#define ID_Botao_Nove 1009
#define ID_Botao_Vezes 1010
#define ID_Botao_Dividir 1011
#define ID_Botao_mais 1012
#define ID_Botao_Menos 1013
#define ID_Botao_Igual 1014
#define ID_Botao_Apagar 1015


LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
HWND hTab, hEdit_Total, Botao,Botao_sqrt,Botao_Vezes,Botao_Dividir,Botao_Mais,Botao_Menos,Botao_Igual,Botao_Apagar;
HINSTANCE g_hinst;

ListaSL* transforma(char *str);
ListaSL* posfixa(ListaSL *l);
double calcula(ListaSL *l);


int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow )
{
  //
 MSG  msg ;
 WNDCLASS wc = {};
 wc.lpszClassName = TEXT( "Application" );
 wc.hInstance	 = hInstance ;
 wc.hbrBackground = GetSysColorBrush(COLOR_WINDOWFRAME);
 wc.lpfnWndProc   = WndProc ;
 wc.hCursor	   = LoadCursor(0,IDC_ARROW);


 g_hinst = hInstance;

 RegisterClass(&wc);

Obrigado pela atenção

  CreateWindow( wc.lpszClassName, TEXT(" CALCULADORA 2013 "),
			WS_OVERLAPPEDWINDOW | WS_VISIBLE ,				// mostra janela da Calculdora
			300,100,750,500, 0, 0, hInstance, 0);
			//dist_X, dist_y, largura ,altura , 0, 0, hInstance, 0);		// posição da janel ano fundo


 while( GetMessage(&msg, NULL, 0, 0)>0)
 {
TranslateMessage(&msg);
DispatchMessage(&msg);
 }
 return (int) msg.wParam;
}


LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

int len;
  TCHAR text[250];
  LRESULT id;
  INITCOMMONCONTROLSEX icex;


  switch(msg) {

   case WM_CREATE:
   // DesenharObjectos(hwnd,message,wParam,lParam);

	   icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
	   icex.dwICC = ICC_TAB_CLASSES;
	   InitCommonControlsEx(&icex);


// dysplay valor
	hEdit_Total = CreateWindowEx(WS_EX_CLIENTEDGE,"EDIT","", WS_VISIBLE |WS_CHILD| WS_BORDER,
		  200, 20, 350, 50, hwnd, NULL,g_hinst, NULL);
// 1ªcoluna

	  Botao=CreateWindow("button","0",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  40, 400, 100, 40, hwnd, (HMENU) 10, g_hinst, NULL);

	  Botao=CreateWindow("button","7",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  40, 300, 100, 40, hwnd, (HMENU) 7, g_hinst, NULL);

	  Botao=CreateWindow("button","4", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  40, 200, 100, 40, hwnd, (HMENU) 4, g_hinst, NULL);

	  Botao=CreateWindow("button", "1", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  40, 100, 100, 40, hwnd, (HMENU) 1, g_hinst, NULL);
// 2ªcoluna
	  CreateWindow("button","sqrt",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  190, 400, 100, 40, hwnd, (HMENU) 11, g_hinst, NULL);

	  Botao=CreateWindow("button","8",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  190, 300, 100, 40, hwnd, (HMENU) 8, g_hinst, NULL);

	  Botao=CreateWindow("button","5", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  190, 200, 100, 40, hwnd, (HMENU) 5, g_hinst, NULL);

	  Botao=CreateWindow("button", "2", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  190, 100, 100, 40, hwnd, (HMENU) 2, g_hinst, NULL);
// 3ªcoluna
	  Botao=CreateWindow("button",",",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  350, 400, 100, 40, hwnd, (HMENU)12 , g_hinst, NULL);

	  Botao=CreateWindow("button","9",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  340, 300, 100, 40, hwnd, (HMENU) 9, g_hinst, NULL);

	  Botao=CreateWindow("button","6", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  340, 200, 100, 40, hwnd, (HMENU) 6, g_hinst, NULL);

	  Botao=CreateWindow("button","3", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  340, 100, 100, 40, hwnd, (HMENU) 3, g_hinst, NULL);
// 4ªcoluna
	  Botao_Menos=CreateWindow("button","-",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  490, 400, 100, 40, hwnd, (HMENU) 13, g_hinst, NULL);

	  Botao_Mais=CreateWindow("button","+",WS_CHILD | WS_VISIBLE | WS_BORDER,
		  490, 300, 100, 40, hwnd, (HMENU) 14, g_hinst, NULL);

	  Botao_Dividir=CreateWindow("button","/", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  490, 200, 100, 40, hwnd, (HMENU) 15, g_hinst, NULL);

	  Botao_Vezes=CreateWindow("button","*", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  490, 100, 100, 40, hwnd, (HMENU) 16, g_hinst, NULL);

	Botao_Igual=CreateWindow("button","=", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  630, 240, 70, 200, hwnd, (HMENU) 18, g_hinst, NULL);

	Botao_Apagar=CreateWindow("button","DEL", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
		  630, 100, 70, 100, hwnd, (HMENU) 19, g_hinst, NULL);

  case WM_COMMAND:


	   switch(LOWORD(wParam)) {


case 1:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '1';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;


case 2:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '2';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 3:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '3';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 4:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '4';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;

case 5:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '5';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;

case 6:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '6';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 7:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '7';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 8:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '8';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 9:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '9';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;

case 10:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '0';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 11:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = 'r';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;

case 12:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = ',';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 13:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '-';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;

case 14:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '+';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 15:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '/';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 16:
			   len = GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);
			   text[len-1] = '*';
			   text[len] = '\0';
			   SetWindowText(hEdit_Total, text);
			   break;
case 18:
			   id= GetWindowTextLength(hEdit_Total)+1;
			   GetWindowText(hEdit_Total, text, len);

			 if(id!='0')
			{

			  ListaSL *l = transforma(text);
			   ListaSL *l1=posfixa(l);
			   double r = calcula(l1);
			   char str[100];
			   sprintf(str, "%lf", r);
			   SetWindowText(hEdit_Total, str);
			  }
			   break;
case 19:
			   id = SendMessage(hTab, TCM_GETCURSEL, 0, 0);
			   if (id !=-1)
			   {
				   SendMessage(hTab, TCM_DELETEITEM, 0, id);
			   }
			   break;
	   }
		break;

   case WM_DESTROY:
	   PostQuitMessage(0);
	   break;


  }
  return(DefWindowProc(hwnd, msg, wParam, lParam));

}

ListaSL* posfixa(ListaSL *l)// forneço em in fix e devolve em pos fixo
{

ListaSL *l1= cria();
Pilha *p = cria_p();

  //aux = l->head;
Nodo *aux = l->head;

while (aux != NULL)	 // lista
{
	if(aux->dados[0]!='*' && aux->dados[0]!='/' && aux->dados[0]!='+' && aux->dados[0]!='-') // valores de (0...9)

	  insereFim(l,aux->dados);// colocar elemento na fila , inserir no fim da lista
	else											  // par valores de aux ( * || / || + || - )
	{
		if (estaVazia_p(p))						   // esta vazia
			push_p(p, aux->dados);					// coloca parametros p ( * || / || + || - )
		else										  // Nao esta vazia
		{
		   char* t = peek_p(p);					// ponteiro t devolve parametro p
		   if (prioridade(aux->dados[0]) > prioridade(t[0]))   // SE prioridade dos operadores > dados ( * || / || + || - )
				push_p(p, aux->dados);			 // coloca na pilha ( * || / || + || - )
			else								   // SE prioridade dos operadores < dados ( * || / || + || - )
			 {
			   do
			   {
					insereFim(l1,pop_p(p));		// remove da Pilha parametro p, e insere no fim da lista
					if (estaVazia_p(p))			// se pilha esta vazia
					  break;					   // sai
					t = peek_p(p);				 // devolve o parametro que estiver ( * || / || + || - )
			   }
			   while (prioridade(aux->dados[0])>=prioridade(t[0]));  // Enquanto prioridade actual ( * || / || + || - )  < prioridade anterior
			   push_p(p, aux->dados);



		   }
		}
	}
	  aux = aux->proximo;

};
// agora despeja


while(!estaVazia_p(p)) //Enquanto a pilha não estiver vazia
{
	insereFim(l1,pop_p(p)); //remove parametro p  ( * || / || + || - ) e insere no fim da lista
}
  liberta_p(p);

return l1;
}

ListaSL* transforma(char *str){
ListaSL *l= cria();

//

int i;
int j=0;
char express_mat [j]; // auxiliar express_mat de um array


 for(i=0; i<strlen(str) ;i++)// express_mat caracter a caracter
 {

// printf("%c\n",argv[1][i]); // imprime caracter um a um com o tamanho da string [1] *   [i]  *




if (  str[i]=='*' || str[i]=='/' || str[i]=='+' || str[i]=='-' ) // teste array [i],qd sao operadores
	{
express_mat[j]='\0';	   // variavel auxiliar com array [j]
 insereFim(l, express_mat);

// colocar os operadores
	  express_mat[0]=str[i];
	  express_mat[1]='\0';
  insereFim(l, express_mat);

j=0;


}
// verificada a inexistencia de operadores
else
{
express_mat[j]=str[i];
j++;
if (i == strlen(str)-1) // tamanho do array-1
{
express_mat[j]='\0';
 insereFim(l, express_mat);


}
}

}

return l;
}

double calcula(ListaSL * l)
{

Pilha *p = cria_p();

Nodo *aux = l->head;
while (aux != NULL)	 // lista
{

 if(aux->dados[0]!='*' && aux->dados[0]!='/' && aux->dados[0]!='+' && aux->dados[0]!='-') // valores de (0...9)
 {
	 push_p(p, aux->dados);
 } else {
	 char *pri = pop_p(p);
	 char *seg = pop_p(p);
	 double r;
	   if(aux->dados[0]=='*')
		  r = atof(seg)*atof(pri);
	if(aux->dados[0]=='/')
		  r = atof(seg)/atof(pri);
		  if(aux->dados[0]=='+')
		  r = atof(seg)+atof(pri);
		  if(aux->dados[0]=='-')
		  r = atof(seg)-atof(pri);

		  char str[100];
		  sprintf(str,"%lf", r);

		  push_p(p, str);
 }

aux = aux->proximo;
}

return atof(pop_p(p));
}




int prioridade(char op)
{
if (op == '+' || op == '-')
	return 1;
else
	return 2;
}

------------------------------------------------------------------

listasSl.c

-------------------------------------------------------------------

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "ListasSL.h"
#include <windows.h>


ListaSL* cria() {
ListaSL* l = (ListaSL*)malloc(sizeof(ListaSL)+1);
l->head = NULL;
l->tail = NULL;
return l;
}

void liberta(ListaSL *l) {
Nodo *aux;
aux = l->head;
while(aux != NULL) {
	l->head = l->head->proximo;
	free(aux);
	aux = l->head;
}
free(l);
}

int estaVazia(ListaSL *l) {
return l->head == NULL;
}
//-------------------------------------------//
int insereFim(ListaSL *l, char *info) {
Nodo *n = (Nodo*)malloc(sizeof(Nodo));
if (n == NULL)
	return 0;
//n->dados=info; // com esta linha de codigo teria 544 544 544 544 544
n->dados=(char*)malloc(sizeof(char)*strlen(info)+1);
strcpy(n->dados,info);

n->proximo = NULL;
// lista vazia
if (l->head == NULL) {
	l->head = n;
	l->tail = n;
} else {
	l->tail->proximo = n;
	l->tail = n;
}
return 1;
}
//------------------------------------------------//

int insereInicio(ListaSL *l, char* info) {
Nodo *n = (Nodo*)malloc(sizeof(Nodo));
if (n == NULL)
	return 0;
n->dados=(char*)malloc(sizeof(char)*strlen(info)+1);
strcpy(n->dados,info);
n->proximo = NULL;
// lista vazia
if (l->head == NULL) {
	l->head = n;
	l->tail = n;
} else {
	n->proximo = l->head;
	l->head = n;
}
return 1;
}


int insereOrdenado(ListaSL *l,char * info) {
Nodo *n = (Nodo*)malloc(sizeof(Nodo));
Nodo *aux;
if (n == NULL)
	return 0;
n->dados=(char*)malloc(sizeof(char)*strlen(info)+1);
strcpy(n->dados,info);
n->proximo = NULL;
// lista vazia
if (l->head == NULL) {
	l->head = n;
	l->tail = n;
} else {
	aux = l->head;
	if (info < aux->dados) {
		n->proximo = l->head;
		l->head = n;
	} else {
	while (aux->proximo != NULL && aux->proximo->dados < info)
		aux = aux->proximo;

   n->proximo = aux->proximo;
   aux->proximo = n;
	}
}
return 1;
}

//------------------------------------------------------//
int existe(ListaSL *l, char *info) {
Nodo *aux = l->head;
while (aux != NULL && aux->dados != info)
	aux = aux->proximo;
if (aux == NULL)
	return 0;
else
	return 1;
}
//-------------------------------------------------------//
int removerInicio(ListaSL *l) {
Nodo *aux;
// 1:Lista vazia
if (l->head == NULL)
	return 0;
else {
	aux = l->head;
	// valor no inicio

		// 2:Lista com um elemento
		if (l->head == l->tail) {
			l->head = NULL;
			l->tail = NULL;
			free(aux);
		} else {
		   // 3:Lista com vários elementos
		   l->head = l->head->proximo;
		   free(aux);
		}
		return 1;
	}


}
//---------------------------------------------------//

char *peekInicio(ListaSL *l) {
return l->head->dados;
}

char *peekFim(ListaSL *l) {
return l->tail->dados;
}

---------------------------------------------------------------

listasSl.h

------------------------------------------------------------

#ifndef LISTASL_H_INCLUDED
#define LISTASL_H_INCLUDED



typedef struct _Nodo {
char *dados;
struct _Nodo* proximo;
} Nodo;

typedef struct {
Nodo *head; // remover
Nodo *tail; // inserir
} ListaSL;



ListaSL* cria();
void liberta(ListaSL *l);
int estaVazia(ListaSL *l);
int insereInicio(ListaSL *l, char* info);
int insereFim(ListaSL *l, char *info);
int insereOrdenado(ListaSL *l, char* info);
int existe(ListaSL *l, char* info);
int removerInicio(ListaSL *l);
char* peekInicio(ListaSL *l);
char* peekFim(ListaSL *l);

ListaSL* transforma(char *str);
int prioridade(char op);
ListaSL* posfixa(ListaSL *l);
double calcula(ListaSL *l);



#endif // LISTASL_H_INCLUDED

*------------------------------------------------------------

pilha.h

------------------------------------------------------------------

#ifndef PILHA_H_INCLUDED
#define PILHA_H_INCLUDED


typedef struct _Nodo_p{
char *dados;
struct _Nodo_p* proximo;
} Nodo_p;

typedef struct {
Nodo_p *topo;
} Pilha;

Pilha* cria_p();
void liberta_p(Pilha *p);
int estaVazia_p(Pilha *p);
int push_p(Pilha *p,char *info);
char* pop_p(Pilha *p);
char* peek_p(Pilha *p);


#endif // PILHA_H_INCLUDED

---------------------------------------------------------------------

pilha .c

----------------------------------------------------------------------

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "ListasSL.h"
#include "Pilha.h"

Pilha *cria_p(){
Pilha* p = (Pilha*)malloc(sizeof(Pilha));
p->topo = NULL;
return p;
}

void liberta_p(Pilha *p)
{
Nodo_p* aux;
aux = p->topo;
while(aux != NULL) {
	p->topo = p->topo->proximo;
	free(aux);
	aux = p->topo;
}
free(p);
}

int estaVazia_p(Pilha *p) {
return p->topo == NULL;
}

//-- COLOCA --//
// chama estrutura Pilha apontado por *p
int push_p(Pilha *p,char *info)
{
Nodo_p *n = (Nodo_p*)malloc(sizeof(Nodo_p));
if (n == NULL)
	return 0;
  //n->dados=info;
n->dados=(char*)malloc(sizeof(char)*strlen(info)+1);
strcpy(n->dados,info);
n->proximo = p->topo;
p->topo = n;
return 1;
}
// -- REMOVE -- //
char* pop_p(Pilha *p) {
char* info;
Nodo_p* aux= p->topo; // variavel auxiliar para guardar variavel removida do topo
info = p->topo->dados; // info= posicao da pilha no topo com dados
p->topo = p->topo->proximo; // p seta topo e igual p seta topo seta proximo
free(aux); // liberta auxiliar nao e necessario alucar memoria
return info; // devolve informacao
}
// -- DEVOLVE -- //
char* peek_p(Pilha *p) {
return p->topo->dados;
}

Share this post


Link to post
Share on other sites
thoga31

Convinha explicares exactamente qual é o erro que te está a dar. Despejar aqui linhas de código à francesa não atrai muita gente para ajudar.

Atenção: eu não percebo de C/C++, pelo que não te posso ajudar, mas já te estou a dizer antecipadamente aquilo que outros de certeza te iriam dizer.


Knowledge is free!

Share this post


Link to post
Share on other sites
gimguba++c++

Peço, desculpa não estou dentro das regras.

Mas exactamente o que passa e o seguinte:

Foi criado o programa em c 'codebloks', que consta em escrever uma ou mais operações ex:1+3*5-7+6, e usando Pilhas ,é transformada numa posição fixa em posfixa,para isso existem tres funções, ,transforma ,posfixa e funçãoque retorna resultado com funcão calcula.

Depois por aplicação de win32, com a criação da plataforma "calculadora", com criação dos botões.

Verifica-se que em win32 os botões de 1 a 9, 0, + ,-,/,*, funciona , com apresentação dos valores na janela criada ?display?

Agora o problema reside quando, na plataforma faço igual'=', chamaria as funçoes transforma ,posfixa e calcula, e visualizava o total da operação no display. Assim n-ao acontece.

Da mesma forma quando faço del apagaria, o que estava no display.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.