Transformar de c para C ++ Orientado a objeto

[Matheus Rios_744170]

Alguém por favor, me auxilia a transformar esse programa pra c++ Orientado a objeto por favor, Estou tentando, mas esta dando erro

 

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

 

 

struct no

{

float valor;

struct no *prox;

};

typedef struct no No;

 

struct pilha

{

    No * topo;

};

typedef struct pilha Pilha;

 

void Empilhar(float x,Pilha * p);

float Desempilhar (Pilha * p);

void Processador(Pilha *p,float (*Operador)(),int Argumentos);

float soma(float *v);

float sub(float *v);

float mult(float *v);

float divv(float *v);

 

Pilha* Pilha_Criar (void)

{

Pilha* p = (Pilha*) malloc(sizeof(Pilha));

p->topo = NULL;

return p;

}

int Pilha_vazia(Pilha* p)

{

return (p->topo==NULL);

}

 

int main()

{

    char expressao[200];                    // Vetor que recebe a expressao e a separa por parte    

    char c;                                    // Recebedor das do Vetor

    int i;                                    // Pecorrer o For

    int tamanho;                            // Pega o tamanho da expressao

    int Argumentos;                            // Argumentos para serem operados

    int flag;                                // Verificador para as condições

Pilha *p;                                    // Declarando a pilha

p = Pilha_Criar();                        // Criando a pilha

float a;                                    // Constantes usadas para armazenar os valores vindos da string

float b;                                    // Constantes usadas para armazenar os valores vindos da string

float(*Operador)();                        // Ponteiro que aponta para as funções dos operadores

float dez;                                // usado para caso haja pontos na string    

 

scanf("%[^\n]s",expressao);                // Comando para ler a expressao digitada

tamanho=strlen(expressao);                // strlen é a função que le quantos digitos ( caracteres ) possui a expressão e esssa quantidade de digitos são armazenados no tamanho

for(i=0;i<tamanho;i++)                    // Loop para transformar as string em numeros inteiro

{

c=expressao;                            // a expressão será dividia em um vetor Exemplo : 123 , ficará separado expressão[0] = 1 ;expressão[1] = 2 ;expressão[2] = 3 ;

flag=0;                                    // usado para interromper algum loop , no caso o usado em '.'

if(c>='0'&&c<='9')                        // Aqui o c receberá a string do vetor expressão[0] que é a expressao '1' em expressão

{

a=(float)(c-'0');                        // no caso o c -'0' é o que transforma o caracter 1 em um inteiro com seu número no caso a = '1' - '0' o a = 1

Empilhar(a,p);                            // Aqui o valor será empilhado para ser guardado

i++;                                    // o i recebrá um acrescimo para passar para a posição seguinte do vetor no caso expressao[1] = '2'

c=expressao;                            // aqui o o c receberá c = '2' em caractere

    while(c!=' '&&flag==0)                    // Aqui se fará um loop para pecorrer todos os caracteres até que sejá diferente do espaço ou até mudar o flag que é a comdiçao de interrompimento

{

if(c>='0'&&c<='9')                    // Aqui se verifica se o c= '2' está nos parametros

{

a=Desempilhar(p);                    // Aqui desempilha o valor que foi empilhado no começo , no caso o numero 1

a=10*a;                            // Aqui o multiplica por 10, para começar a entrar em sua real casa decimal

b=(float)(c-'0');                // Aqui se transforma o c = '2' em um numero

a+=b;                                // Aqui se faz a soma do a +b que ficará 10 + 2 = 12

Empilhar(a,p);                        // Aqui se empilha o número 12

}

else if(c=='.')                        // Se o caractere c não foi um número se verifica se ele é um ponto

        {

        flag=1;                                // Se for ele sai do loop mudando a condição do flag

        dez=1;                                // e o dez recebe 1

        }

i++;                                // Aqui mudará para expressao[2] = '3' que voltará para o loop do while e transformará esse numero em 3 , mas antes multiplicará o 12 que esta empilhado por 10 e depois somará com o 3 ficando 123

c=expressao;                        

}

while(c>='0'&&c<='9')                    // Aqui se verifica qual numero esta depois do ponto

{

dez=dez/10;                            // aqui se divide o 1/10 que ficará 0.1

 

b=(float)(c-'0');                    // aqui se transforma o número que esta depois do pontos

b=b*dez;                            

 

a=Desempilhar(p);                    // Aqui se desempiha o número que estava antes do pontos

    a+=b;                                // Aqui soma o que está depois do ponto

Empilhar(a,p);

i++;

c=expressao;

}

}

else

{

if(c!=' ')                    // Aqui verifica se o c é diferente do espaço, pois pode ser um operador

{

switch©                        

{

case '+':                    // Aqui verifica qual é o operador

Operador=soma;        // Aqui é um ponteiro que aponta para uma função    

Argumentos=2;        // Verifica quantos argumentos são necessários para efetuar essa operação

break;

case '-':

Operador=sub;

Argumentos=2;

break;

case '*':

Operador=mult;

Argumentos=2;

break;

case '/':

Operador=divv;

Argumentos=2;

break;

}

Processador(p,Operador,Argumentos); // aqui chamará a funçao que fará as operações que é pegar os elementos empilhados e os operar, pegando a pilha, a função que utilizará e a quantidade de argumentos

}

}

}

a=Desempilhar(p);

printf("%f\n",a);

system("pause");

return 0;

}

 

void Empilhar (float x,Pilha *p)

{

No* novo = (No*) malloc(sizeof(No));         // Cria um novo nó

novo->valor = x;                            // Atribui o valor para a Nó        

novo->prox = p->topo;                        // faz o novo nó apontar para a Pilha e consequentemente para seu topo.

p -> topo = novo;                            // o topo recebe o novo Nó, Ou seja , faz uma atualização da pilha

}

 

float Desempilhar(Pilha *p)

{

    No * aux;

    float x;

    if(Pilha_vazia(p)){                            // Verifica se a pilha esta vazia

        printf("Pilha vazia\n");            

        exit(1);                        //se for vazia, Sai do programa

    }

    aux = p -> topo;                // Aqui o auxiliar recebe o nó que estava no topo

    x = aux -> valor;                // Aqui se guarda o valor do elemento que esta no topo

    p->topo = aux -> prox;            // Aqui faz com que o topo receba o que estava sem segundo e o auxiliar sejá o primeiro(topo) no caso

    free(aux);                        // Aqui se deleta o topo            

    return x;                        // Aqui se retorna o valor do que era o topo

}

 

void Processador(Pilha * p,float (*Operador)(),int Argumentos )

{

int i;            // Aqui receberá a quantidade de argumentos necessária                

float *vet;        // Aqui será o vetor que receberá os números da pilha para fazer as operações

float Respostas;            // Aqui informará o resultado após a operação

vet=(float *)malloc(Argumentos*sizeof(float));    // Reservará a memoria necessária para guardar a quantidade de elementos necessarios para efetuar as operações

for(i=Argumentos-1;i>=0;i--){                // Faz o loop começando em 2 , pois a pilha tem que ser desempilheirada do primeiro para o ultimo

vet=Desempilhar(p);                    // Desempilha o primeiro valor sendo esse o v[1] e o outro v[0] , no caso o primeiro a digitado é o segundo da pilha

    }

Respostas=(*Operador)(vet);                // Aqui se chama as operações da das funções e atriu o resultado a variavel Resposta

Empilhar(Respostas,p);                    //Aqui empilha a resposta

free(vet);                                // e da livre no vetor

}    

 

float soma(float *v)                        // Aqui são as funções que executam as operações

{

return (v[0]+v[1]);                        // Que se pega os vetores que a função processador retira da pilha e os opera retornando o seu resultado

}

 

float sub(float *v)

{

return (v[0]-v[1]);

}

 

float mult(float *v)

{

return (v[0]*v[1]);

}

 

float divv(float *v)

{

return (v[0]/v[1]);

}