estructura en diferentes archivos .cpp

Question

Tengo dos archivos .cpp en un proyecto, y main.cpp MyFile.cpp

me he globaly definidos MyStruct estructura en main.cpp, ahora quiero usar esta estructura en myfile.cpp. Cuando escribo mystruct en un archivo de cabecera e incluyo en ambos archivos cpp, aparece un error que dice redefinición de mystruct. ¿Cómo debería resolver este problema?

Answer 1

El problema es que básicamente tiene el mismo código dos veces como resultado si ve una inclusión como una importación del código.

Puede usar #ifdef para solucionarlo, consulte http://www.fredosaurus.com/notes-cpp/preprocessor/ifdef.html

Answer 2

Debe mover la estructura común a un fichero de cabecera e incluir esa cabecera en ambos archivos. Cualquier otra solución es una solución.

Answer 3

La declaración y las definiciones son dos cosas diferentes. Para su caso, está asignando espacio para su estructura en main.cpp. En su encabezado, debe usar el modificador extern para su estructura para que todos los archivos que incluyen el archivo de encabezado se vean en el espacio de nombres global para la estructura. Espero eso ayude.

Answer 4

El C/C++ enfoque estándar:

// 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" 

Answer 5

La cabecera es donde se declara lo que su struct consistirá en (probablemente un archivo common.h incluido por main.cpp y myfile.cpp):

struct MyStruct { 
    int messageID; 
    int tempVariable; 
}; 

En su main.cpp, aquí es donde realmente usa la estructura:

void someFunction() { 
    struct MyStruct tempStruct; 

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

} 

No ponga la definición de su struct en su main.h y main.cpp - ¡o obtendrá un error de redefinición!

Además, no incluya el archivo cpp, incluya el archivo de encabezado (por ejemplo, common.h). Sin saber más sobre la estructura de su programa, es difícil proporcionar mejor información.

Answer 6

debe definir la estructura en el archivo de cabecera única, debe quitar la definición de main.cpp

Answer 7

Puede ser que usted puede dar más información acerca de lo que es el diseño de su proyecto.

A juzgar por la conjetura, probablemente su problema puede ser cualquiera de los dos:

1. desea declaración adelantada de la estructura.

2. usando incluyen protecciones para evitar la redefinición.

Véase el siguiente enlace para saber cómo manejar tanto:

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

Los archivos de cabecera también utilizan incluyen guardias, por lo que puede averiguar qué es exactamente puede resolver su problema.

Answer 8

Si desea compartir cualquier variable entre varios archivos cpp, debe declarar en la cabecera como extern. Y sin extern en uno de los archivos C++.

Si no lo hace, no tendrá una vinculación, ya que varios objetos tendrían variables con el mismo nombre. En cambio, al usar extern, un objeto tendría esta variable y otros objetos lo vincularían.

Answer 9

Si usted está tratando de compartir la definición de una estructura entre varias unidades de compilación (archivos CPP), la forma común es la siguiente: Coloque la definición de su estructura en un archivo de cabecera (mystruct.h). Si la estructura contiene algún método (es decir, es una clase con todos los miembros públicos por defecto), puede implementarlos en el archivo mystruct.CPP o, si son livianos, directamente dentro de la estructura (lo que los hace inline por defecto)

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() { ... } 

Puede utilizar su estructura en tantos archivos cpp como desee, simplemente #include mystruct.h:

principal .cpp

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

Si, por el contrario, que está tratando de compartir un mundial ejemplo de la estructura a través de varias unidades de compilación (que no es absolutamente claro por su pregunta), hacer que el anterior pero también se suman

extern MyStruct globalStruct; 

a myStruct .h. Esto anunciará que una instancia está disponible con enlace externo; en otras palabras, existe una variable pero se inicializa en otro lugar (en tu caso en mystruct.cpp). Agregue la inicialización de la instancia global a mystruct.cpp:

MyStruct globalStruct;

Esto es importante. Sin crear manualmente una instancia de globalStruct, obtendría unresolved-external errores de vinculador. Ahora tiene acceso al globalStruct desde cada unidad de compilación que incluye mystruct.h.