À l'aide struct dans différents .fichier cpp

Si vous essayez de partager la définition d'une struct entre plusieurs unités de compilation (fichiers cpp), la façon la plus courante est: Place de la définition de votre structure dans un fichier d'en-tête (mystruct.h). Si la structure contient toutes les méthodes (c'est à dire qu'il est plutôt une classe avec tous les membres du public par défaut), vous pouvez les mettre en œuvre dans mystruct.CPP fichier, ou, s'ils sont légers, directement au sein de la structure (ce qui les rend inline par défaut).

mystruct.h:

#ifndef MYSTRUCT_H
#define MYSTRUCT_H

struct MyStruct
{
    int x;
    void f1() { /* Implementation here. */ }
    void f2(); /* Implemented in mystruct.cpp */
};

#endif

mystruct.cpp

#include "mystruct.h"
//Implementation of f2() goes here
void MyStruct::f2() { ... }

Vous pouvez utiliser votre structure dans autant de fichiers cpp que vous le souhaitez, il suffit de #include mystruct.h:

main.cpp

#include "mystruct.h"
int main()
{
    MyStruct myStruct;
    myStruct.x = 1;
    myStruct.f2();
    //etc...
}

Si, d'autre part, vous essayez de partager un mondial instance de la structure à l'échelle de plusieurs unités de compilation (il n'est pas absolument clair à partir de votre question), faire comme ci-dessus mais aussi ajouter

extern MyStruct globalStruct;

à mystruct.h. Cela permettra d'annoncer qu'une instance est disponible avec une liaison externe; en d'autres termes qu'une variable existe mais est initialisé ailleurs (dans votre cas mystruct.cpp). Ajouter l'initialisation de l'instance globale de mystruct.cpp:

MyStruct globalStruct;

C'est important. Sans créer manuellement une instance de globalStruct, vous obtiendrez en suspens-externe erreurs d'édition de liens. Vous avez maintenant accès à globalStruct de chaque unité de compilation qui comprend mystruct.h.

OriginalL'auteur Martin Gunia

Vous devez déplacer la commune de la structure d'un fichier d'en-tête et de l'inclure l'en-tête dans les deux fichiers. Toute autre solution est une solution de contournement.

OriginalL'auteur cprogrammer

L'en-tête est l'endroit où vous déclarez que votre struct sera composé de (probablement un common.h fichier inclus par main.cpp et myfile.cpp):

struct MyStruct {
    int messageID;
    int tempVariable;
};

Dans votre main.cpp, c'est là que vous utilisez réellement la structure:

void someFunction() {
    struct MyStruct tempStruct;

    //do something with it
    tempStruct.messageID = 1;

}

Ne pas mettre la définition de votre struct dans votre main.h et main.cpp - ou vous obtiendrez une redéfinition erreur!

Aussi, de ne pas inclure le fichier cpp - inclure le fichier d'en-tête (par exemple,common.h). Sans en savoir plus sur la structure de votre programme, il est difficile de fournir de meilleures informations.

OriginalL'auteur

Peut-être vous pouvez donner plus d'informations à propos de qu'est-ce que la mise en page de votre projet.

En passant par le deviner, probablement votre problème peut être l'un des deux:

1. vous voulez avant la déclaration de la structure.

2. l'aide d'inclure des gardes pour empêcher la redéfinition.

Voir le lien suivant pour savoir comment gérer à la fois:

http://www.adp-gmbh.ch/cpp/forward_decl.html

Les fichiers d'en-tête utilisons également inclure des gardes, de sorte que vous pouvez comprendre ce qu'est exactement peut résoudre votre problème.

OriginalL'auteur A. K.

Le standard C/C++ approche:

//source.h
Put all struct, class, typedef, macro definitions, extern variable declaraltions


//source.cpp
Implement the class, functions, define global/external variables


//main.cpp, and other parts of program
#include"source.h"

OriginalL'auteur Ajay