Struct-Array initiasisieren

Computer: Software & Programmierung C/C++
#1

Hallo Experten!

Ich habe ein Array aus Strukturen:

struct Record
{
int Addr;
int Data[0x80];
};

Record WorkSpace[0x400];

In dem Struct ist ein Array ( Data[0x80] ), das soll mit dem Hex-Wert 0xFF initialisiert werden.
Ich hab mir schon ein Beispiel-Struct angelegt in dem die entsprechenden Werte drinstehen, aber auch damit kann ich es nicht richtig initialisieren.

Wie muss ich dieses Feld Workspace[] initialisieren, damit Addr=0 ist und in Data[0x80] jedes Feld 0xFF ist?

Danke im Vorraus, Christof

#2

Hallo Christoph!

Ich sehe 2 Möglichkeiten:
* Du machst aus der Struktur eine Klasse und initialisierst
die Variablen im Konstruktor
* Du nimmst ganz einfach eine For-Schleife

class Record
{
public:
int addr;
int data[0x80];

Record();
};

Record::Record()
{
memset (data, 0xff, 0x80);
addr = 0;
}

Record Workspace[0x400];

struct Record
{
int addr;
int data[0x80];
};

Record Workspace[0x400];

void main()
{
int i;

for (i=0; i

#3

Ich hab jetzt die Klasse genommen:

class Record
{
public:
 int Addr;
 int Data[0x80];

 Record();
};


Record::Record()
{
 memset (data, 0xff, 0x80);
 addr = 0;
}


Record Workspace[0x400];

Bis dahin tuts auch gut, aber ich kann dann nicht über

WorkSpace[bla].Data[bli]

darauf zugreifen und

Data[bli]

verändern.

An der Klasse kanns eigentlich nicht liegen da die Variablen ja alle public sind.
Muss ich doch noch Manipulationsmethoden schreiben? Dann müsste ich mein ganzes Programm umschreiben.

Danke für Ratschläge, Christof

#4

Geht’s genauer?
Hallo Christof,

was heißt

aber ich kann dann nicht über
WorkSpace[bla].Data[bli]
darauf zugreifen und
Data[bli]
verändern.

?

Dieses Dingsbums funktioniert bei mir einwandfrei: (Visual C++ 6.0) (Du hattest übrigens im ‚memset()‘ das ‚sizeof(int)‘ vergessen):

#include "stdio.h"
#include "memory.h"

class Record{
public: 
 int Addr; 
 int Data[0x80]; 
 Record();
};
Record::Record()
{ 
 memset (Data, 0xff, 0x80\*sizeof(int)); 
 Addr = 0;
}
Record Workspace[0x400];

int main(int argc, char\* argv[])
{
 Workspace[0].Data[0] = 1234567;
 Workspace[0x399].Data[0x79] = 7654321;
 printf(
 "%d %d\n", 
 Workspace[0].Data[0], 
 Workspace[0x399].Data[0x79]
 );
 return 0;
}

Bei mir erscheint die Ausgabe

1234567 7654321

und gut.

Könntest Du mal genauer sagen, was nicht funktioniert (Compilerfehler, Laufzeitfehler, kein Fehler aber unerwartete Daten …) ?

Gruß, Ralf

#5

Hi Ralf!

Dieses Dingsbums funktioniert bei mir einwandfrei: (Visual C++
6.0) (Du hattest übrigens im ‚memset()‘ das ‚sizeof(int)‘
vergessen):

memset produziert bei mir ob mit oder ohne sizeof als Wert -1 (Borland C++ Builder 4)

Könntest Du mal genauer sagen, was nicht funktioniert
(Compilerfehler, Laufzeitfehler, kein Fehler aber unerwartete
Daten …) ?

Gruß, Ralf

Ich kann zur Laufzeit den Werten in WorkSpace[i].Data[j] nichts anderes zuweisen:

for (int i=0; i

Die Kontrollausgabe bringt konstant als Wert 0xFF mit dem es ja korrekt initialisiert wurde.
Auch der Debugger sagt mir dass die Werte gleich sind.
Ich habe da ja memset nicht tat (s.o.) in einer Schleife initialisiert:


    
    Record::Record()
    {
    Addr = 0;
    for (int i=0;i
    
    Bin nach wie vor ein bischen ratlos.
    
    Danke im Vorraus, Christof
#6

Hallo Christoph!

Halbe Fragen, halbe Antworten. Was enthält denn eigentlich temp?

Bis zum nächsten Post,
KoRn!

#7

temp enthält Integer-Werte zwischen 0 und 255 (0xFF)
Die werden aus einer Datei eingelesen und an der entsprechenden Stelle in Workspace eingefügt.
Das Auslesen tut, auch die Algorithmen zum einfügen in Workspace haben die Richtige Daten. Nur wenn ich nachher WorkSpace auslese stehen keine Daten drin.

Ich habe das Array in einer separaten Datei, die ich dort wo die Daten verarbeitet werden sollen mittels #include „Workspace.h“ einbinde.
Daran kanns eigentlich nicht liegen, mit anderen Variablen tuts ja auch.

Bis dann, Christof

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]

#8

Hallo Leute!

Hab das Problem genauer lokalisieren können, weiss aber nicht woran es liegt.

In Workspace.h ist mein Array bekannt gemacht worden.

In Unit1.cpp wird es gefüllt, wenn ich hier die Daten auslese sind sie da (Kontrollausgabe)

In Unit2.cpp wird das Array auch ausgelesen, dort sind die Daten nicht drin, das Array hat die Initialisierungswerte.

Muss ich das Array ausdrücklich übergeben?
Bis jetzt habe ich halt in beiden Units #include „Workspace.h“ gemacht, dabei entstehen keine Zugriffsfehler.
Kann es sein dass ich auf lokale Arrays zugreife ohne es zu merken oder greif ich wirklich immer auf die gleichen Daten zu?
Wie kann ich die lokalen Sachen mit Zeigern umgehen?

Christof

#9

Autsch!
Hallo Christof,

Du hast Dein Problem eigentlich schon erkannt.
Wenn die Definition des Arrays in der Headerdatei steht, wird überall dort, wo Du Workspace.h einbindest, eine lokale Kopie erzeugt. Der Precompiler fügt den Text aus der.h-Datei wörtlich ein, anschließend übersezt der Compiler alles. Der Compiler sieht dann aber nicht mehr, dass beide Male die Datei Workspace.h eingebunden wurde, sondern nur, dass jedesmal

Record Workspace[0x400];

dasteht. Also erzeugt er jedesmal ein neues Objekt.

Damit schreibst Du die Daten in ein Array und versuchst, sie dann in einem anderen wiederzufinden.

Böse Falle.

Vorschlag:
Eine Datei ‚Workspace.cpp‘ hinzufügen, dort die Zeile

Record Workspace[0x400];

hineinschreiben (und am besten auch gleich noch die Implementierung der Klasse).

In die Datei Workspace.h kommt stattdessen die Zeile

extern Record Workspace[];

Damit ‚weiß‘ der Compiler, dass er das Objekt nicht anlegen soll, sondern dass es das Objekt schon irgendwo gibt. Wo das Objekt dann tatsächlich zu finden ist (nämlich in Workspace.cpp) findet der Linker heraus.

Gruß,
Ralf

#10

1000 Dank
Hallo Ralf!

Das wars, jetzt tuts.
Vielen Dank, hab wieder mal viiiiiiiiiiiiel dazu gelernt.

Bye, Christof