Exercices pour débutants en C

#include <stdio.h>
#include <stdlib.h> /* for atof() - in K&R, math.h is referenced - this is an anachronism */

#define MAXOP 100 /* max size of operand or operator */
#define NUMBER '0' /* signal that a number was found */

int getop(char []);
void push(double);
double pop(void);

/* reverse Polish calculator */

int main(void)
{
  int type;
  double op2;
  char s[MAXOP];

  while((type = getop(s)) != EOF)
  {
    switch(type)
    {
      case NUMBER:
        push(atof(s));
        break;
      case '+':
        push(pop() + pop());
        break;
      case '*':
        push(pop() * pop());
        break;
      case '-':
        op2 = pop();
        push(pop() - op2);
        break;
      case '/':
        op2 = pop();
        if(op2 != 0.0)
          push(pop() / op2);
        else
          printf("error: zero divisor\n");
        break;
      case '\n':
        printf("\t%.8g\n", pop());
        break;
      default:
        printf("error: unknown command %s\n", s);
        break;
    }
  }

  return 0;
}

#define MAXVAL  100 /* maximum depth of val stack */

int sp = 0; /* next free stack position */
double val[MAXVAL]; /* value stack */

/* push: push f onto value stack */
void push(double f)
{
  if(sp < MAXVAL)
    val[sp++] = f;
  else
    printf("error: stack full, can't push %g\n", f);
}

/* pop: pop and return top value from stack */
double pop(void)
{
  if(sp > 0)
    return val[--sp];
  else
  {
    printf("error: stack empty\n");
    return 0.0;
  }
}

#include <ctype.h>

int getch(void);
void ungetch(int);

/* getop: get next operator or numeric operand */
int getop(char s[])
{
  int i, c;

  while((s[0] = c = getch()) == ' ' || c == '\t')
    ;

  s[1] = '\0';
  if(!isdigit(c) && c != '.')
    return c; /* not a number */
  i = 0;
  if(isdigit(c)) /* collect integer part */
    while(isdigit(s[++i] = c = getch()))
      ;
  if(c == '.')
    while(isdigit(s[++i] = c = getch()))
      ;
  s[i] = '\0';
  if(c != EOF)
    ungetch(c);
  return NUMBER;
}

#define BUFSIZE 100

char buf[BUFSIZE]; /* buffer for ungetch */
int bufp = 0; /* next free position in buf */

int getch(void) /* get a (possibly pushed back) character */
{
  return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c) /* push character back on input */
{
  if(bufp >= BUFSIZE)
    printf("ungetch: too many characters\n");
  else
    buf[bufp++] = c;
}

#include <stdio.h>
#include <stdlib.h>

/** implémentation de pile provenant du tuto de Octal
http://www.siteduzero.com/tutoriel-3-34229-les-piles-et-les-files.html */

typedef struct pile
{
    int value;
    struct pile *precedent;
} Pile;

void pile_push (Pile **p_pile, int value)
{
    Pile *p_nouveau = malloc(sizeof *p_nouveau);
    if (p_nouveau != NULL)
    {
        p_nouveau->value = value;
        p_nouveau->precedent = *p_pile;
        *p_pile = p_nouveau;
    }
}

int pile_pop (Pile **p_pile)
{
    int ret = 0;
    if (*p_pile != NULL)
    {
        Pile *temporaire = (*p_pile)->precedent;
        ret = (*p_pile)->value;
        free(*p_pile), *p_pile = NULL;
        *p_pile = temporaire;
    }
    return ret;
}

void pile_clear(Pile **p_pile)
{
    while (*p_pile != NULL)
    {
        pile_pop(p_pile);
    }
}
/*********************************************************/

int isOperator (char c)
{
    return (c == '+' || c == '-' || c == '*' || c == '/');
}

int main(void)
{
    Pile *pile = NULL;
    char str[] = "-4 5 * -10 +";
    char *expr = str, *ptr;
    int a, b, val;
    /* compteur pour l'etat de la pile */
    int n = 0, divisionParZero = 0;

    do
    {
        val = strtol (expr, &ptr, 10);
        /* si strtol a lu un nombre */
        if ( expr < ptr )
        {
            expr = ptr;
            pile_push (&pile, val);
            n++;
        }
        /* sinon si on lit un operateur */
        else if ( isOperator (*expr) )
        {
            a = pile_pop(&pile);
            b = pile_pop(&pile);
            switch (*expr)
            {
            case '+':
                pile_push (&pile, b + a);
                break;
            case '-':
                pile_push (&pile, b - a);
                break;
            case '*':
                pile_push (&pile, b * a);
                break;
            case '/':
                if (a != 0)
                    pile_push (&pile, b / a);
                else
                    divisionParZero = 1;
                break;
            }
            n--;
        }
    }
    while (*++expr && !divisionParZero);

    /* Si la pile contient un seul element */
    if (n == 1 && !divisionParZero)
    {
        printf ("'%s' vaut : %d\n", str, pile_pop(&pile));
    }
    else
    {
        if (divisionParZero)
        {
            puts("Erreur : division par zero !");
        }
        else
        {
            puts("Erreur : l'expression est erronnee !");
        }
        /* On vide la pile */
        pile_clear(&pile);
    }
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
  char *p = "1 2 + 3 4 * 1 5 3 2 - * - 2 * + 1 * - 3 -",*q=p;
  int pile[100] = { 0 };
  int hauteur = 0;

  while (*p)
    {
      switch (*p)
        {
        case ' ':
          break;
        case '+':
          pile[hauteur - 2] += pile[hauteur - 1];
          hauteur--;
          break;
        case '-':
          pile[hauteur - 2] -= pile[hauteur - 1];
          hauteur--;
          break;
        case '*':
          pile[hauteur - 2] *= pile[hauteur - 1];
          hauteur--;
          break;
        case '/':
          if (pile[hauteur] == 0)
            return 0;
          else
            {
              pile[hauteur - 2] /= pile[hauteur - 1];
              hauteur--;
            }
          break;
        default:
          pile[hauteur] = *p - '0';
          hauteur++;
        }
      p++;
    }

  printf("%s vaut %d\n", q, pile[0]);
  return 0;
}

int zMath(const char* calcul, size_t taille)
{
    int i, temp1, temp2, final;
    Pile* ma_pile = NULL;
    i = temp1 = temp2 = final = 0;

    for(; i < taille; i++)
    {
        if(calcul[i] >= '0' && calcul[i] <= '9') // si c'est un chiffre...
            pile_push(&ma_pile,calcul[i]-'0');
        // '-0' permet de "convertir" l'information numérique d'un caractère en "vrai" chiffre
        else if(calcul[i] == '*')
        { // multiplication
            temp1 = pile_pop(&ma_pile);
            temp2 = pile_pop(&ma_pile);
            pile_push(&ma_pile, temp2*temp1);
        }
        else if(calcul[i] == '/')
        { // division
            temp1 = pile_pop(&ma_pile);
            temp2 = pile_pop(&ma_pile);
            pile_push(&ma_pile, temp2/temp1);
        }
        else if(calcul[i] == '+')
        { // addition
            temp1 = pile_pop(&ma_pile);
            temp2 = pile_pop(&ma_pile);
            pile_push(&ma_pile, temp2+temp1);
        }
        else if(calcul[i] == '-')
        { // soustraction
            temp1 = pile_pop(&ma_pile);
            temp2 = pile_pop(&ma_pile);
            pile_push(&ma_pile, temp2-temp1);
        }
        else // caractère invalide
            printf(" Erreur : %c n'est pas considéré comme un caractere valide ! \n", calcul[i]);
    }
    final = pile_pop(&ma_pile);
    pile_clear(&ma_pile); // au cas où ...
    return final;
}