Programacao AvanÇada Em C - Duvida & Desafio

[Guest --JOAO --]

PESSOAL ESTOU TENTANDO RESOLVER UM EXERCICIO EM C MAIS NÃO ESTOU CONSEGUINDO, REALMENTE NÃO ESTÁ FACIL, SERA QUE alguém PODERIA AJUDAR? TAMBEM FICA COMO DESAFIO PARA QUEM CONSEGUIR FAZE-LO:

ENUNCIADO:

desenvolver na linguagem C tres versoes de um programa que execute

operacoes matematicas elementares

as operacoes matematicas são: +,−, , /

um processo, dito cliente, le do teclado uma operacao matematica

envia a operacao a ser relizada, no seguinte formato: “operando

operador operando” (2 + 2)

o outro processo, dito receptor, recebe a descricao da operacao,

executa e envia resposta (4)

o cliente recebe resposta e exibe o resultado na tela

fazer uma versao que usa pipes, outra pipes nomeados e uma terceira memoria

compartilhada

ESTAVA FAZENDO O PRIMEIRO QUE USA SOMENTE PIPE SEGUE O CODIGO ABAIXO, MAIS NÃO ESTOU CONSEGUINDO SUCESSO...

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <string.h>

int n, fd[2];

/* recebe os numeros e a operação, calcula e devolve o resultado*/

void calcula(int n1, int n2, char op, int fd){

char saida[15];

int result;

switch(op){

case '+':

result=n1+n2;

break;

case '-':

result=n1-n2;

break;

case '/':

result=n1/n2;

break;

case '*':

result=n1*n2;

break;

}

/* imprimimos o resultado no fd */

sprintf(saida,"%d",result);

/* agora mandamos os bytes */

if (write(fd, saida, strlen(saida)) != strlen(saida) ) {

fprintf(stderr, "Erro na escrita no pipe (saida=%s)\n",saida);

}

}

int main(int argc, char *argv[]){

int fd[2];

pid_t pid;

int n1,n2,result;

n1=atoi(argv[1]);

n2=atoi(argv[3]);

/* cria pipe */

if (pipe(fd) < 0) {

perror("Problema na criacao do pipe");

exit(1);

}

if ( (pid = fork() ) < 0) {

perror("Problema no fork");

exit(1);

}else if ( pid > 0 ) {

/* pai */

close (fd[0]); /* fecha o lado da leitura */

calcula(n1,n2,*argv[2],fd[1]); /* gera o resultado(saida) escrevendo-a no pipe */

/* terminada a saida, fechamos este lado de writing do pipe */

close(fd[1]);

/* esperamos pela terminacao do filho */

if (waitpid (pid, NULL, 0) < 0) {

fprintf(stderr, "Erro no waitpid");

exit(1);

}

/* pai sai normalmente */

exit(0);

}

else {

/* filho */

close(fd[1]); /* fecha o lado de escrita */

/* queremos chamar dup2 para associar lado de leitura

** do pipe com stdin, mas temos que tomar cuidado para

** o lado do pipe já' ser o proprio stdin. Lembremos

** da definicao de dup2(filedes, filedes2) :

** dup2 causa o file descriptor filedes2 se referir

** a mesma coisa que files. Se filedes2 se refere a

** um file descriptor já' aberto e diferente de filedes,

** então ele e' primeiro fechado.

** Portanto, queremos fechar que stdin seja fechado no

** caso de fd[0] já' ser o stdin. Voce acha que seria

** possivel, ou seja, que fd[0] poderia ser o stdin quando

** criado pelo pipe() ? Bem, e' possivel se o shell não

** criou o fd 0 como sendo o stdin, pois ai' pipe acharia

** que este valor (menor file descriptor não usado) estaria

** livre. Mas deveria ser improvavel ...

*/

if (fd[0] != STDIN_FILENO) {

/* diferentes, então podemos chamar sem perigo */

if (dup2(fd[0], STDIN_FILENO) != STDIN_FILENO) {

fprintf(stderr, "dup2 error para stdin");

exit(1);

}

close(fd[0]); /* não e' necessario mais */

}

}

[Guest --JOAO --]

Esse é com memoria compartilhada, esse sim não sei se está certo, não entendi muito bem, mais vamos ao codigo:

#include <stdio.h>
#include <sys/shm.h>
#include <sys/stat.h>


int calcula(char str[20]){

int resultado=0,n1=0,n2=0,cont=0;
char delims[] = " ";
char *result = NULL;
char op;
     result = strtok ( str, delims );
     n1=atoi(result);
     while( result != NULL ) {
       if (cont==1){
          op=*result;
       }else if(cont==2){
          n2=atoi(result);
       }
       cont++;
       result = strtok( NULL, delims );
    }
    printf("%d",n1);
    printf("%c",op);
    printf("%d",n2);

    switch(op){
       case '+':
           resultado=n1+n2;
           break;
       case '-':
           resultado=n1-n2;
           break;
       case '/':
           resultado=n1/n2;
           break;
       case '*':
           resultado=n1*n2;
           break;
    }
   return resultado;
 }



int main ()
{
  int segment_id;
  char* shared_memory;
  struct shmid_ds shmbuffer;
  int segment_size;
  const int shared_segment_size = 0x6400;
  char aux[20];
  char Buff[20]; 

  /* Allocate a shared memory segment.  */
  segment_id = shmget (IPC_PRIVATE, shared_segment_size,IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR);

  /* Attach the shared memory segment.  */
  shared_memory = (char*) shmat (segment_id, 0, 0);
  printf ("shared memory attached at address %p\n", shared_memory);

  /* Determine the segment's size.  */
  shmctl (segment_id, IPC_STAT, &shmbuffer);
  segment_size = shmbuffer.shm_segsz;
  printf ("segment size: %d\n", segment_size);

  /* Write a string to the shared memory segment.  */
    printf("digite a operacao");
   fgets(aux,20,stdin);
   strcpy(Buff,aux);

  sprintf (shared_memory,Buff);

  /* Deatch the shared memory segment.  */
  shmdt (shared_memory);

  /* Reattach the shared memory segment, at a different address.  */
  shared_memory = (char*) shmat (segment_id, (void*) 0x5000000, 0);
  printf ("shared memory reattached at address %p\n", shared_memory);
  /* Print out the string from shared memory.  */

  //printf ("%s\n", shared_memory);
  result=calcula(shared_memory); /*recebe a operacao ex: 2 + 4*/  ,
  printf("Resultado: %d",result);


  /* Detach the shared memory segment.  */
  shmdt (shared_memory);

  /* Deallocate the shared memory segment.  */
  shmctl (segment_id, IPC_RMID, 0);

  return 0;
}
[/codebox]