Programmer une fonction en C

#include <stdio.h> // permet d'appeler printf 

// Cette fonction reçoit un paramètre entier 
// (noté x dans le code de la fonction valeur_absolue 
// et retourne un entier x 
int valeur_absolue(int x){ 
  if (x < 0){ 
    return -x; 
  }else{ 
    return x; 
  } 
} 

// La fonction main est celle dans laquelle démarre 
// le programme 
int main(){ 
  // Début du programme 
  int y = -7; 
  printf("Coucou je vais calculer la valeur absolue de y = %d\n", y); 
  int val_abs_y = valeur_absolue(y); 
  printf("|y| = %d\n", val_abs_y); 
  printf("Et maintenant je quitte !\n"); 

  // Ceci met le programme en pause ce qui est utile sous windows 
  // quand on lance le programme depuis l'explorateur 
  // (sinon il quitte directement la console !) 
  getchar(); 

  // Le programme s'est terminé correctement 
  // Par convention on retourne 0 si tout va bien 
  return 0; 
}

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

int main(){
    FILE *fp = fopen("toto.txt","r");
    size_t n = 255;
    char *buffer  = malloc(n * sizeof(char));
    char *triplet = malloc(n * sizeof(char));
    char *pos;
    char lettre;
    char operande;
    int  valeur;
    unsigned no_ligne;

    for(no_ligne = 0; getline(&buffer, &n, fp) != -1; ++no_ligne){
        printf("Ligne %d: %s", no_ligne, buffer);
        pos = buffer;
        while(sscanf(pos, "%s ", triplet) == 1){
            if(sscanf(triplet,  "%c%c%d", &lettre, &operande, &valeur) == 3){
                printf("(%c, %c, %d)\n", lettre, operande, valeur);
            }
            pos += strlen(triplet) + 1;
        }   
    }

    free(buffer);
    free(triplet);
    return 0;
}

p+0 e+1 e+2 e+3 p*1 p*2
p*1 p+4 p*5

Ligne 0: p+0 e+1 e+2 e+3 p*1 p*2
(p, +, 0)
(e, +, 1)
(e, +, 2)
(e, +, 3)
(p, *, 1)
(p, *, 2)
Ligne 1: p*1 p+4 p*5 
(p, *, 1)
(p, +, 4)
(p, *, 5)

#define _GNU_SOURCE
#include <stdio.h>

...

#ifndef BINARY_TREE_H
#define BINARY_TREE_H

typedef struct _binary_tree_node_t{
  struct _binary_tree_node_t *l; /// Fils gauche
  struct _binary_tree_node_t *r; /// Fils droit
  void *data; /// Adresse de la donnée stockée dans le noeud
} binary_tree_node_t;

typedef struct _binary_tree_t{
  binary_tree_node_t * root; /// Racine de l'arbre
} binary_tree_t;

// Noeuds
void free_binary_tree_node(binary_tree_node_t *node);
binary_tree_node_t * alloc_binary_tree_node();

// Arbre
binary_tree_t * alloc_binary_tree();
void free_binary_tree(binary_tree_t *tree);

// Alloue un noeud fils
binary_tree_node_t * add_child_node(
  binary_tree_node_t *node,
  char where /// 'r' ou 'l'
);

// Alloue un noeud parent de l et r
binary_tree_node_t * add_parent_node(
  binary_tree_node_t *l,
  binary_tree_node_t *r
);

#endif

#include "binary_tree.h"
#include <stdlib.h>

binary_tree_node_t * alloc_binary_tree_node(){
  return calloc(1, sizeof(binary_tree_node_t));
}

binary_tree_t * alloc_binary_tree(){
  return calloc(1, sizeof(binary_tree_t));
}

void free_binary_tree_node(binary_tree_node_t *node){
  if(node->r) free_binary_tree_node(node->r);
  if(node->l) free_binary_tree_node(node->l);
  free(node);
}

void free_binary_tree(binary_tree_t *tree){
  if(tree){
    if(tree->root){
      free_binary_tree_node(tree->root);
      free(tree->root);
    }
    free(tree);
  }
}

binary_tree_node_t * add_child_node(
  binary_tree_node_t *node, /// Le noeud sur lequel on greffe child
  char where /// 'l' ou 'r'
){
  binary_tree_node_t *child = NULL;
  if(node){
    binary_tree_node_t *p = NULL;
    switch(where){
      case 'l': p = node->l; break;
      case 'r': p = node->r; break;
    }
    if(p){
      child = alloc_binary_tree_node();
      p = child;
    }
  }
  return child;
}

binary_tree_node_t * add_parent_node(
  binary_tree_node_t *l,
  binary_tree_node_t *r
){
  binary_tree_node_t *parent = alloc_binary_tree_node();
  if(parent){
    parent->l = l;
    parent->r = r;
  }
  return parent;
}