Probleme mit einem struct

Ich möchte ein struct in mehreren Klassen benutzen, erhalte aber nur ein

Public symbol '_data' defined in both module c:\..\unit1.obj and c:\..\test_class.obj

Projekt hat Unit1.cpp (TForm)
help.h (sammel-header mit dem struct)
test_class.cpp (test Klasse)

Unit1.cpp

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::func(mystruct &x)
{
}
//---------------------------------------------------------------------------

Unit1.h

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>

#include "help.h"

//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
private:	// Anwender-Deklarationen
    void __fastcall func(mystruct &x);
public:		// Anwender-Deklarationen
    __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

//--------------------------------------------------------

help.h

#ifndef _help_
#define _help_

struct mystruct
{
    int i;
}data;

#endif

//--------------------------------------------------------

test_class.cpp

#include "test_class.h"

//---------------------------------------------------------------------------
XYZ::XYZ(void)
{
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
XYZ::~XYZ()
{
}
//---------------------------------------------------------------------------
void XYZ::func(mystruct &x)
{
}
//---------------------------------------------------------------------------

test_class.h

#ifndef _XYZ_
#define _XYZ_

#include "help.h"

class XYZ
{
private:
    void func(mystruct &x);
public:
	XYZ(void);
	~XYZ();
};
#endif

Kann mir wer helfen und sagen was ich falsch mache?

P.S. Ich glaube Smitty hat das selbe Problem, ich stelle meine Frage aber lieber allein.

sothis_

typedef struct mystruct
{
    int i;
}mystruct;

hilft vielleicht, bin mir aber nicht sicher

VergissEs

struct mystruct 
{ 
    int i; 
};

Es geht beides, bei beiden kann ich aber nicht mehr global von überall auf data zugreifen, sondern muss das struct neu mit mystruct data; anlegen.

Auch nicht so schlimm. Dann muss ich in Unit1.cpp eben mystruct ccc; und in test_class.cpp extern mystruct ccc; eintragen. Danke für eure Hilfe!! :schland:

akari

Hallo

Das ist das allgemeine Problem mit globalen Variablen über mehrere Übersetzungseinheiten. Die eine Lösung mit dem extern hast du ja schon gefunden. Eine andere, meiner Meinung nach sinnvollere ist es die struct-Instanz irgendwo lokal zu deklarieren und dann immer per Parameter an Funktionen zu übergeben (und mit Pointern/Referenzen arbeiten wenn nötig)

bis bald
akari

Danke akari.

Bin weiter am rumspielen von Funktionen und structs. Vielleicht kann mir jemand ja erklären warum ich bei Arrays-Structs Zeiger anstatt Adressen verwednen muss und ob mein funktionierendes Beispiel das "optimale" wäre.

mein struct und was ich tun möchte

struct mystruct
{
    int i;
};

mystruct ccc;
mystruct ooo[100];

//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    ccc.i = 5;
    func1(ccc);

    ooo[0].i = 101;
    func2(ooo); 
}
//---------------------------------------------------------------------------
void __fastcall TForm1::func1(mystruct &x)
{
    Caption = IntToStr(x.i);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::func2(mystruct *x)
{
    Caption = IntToStr(x[0].i);
}
//---------------------------------------------------------------------------

akari

Hallo

Ein Array läßt sich in C++ auch über einen Pointer ansprechen. Der Pointer zeigt dann auf das erste Element des Arrays. Über die sogenannte Pointer-Arithmetik läßt sich dann mit Hilfe des []-Operators auch auf die andern Elemente zugreifen.

Aber eine Referenz ist immer "nur" genau der Datentyp. Wenn du also mystruct &x als Parameter angibst, kannst du auch nur genau eine Instanz übergeben, nicht ein ganzes Arrays.

Du kannst aber schreiben :

struct A
{
};

void Funktion( A a[])
{
}

Damit kannst du Arrays an Funktionen übergeben.
Beachte aber zwei Dinge :
- In der Funktion kannst du nicht die Größe des Arrays bestimmen. Entweder must du zur Compiletime feste Größen verwenden oder die zur Laufzeit dynamische Größe als extra Parameter an die Funktion mit übergeben
- Das so übergebene Array wird nicht kopiert sondern auch ohne extra &-Operator als Referenz behandelt. Das führt auch dazu das jede Änderung des Arrays in der Funktion auch das Arrays außerhalb der Funktion mitändert.

bis bald
akari