[C/C++]Tableu et structure

double tab[] = {8.3, 6.5,  7.2, 6.5, 3.4, 2.5, 3.5, 4.9, 7.3, 6.2, 1.5, 0.3, 5.8, 7.6, 3.9, 8.2 };

int nb_intervalle02(double *tableau, int longueur)
{
    //On part de zero nombre dans cet intervalle
    int nb_inter=0;
    int i;
    //On parcoure chaque champs
    for (i=0; i< longueur; i++)
    {
       //Le champs examiné est t'il dans le bon interval?
        if (tableau[i] >0 && tableau[i] <= 2){
            //Si c'est vrai, on incrémente notre compteur de nombre dans l'interval
            nb_inter++;
        }
    }
    return nb_inter;
}

//On teste la fonction:
int main()
{
    printf("%d\n", nb_intervalle02(tab, sizeof(tab)));
    return 0;
}

..et le...le...enfin, non parce c'est...ya...quand...bah tu sais là le...

#include <cassert>

class intervalle_t{
  protected:
  double min; // la borne min
  double max; // la borne max
  bool min_exclu; // la borne min est elle exclue ?
  bool max_exclu; // la borne max est elle exclue ?

  public:

  // Le constructeur
  intervalle_t(const double & min0=0,const double & max0=0,bool min_exclu0=false,bool max_exclu0=false):
    min(min0),max(max0),
    min_exclu(min_exclu0),max_exclu(max_exclu0)
  {
    assert(min<=max);
  }

  // Obtenir la borne inférieure
  inline const double & get_min() const{
    return min;
  }

  // Obtenir la borne supérieure
  inline const double & get_max() const{
    return max;
  }

  // Est ce que x est dans l'intervalle
  inline bool contient(const double & x) const{
    return (x > min || x >= min && !min_exclu) &&
      (x < max || x <= max && !max_exclu);
  }
};

inline bool operator<(const intervalle_t & i,const intervalle_t & j){
  return (i.get_min() < j.get_min()) || 
    (i.get_min() == j.get_min() && i.get_max() < j.get_max());
}

template <typename Tstream>
Tstream & operator << (Tstream &,const intervalle_t i){
  if (min_exclu) out << ']';
  else out << '[';
  out << min << ',' << max;
  if (max_exclu) out << '[';
  else out << ']';
  return out;
}

#include "intervalle.hpp"
#include <set>
#include <map>

class histogramme_t{
  protected:
  std::map<intervalle_t,unsigned int> datas;
  public:
  // Le constructeur par défaut
  histogramme_t(){}

  //Un autre constructeur. A partir d'un ensemble d'intervalle je 
  // construit une map qui associe pour chaque intervalle le nb de pt
  histogramme_t(const std::set<intervalle_t> & intervalles0){
    const std::set<intervalle_t>::const_iterator
      intervalle_it (intervalles0.begin()),
      intervalle_end(intervalles0.end());
    for(;intervalle_it!=intervalle_end;++intervalle_it){
      const intervalle_t & intervalle = *intervalle_it;
      datas[intervalle] = 0;
    }
  }

  // Encore un constructeur (ici j'ai déjà ma map de point d'initialisée)
  histogramme_t(const std::map<intervalle_t,unsigned int> & datas0):
    datas(datas0)
  {}

  // Ajouter un point
  void ajouter_point(const double & x){
    std::map<intervalle_t,unsigned int>::iterator
      data_it (datas.begin()),
      data_end(datas.end());
    for(;data_it!=data_end;++data_it){
      const intervalle_t & intervalle = data_it->first;
      if(intervalle.contient(x)) ++(data_it->second);
    }
  }

  // Ecrire l'histogramme
  template <typename Tstream>
  Tstream & operator << (Tstream & out) const{
    std::map<intervalle_t,unsigned int>::iterator
      data_it (datas.begin()),
      data_end(datas.end());
    for(;data_it!=data_end;++data_it){
      const intervalle_t & intervalle = data_it->first;
      out << intervalle << " : ";
      const unsigned int nb_etoile = data_it->second;
      for(unsigned int i=0;i<nb_etoile;++i) out << '*';
      out << std::endl;
    }
    return out;
  }
};

#include "intervalle.hpp"
#include "histogramme.hpp"
#include <iostream>

int main(){
  // Construction des intervalles
  std::set<intervalle_t> intervalles;
  {
    intervalles.insert(intervalle_t(0,2,false,true));
    intervalles.insert(intervalle_t(2,4,false,true));
    intervalles.insert(intervalle_t(4,6,false,true));
    intervalles.insert(intervalle_t(6,8,false,true));
    intervalles.insert(intervalle_t(8,10,false,true));
  }

  histogramme_t h(intervalles); // 2e constructeur

  // Ajout des points
  {
    h.ajouter_point(1.1);
    h.ajouter_point(6.9);
    h.ajouter_point(2.8);
  }

  // Ecriture de l'histogramme
  std::cout << h << std::endl;
  return 0;
}

struct intervalle{
    double inf, sup; // les bornes
    int val; // la valeur
};

intervalle intervalles[5];

void initialiser()
{
    int i;
    for(i = 0; i < 5; i++)
    {
        intervalles[i].inf = i * 2;
        intervalles[i].sup = i * 2 + 1;
        intervalles[i].val = 0;
    }
}

void saisir(double val)
{
    int i;
    for(i = 0; i < 5; i++)
    {
        if(val > intervalles[i].inf && val <= intervalles[i].sup)
        {
            intervalles[i].val++;
            return;
        }
    }
    // si on arrive ici, la valeur ne se range dans aucun intervalle
    printf("Veuillez entrer un réel dans ]0.0;10.0]\n");
}

void afficher()
{
    int i, j;
    for(i = 0; i < 5; i++)
    {
        printf("]%f,%f] : ", intervalles[i].inf, intervalles[i].sup);
        for(j = 0; j < intervalles[i].val; j++)
            printf("*");
        printf("\n");
    }
}

int minimum()
{
    int i, imin, min = -1;
    for(i = 0; i < 5; i++)
    {
        if(-1 == min || intervalles[i].val < min)
        {
            imin = i;
            min = intervalles[i].val;
        }
    }
    return imin;
}

/**
 * @file plop.c
 * @author plop!
 * @date 03/02/07 05:30
 * @brief Truc de N00b
 */

#include <stdio.h>
#include <windows.h>

struct intervalle{
    double inf, sup; // les bornes
    int val; // la valeur
};

struct intervalle intervalles[5];

void initialiser()
{
    int i;
    for(i = 0; i < 5; i++)
    {
        intervalles[i].inf = i * 2;
        intervalles[i].sup = ( i + 1 )* 2;
        intervalles[i].val = 0;
    }
}

void saisir(double val)
{
    int i;
    for(i = 0; i < 5; i++)
    {
        if(val > intervalles[i].inf && val <= intervalles[i].sup)
        {
            intervalles[i].val++;
            return;
        }
    }
    // si on arrive ici, la valeur ne se range dans aucun intervalle
    printf("Veuillez entrer un réel dans ]0.0;10.0]\n");
}

void afficher()
{
    int i, j;
    for(i = 0; i < 5; i++)
    {
        printf("]%f,%f] : ", intervalles[i].inf, intervalles[i].sup);
        for(j = 0; j < intervalles[i].val; j++)
            printf("*");
        printf("\n");
    }
}

int minimum()
{
    int i, imin, min = -1;
    for(i = 0; i < 5; i++)
    {
        if(-1 == min || intervalles[i].val < min)
        {
            imin = i;
            min = intervalles[i].val;
        }
    }
    return imin;
}

int main()
{
	float in;
	
	initialiser();
	printf("Entrez des réels dans ]0;10] en terminant par 0\n");

	while(1)
	{
		scanf("%f", &in);
		if(in == 0) break;
		saisir(in);
	}
	
	afficher();
	
	//afficher ici les intervalles minimums et maximums
	
	system("pause>nul");
	return 0;
}

typedef struct{
  double salaires[TAILLE];
  char noms[TAILLE][30]; // les noms sont de longueurs < 30
} salaries_t;

#define TAILLE 30
...
double moyenne(double *tab,unsigned int taille){
  unsigned int i;
  double moyenne=0;
  for(i=0;i<taille;++i) moyenne += tab[i];
  moyenne /= taille;
  return moyenne;
}

int main(){
  salaries_t salaries;
  ... // remplissage de la structure
  printf("Moyenne : %d\n",moyenne((double *) (salaries.salaires),TAILLE));
  return 0;
}

moyenne /= taille;

moyenne = moyenne / taille;

printf("Moyenne : %d\n",moyenne((double *) (salaries.salaires),TAILLE));

double moy = moyenne((double *) (salaries.salaires), TAILLE);
printf("Moyenne : %d\n", moy);