besoin d'un tuto svp

j'ai besoin d'un tuto sur les structures mais expliqué le plus simplement possible.
j'ai quelques livres et j'ai fait des recherches sur internet mais j'y comprend
toujours rien.
j'utilise des tableaux actuellement et je voudrais les remplacer par une structure
---------------------------------------------
pointeur[99];
donnee[99];

int ajout_donnee(int val){
for (i=0;i<99;i++){
  if (pointeur(i)==0){
    pointeur(i)=1;
    donnee(i)=val;
    return i;
  }  
}
return 0;
}

int lire_donnee(int val){
if (poiteur(val)==0)return 0;
return donnee(val);
}

void delete_donnee(val){
pointeur(val)=0;
}
---------------------------------------------

struct structure{
  int donnee;
};

int ajout_donnee(int val){
  //struct structure{
    //donnee=val;  //ici comment fait on pour que 'donnee'=val ?
    //val=  ;//et comment faire pour que 'val' pointe sur 'donnee'
  //};
return val;
}

int lire_donnee(val){
  //struct structure{
    //val=donnee;  
  //};
return val;
}

void delete_donnee(val){
  //?????
}

---------------------------------------------

merci.

Tu es sur d'avoir aussi compris les tableaux ? Tu les utilises mal.
if (pointeur(i)==0) devrait être if (pointeur[i]==0)

De plus, énormément d'erreur sont présentes dans ton code. Par exemple, dans ta première fonction, tu mets un return dans ta boucle for mais celui-ci étant débranchant, tu ne feras qu'un seul tour.

Tu sembles avoir des lacunes sur des choses bien plus basique que les tableaux ou les structures. Néanmoins, voici une explication simplifiée de ce qu'est une structure:

Pour vulgariser, un tableau permet de ranger plusieurs données au sein d'une même variable. Chaque donnée est récupérable grâce à un numéro (de 0 à la taille - 1).
Exemple: int tab[3] = {14, 454, 90};

tab[0] contiendra 14
tab[1] contiendra 454
tab[2] contiendra 90

On ne peut pas mélanger les types de donnés. C'est à dire que pour chaque case, si on a un tableau d'entier, seul des entiers seront présents dans le tableau.

Maintenant, une structure est un type personnalisé, crée à partir de types existants. Tout comme le tableau, on peut stocker à l'intérieur plusieurs donnés au sein d'une variable. La petite différence vient du fait que l'on récupère les donnés, non pas par un numéro, mais par un nom d'étiquette. De plus, il est possible de mélanger différent type de données.

Exemple:

// Crééons un nouveau type, que l'on appelera Personne.
struct Personne
{
   int age;
   float taille;
   int poids;
};

// Ce nouveau type peux maintenant être utilisé.
int main(void)
{
  // On déclare une variable p, de type Personne
   struct Personne p;

   p.age = 18;
   p.taille = 13.9;
   p.poids= 34.4;

  // Vu que Personne est un type, rien ne nous empêche d'en déclarer plusieurs:
   struct Personne p2;

   p2.age = 13;
   p2.taille = 4.1;
   p2.poids= 83.5;

   if (p == p2)
     printf("Identique !");
}

Si on veut s'affranchir du "struct", on peut déclarer la structure comme ceci:

typedef struct
{
   int age;
   float taille;
   int poids;
} Personne;

se n'était pas un code fonctionnelle mais explicative
le code ci-dessous est fonctionnel mais je voudrais remplacer
le tableau par une structure

#include <cstdlib>
#include <iostream>

using namespace std;

int donnee[99];

void ajout_personne(int nom,int age){
     donnee[nom]=age;
}
int info_personne(int nom){
    return donnee[nom];
}
void supprime_personne(int nom){
     donnee[nom]=0;
}

int main(int argc, char *argv[]){
    ajout_personne(1,10);
    ajout_personne(2,20);
    ajout_personne(6,35);
    cout << info_personne(2)<< '\n';
    cout << info_personne(6)<< '\n';
    cout << info_personne(2)<< '\n';
    cout << info_personne(1)<< '\n';
    system("PAUSE");
    return EXIT_SUCCESS;
}

Si tu es en C++, et non en C, alors j'ai quelques remarques.

cstdlib, n'est pas nécessaire. Utilise new et delete, et non malloc et free.
Evite les using namespace std;
N'utilise pas de variable globale.
Pour tes tableaux, tu peux te servir de la STL, qui est une bibliothèque inclue dans C++, et qui fournit des conteneurs (dont des tableaux, des listes, etc...).
Enfin, pour le nom, utilise une chaîne de caractère, plutôt qu'un entier.


#include <vector>
#include <iostream>

// Struct et Class, c'est pareil a part
// le niveau de visibilite par defaut qui differe
struct Personne
{
  std::string    nom;
  int        age;
};

// On fait un alias du type, pour en ecrire moins
typedef std::vector<Personne>::iterator iterator;

void ajout_personne(std::vector<Personne>& tab,
            const std::string& nom, int age)
{
  Personne p;
  p.nom = nom;
  p.age = age;
  tab.push_back(p);
}

iterator recherche(std::vector<Personne>& tab,
           const std::string& nom)
{
  for (iterator it = tab.begin(); it != tab.end(); ++it)
    if (it->nom == nom)
      return it;

  return tab.end();
}

int info_personne(std::vector<Personne>& tab, const std::string& nom)
{
  iterator it = recherche(tab, nom);

  if (it != tab.end())
    return it->age;

  return -1;
}

void supprime_personne(std::vector<Personne>& tab, const std::string& nom)
{
  iterator it = recherche(tab, nom);
  if (it != tab.end())
    tab.erase(it);
}

int main()
{
  std::vector<Personne> donnee;

  ajout_personne(donnee, "Pierre", 10);
  ajout_personne(donnee, "Paul", 20);
  ajout_personne(donnee, "Jacque", 35);
  std::cout << info_personne(donnee, "Paul") << std::endl;
  std::cout << info_personne(donnee, "Jacque") << std::endl;
  std::cout << info_personne(donnee, "Paul") << std::endl;
  std::cout << info_personne(donnee, "Pierre") << std::endl;
  supprime_personne(donnee, "Pierre");
  supprime_personne(donnee, "xx");
  std::cout << std::endl;
  std::cout << info_personne(donnee, "Paul") << std::endl;
  std::cout << info_personne(donnee, "Jacque") << std::endl;
  std::cout << info_personne(donnee, "Paul") << std::endl;
  std::cout << info_personne(donnee, "Pierre") << std::endl;
  //system("PAUSE");
  return 0;
}

Si tu as besoin d'un tutoriel qui récapitule toutes ces notions (structures, tableaux, etc.), je te recommande de visiter le Site du Zér0. Les tutoriels ici et là t'expliqueront (ou te ré-expliqueront) tout cela de la base, respectivement le C, puis le C++. Ça vaut le détour !

Le site du zéro est un très bon site. Le seul défaut, est qu'ils "mentent" temporairement (dixit l'auteur du site) sur certaines choses afin de ne pas assommer le lecteur de trop d'information. C'est une très bonne chose, mais le lecteur qui ne va pas jusqu'au bout prendra malheureusement de mauvaise habitude. Le meilleur exemple est sans doute la mauvaise utilisation des : using namespace std;, qui pullulent d'ailleurs sur le net.

Donc il est important de lire l'ensemble des tutoriaux dans leur intégralité, afin de suivre une certaine cohérence, et d'éviter, dans ce cas, d'en piocher à droite et à gauche.

>  Le site du zéro est un très bon site.

C'est une blague sans doute ?
Mélanger C, C++, QT, SDL, etc, il faut le faire !
Pour les moins de 12 ans, et encore.
J'ai reçu des candidats qui m'ont sorti qu'ils "maitrisaient" le C .
En insistant , ils m'ont dit qu'il l'avaient appris sur le sdz et d'autres "tutoriaux", écrits par des ados.
Je leur ai soumis un test : le meilleur a eu... 2 /20 !!!!

Pour apprendre le C, la seule référence valable est de lire le K&R.

>> Le site du zéro est un très bon site.
> C'est une blague sans doute ?

Non, mais ton post doit en être un !

Le tutoriaux ne sont pas écrit pas des gamins de 12 ans, mais par un ingénieur de l'EFFREI (je ne cherche pas à faire de la pub, je vient d'une école concurrente). Ses travaux seront d'ailleurs prochainement édités.
De plus, les tutoriaux sont relus par la communauté et sont très bien fait. Ce n'est pas parce que tu es tombé sur des gens mauvais, qui ont été une fois dans leur vie sur le sdz, que le sdz est un mauvais site. C'est un excellent tremplin pour qui veut débuter dans ces technologies. Reste ensuite à ceux-ci, de faire la démarche d'aller plus loin. (Modern C++, lire du andrei alexandrescu, etc...). Tes candidats n'ont visiblement pas fait cette démarche, ta déduction est bien trop hâtive et injustifiée, ce qui n'est pas respectueux pour le travail effectué par l'auteur du sdz.

> Pour apprendre le C, la seule référence valable est de lire le K&R.
Paie ton extrêmisme ! Je n'ai pas lu le K&R, ce qui ne m'empêche pas d'avoir un "bon" niveau (cf mes sources).

Bonjour,
Je  ne suis jamais allé sur le SdZ, alors je ne donnerai pas mon opinion à ce sujet.
Quant au K&R, je l'ai lu alors que je croyais avoir un « bon » niveau en C, et j'y ai appris plein de choses ; je vous le conseille vivement !

Pour en revenir au sujet, je trouve ta façon de faire, mana, assez élégante. Et rassure-toi, il n'y a pas tant d'erreurs que cela dans ton code. La seule remarque que je pourrais faire (mis à part les crochets pour les index des tableaux), c'est que l'on ne peut pas savoir, lorsque la fonction ajout_donnee renvoie 0, si la valeur a été insérée à l'emplacement zéro ou s'il n'y a plus de place. Peut-être pourrais-tu renvoyer -1 en cas d'erreur... (Pour CptPingu: le nombre d'itérations dans la boucle for est judicieusement calculé...)

Si je comprends ce que tu veux faire, tu as des valeurs qui identifient des données, et tu souhaites ranger ces données dans un grand sac et les retrouver en utilisant leur identité. Au lieu d'identité, on parle plutôt de clef.

Si j'ai bien compris, ce qu'il te faut est un cours sur les structures de données (pas sur les struct du C). Selon ce que tu vas faire de ces données, certaines structures vont être plus adaptées que d'autres.

Il y a évidemment la solution triviale de la liste, mais un arbre binaire équilibré peut être bien plus efficace !

Après, tu peux vouloir programmer toi-même la structure de donnée. Dans ce cas chercher « arbre » sur ce site (ou ailleurs) devrait te fournir d'intéressants exemples.
Sinon tu peux utiliser des bibliothèques déjà existantes, comme la STL, et aller voir cet exemple de Map ou encore la référence.

Bonne prog,
--
Chouchou.

Re, pour donner un lien.
Un site plein d'algorithmes ; la rubrique « Binary Search Tree » a une mise en œuvre simple, en C, des arbres binaires de recherche ; la rubrique « AVL Tree » montre du C++ plus compliqué (pour les arbres AVL).

Bonne prog,
--
Chouchou.