Comment utiliser plusieurs sources et les fichiers d'en-tête

J'ai récemment appris comment peut-on utiliser plusieurs fichiers source avec les fichiers d'en-tête afin de rendre le code portable et hiérarchique. Pour ce faire, j'ai essayé de créer mon programme d'arbre à l'aide de ce principe. Voici mes fichiers

b_tree_ds.h - il contient un déclaration de discbased de nœud d'un arbre, qui peut être appelé de différentes fonctions de la mise en œuvre de la fonctionnalité de l'arbre (qui peut être dans différents fichiers source)

typedef struct node {
    struct node* left;
    struct node* right;
    int key;    //contains value
}NODE;

Lorsque j'essaie d'ajouter un extern comme dans typedef extern struct node il donne une erreur de plusieurs de stockage de classe, mais si je le rate, je reçois l'erreur pour de multiples définitions.

Voici mes autres fichiers source

traverse.h - contient la déclaration de la traversée de la fonction

void traverse_print (NODE* p);

Ici aussi, j'obtiens l'erreur inconnue identificateur de NŒUD

traverse.c - contient la définition de la fonction d'

#include <stdio.h>
#include "b_tree_ds.h"
#include "traverse.h"

void traverse_print(NODE* p)
{
    if(p->left != NULL)
    {
        traverse_print(p->left);
    }

    if (p->right != NULL)
    {
        traverse_print(p->right);
    }

    printf ("\n%d",p->key);
}

Enfin principales.c 

#include <stdio.h>
#include "traverse.h"

void main()
{
    //input
    NODE p;

    printf("\nInput the tree");
    input_tree (&p);

    printf("\n\nThe tree is traversing ...\n")
    traverse_print(&p);
}

void input_tree (NODE *p)
{
    int in;
    int c;
    NODE *temp;

    printf("\n Enter the key value for p: ");
    scanf("%d", &in);
    p->key  =in;
    printf ("\n\nIn relation to node with value %d",in);
    printf ("Does it have left child (Y/N): ")
    if ((c = getchar()) == Y);
    {
        //assign new memory to it.
        temp = (NODE *)malloc(sizeof(NODE));
        input_tree(temp);
    }
    printf ("\n\nIn relation to node with value %d",p->key);

    printf ("\nDoes it have right child (Y/N): ")
    if ((c = getchar()) == Y);
    {
        //assign new memory to it.
        temp = (NODE *)malloc(sizeof(NODE));
        input_tree(temp);
    }
}

C'est ma première tentative d'une telle pratique, s'il vous plaît suggérer est la structure de mon programme est bon ou dois-je essayer autre chose.

S'il vous plaît créer un minimum de cas de test, plutôt que de l'affichage de l'ensemble de votre code.
Vous avez posté beaucoup trop hors de propos de code et pas assez du code qui compte. Le problème réside probablement dans votre fichier d'en-tête qui définit la structure. Aussi s'il vous plaît commencer à accepter le fait que void main() n'est pas droit et que vous devez vous dire int main().

OriginalL'auteur simar | 2012-03-17

  1. 1

    Vous pouvez avoir des problèmes parce que vous n'avez pas encore obtenu une bonne raison de diviser les choses en place. Une bonne raison de ne vous aider à identifier les pièces appartiennent ensemble, et dont les pièces sont séparées. Donc, commencer avec une approche plus simple.

    Diviser le programme en trois fichiers principaux.c qui contient la fonction main(), nœud.h, l'en-tête qui assure les déclarations sont communs à l'ensemble de tous les le programme, et par conséquent, est compris par le compilateur, et le nœud.c, les fonctions qui manipulent le NŒUD de la structure.

    Mettre le typedef ... NODE; et toutes les déclarations de fonctions qui manipulent un NŒUD dans un seul nœud.h fichier d'en-tête. De sorte que vous pouvez fusionner l'en-tête existant fichiers en un seul, et de l'appeler nœud.h.

    Que Joop Eggen, recommande de mettre #ifndef _NODE_H_ ... #endif autour de nœud.h contenu pour le protéger contre l'erreur #inclus deux fois.

    Test que le fichier est correct avec un minimum de main.c fichier contenant:

    #include "node.h"

int main() { return 0; }

    et le compiler. Cela devrait vous donner pas d'erreurs de compilation. Si il contient des erreurs, la faute est dans le fichier d'en-tête.

    Mettre les fonctions qui manipulent NŒUD, dans un fichier appelé nœud.c, qui sera d'abord:

    #include "node.h"

    compiler et lien avec le principal.c (gcc main.c nœud.c), et il devrait y avoir aucune erreur.

    Construire le programme de stades, ajouter du code à la main.c fichier, le nœud.c fichier et ajouter des déclarations de fonctions dans le nœud.fichier c dans le nœud.h. Ajouter de petites quantités de code, et de compiler fréquemment (avec des avertissements sous tension, par exemple gcc-Wall principal.c nœud.c) et de test pour s'assurer qu'il est en train de faire ce que vous attendez.

    Le programme sera finalement terminée.

    OriginalL'auteur gbulmer

  2. 1

    Je recommande à la recherche à Quelles sont extern les variables en C?.

    Vous pouvez inclure des en-têtes systèmes tels que <stdio.h> sans avoir à se soucier de savoir si il ya d'autres en-têtes nécessaires à l'utilisation de ses services. Vous devez concevoir vos propres en-têtes de la même manière. Vous devez également éviter les erreurs si votre fichier est inclus plusieurs fois (que ce soit accidentellement ou délibérément).

    Vous avez:

    • b_tree_ds.h

      typedef struct node {
    struct node* left;
    struct node* right;
    int key;    //contains value
} NODE;

      Jusqu'à un certain point, c'est très bien; il vous suffit de l'envelopper dans un en-tête de gardes si une réintégration n'est pas de dommages.

      #ifndef B_TREE_DS_H_INCLUDED
#define B_TREE_DS_H_INCLUDED

typedef struct node {
    struct node* left;
    struct node* right;
    int key;    //contains value
} NODE;

#endif /* B_TREE_DS_H_INCLUDED */

      Vous note:

      Quand j'ai essayer d'ajouter extern comme dans typedef extern struct node il donne une erreur de plusieurs de stockage de classe, mais si je le rate, je reçois l'erreur pour de multiples définitions.

      Point de vue syntaxique, extern, static, auto, register et typedef sont toutes les classes de stockage, et vous ne pouvez avoir qu'une seule classe de stockage dans une déclaration donnée. C'est pourquoi vous obtenez les multiples de stockage classe d'erreur. La "définition de plusieurs" erreur continuera d'être un problème jusqu'à ce que C2011 est très répandue, et l'en-tête des gardes de prévenir que d'être un problème. Je pense que l'en-tête des gardes resteront valables même après C2011 est largement disponible.

    • traverse.h

      void traverse_print (NODE* p);

      Comme il est, vous ne pouvez pas tout simplement écrire #include "traverse.h" à faire usage de ses installations. C'est quelque chose à éviter dans la mesure du possible. (Voir: Auto-suffisante fichiers d'en-tête dans le C et le C++,
      Ce qui est une bonne référence de documenter les modes d'utilisation de l'h des fichiers dans C, et Dois-je utiliser #include dans les en-têtes.) Par conséquent, ceci devrait inclure b_tree_ds.h:

      #ifndef TRAVERSE_H_INCLUDED
#define TRAVERSE_H_INCLUDED

#include "b_tree_ds.h"

extern void traverse_print(NODE *p);

#endif /* TRAVERSE_H_INCLUDED */

      Vous pourriez omettre l'en-tête comprenant des protections sur cet en-tête (en supposant que b_tree_ds.h est auto-protège), mais il est plus simple d'être soi-même dans tous les en-têtes.

      Il y a une autre technique qui pourrait être mentionné:

      #ifndef TRAVERSE_H_INCLUDED
#define TRAVERSE_H_INCLUDED

typedef struct node NODE;

extern void traverse_print(NODE *p);

#endif /* TRAVERSE_H_INCLUDED */

      Ce fait NODE dans un opaque; l'utilisateur de l'en-tête traverse.h ne sait rien de ce qui est dans un NODE. Il y a des problèmes de coordination à résoudre qui font de ce un moins technique couramment utilisée.

    Avec ces changements pour les en-têtes, puis:

    • traverse.c ne doit inclure traverse.h (et devraient sans doute inclure avant tout autre en-tête pour offrir un test automatique de la maîtrise de soi), mais
    • Si traverse.c comprend à la fois les en-têtes, il n'y a pas de problèmes, quel que soit l'ordre dans lequel ils sont inclus (et il n'a pas d'importance si la répétition est direct ou indirect).
    • Votre main.c peuvent inclure juste traverse.h, comme indiqué, et sera OK. Avec le code d'origine, parce que main.c seulement inclus traverse.h et traverse.h ne comprennent pas b_tree_ds.h, le code ne compile pas correctement.

    OriginalL'auteur Jonathan Leffler

  3. 0

    Oublier extern. Dans le traverser.h vous devez inclure b_tree_ds.h. Certains compilateurs ont un pragma incluent une fois, mais il ne fait pas de mal à entourer le contenu de b_tree_ds.h:

    #ifndef B_TREE_DS_H
#define B_TREE_DS_H

...

#endif //B_TREE_DS_H

    Look pour le compilateur d'infos sur ce cas, et aussi sur les en-têtes précompilés.

    Ci-dessus est une plate-forme indépendante de l'exclusion du contenu de la deuxième fois.

    OriginalL'auteur Joop Eggen