Pointer in Struct

[Anfänger (Gast)]

Hallo habe folgendes Problem.Ich habe verschiedene Structs in denen ich 
Daten ablege. Auf die einzelnen Structs möchte ich mit Hilfe von 
Pointern zugreifen welche in einem weiteren Struct sind.Leider kann ich 
nicht auf die einzelnen Werte zugreifen.Irgend wo scheine ich etwas zu 
vergessen. hier ein kleines Beispiel:

Header
struct  ERROR_BITS { 
     int Error1;
     int Error2;  
     int Error3    
};

union ERROR_REG {
   int          all;
   struct ERROR_BITS  bit;
};

struct DATA
{
  struct RS232Data *pWriteData;
     union ERRORS_REG *pError;
    
};

//Der Stuct ist Global so definiert
struct DATA G_Data;

main
{
 
  G_Data.pError->bit.Error1 = 1; 
 //Jetzt versuche ich einen Wert zu setzten leider geht das nicht
}

[Karl H. (kbuchegg)]

Anfänger schrieb:

>

>  G_Data.pError->bit.Error1 = 1; 
> //Jetzt versuche ich einen Wert zu setzten leider geht das nicht
>}
>

Was heißt in diesem Zusammenhang "es geht nicht"

Kriegst du eine Fehlermeldung vom Compiler?
Wie lautet die Fehlermeldung?
Der Compiler gibt die ja nicht zum Spass aus, sondern damit man sie 
liest und so einen Hinweis bekommt, was falsch sein könnte.

[Anfänger (Gast)]

Er setzt mir den Wert einfach nicht.

[Karl H. (kbuchegg)]

Anfänger schrieb:
> Er setzt mir den Wert einfach nicht.

In deinem Programm wundert mich das nicht wirklich. Du machst ja auch 
nichts mit dem Wert, warum sollte der Compiler daher den Wert setzen.

-> zeig dein richtiges Programm. Wenn das zu groß ist, dann speck es ab, 
bis nur noch der Fehler übrig bleibt (kontrollieren!) und poste das. 
Aber erfinde keine Beispiele hier fürs Forum. Nimm dein richtiges 
Programm.

In dem was du gepostet hast, ist erst mal nichts falsch. Dein Fehler 
liegt also ganz woanders (vergessenes volatile)

[NurEinGast (Gast)]

Syntaktisch hat das "Programm" vielleicht kein Fehler, aber pError zeigt 
doch noch in's Nirwana ? Oder ?

[Anfänger (Gast)]

Ok und wie lege ich fest wohin pError zeigt? Hey sorry für die Fragen 
bin halt neuling und versuche ein Projekt für die Schule zum laufen zu 
bringen.

[Peter (Gast)]

Anfänger schrieb:
> Ok und wie lege ich fest wohin pError zeigt? Hey sorry für die Fragen
> bin halt neuling und versuche ein Projekt für die Schule zum laufen zu
> bringen.

die Frage warum es überhaupt pointer sind?

Erzählt doch mal etwas genau was du vor hast.

[Karl H. (kbuchegg)]

Anfänger schrieb:
> Ok und wie lege ich fest wohin pError zeigt?

Indem du ein ERROR_REG Objekt anlegst und pError darauf zeigen lässt.

Nur daduch, dass du ein struct DATA Objekt anlegst, hast du ja noch kein 
ERRER_REG Objekt. Der Pointer im struct DATA kann auf so eines zeigen, 
aber dazu muss es erst einmal eines geben.

[Anfänger (Gast)]

Die aufgabe welche mir mein Lehrer gestellt hat ist als ertes das 
entwerfen von mehrern Structs (Fehlermeldung, Rs232, Messwerte).Die 
einzelnen Structs sollen aus einem gemeinsammen Struct angesprochen 
werden in welchem nur Pointer enthalten sein sollen.Mit hilfe diesen 
Globalen Struct und den enthaltenen Pointern soll innerhalb des 
Programms auf die einzelnen Structs zugegriffen werden.

[Klaus W. (mfgkw)]

Ich vermisse schon wieder schmerzlich den Button im Forum mit der 
Aufschrift
"Standardantwort: C-Buch lesen, C lernen!"

[Karl H. (kbuchegg)]

Der Aufbau, denn du machen willst sieht so aus (wenn ich mal 
interpretiere, wie die Einzelteile zusammenhängen sollen)

  G_Data
  +--------------------+
  | DATA               |
  +====================+                       +-----------------+
  | pWriteData:   o--------------------------->| RS232Data       |
  | pError:       o--------------+             +=================+
  +--------------------+         |             |                 |
                                 |             |   irgendwelche  |
                                 |             |      Daten      |
                                 v             +-----------------+
                           +------------------+
                           | ERROR_REG        |
                           +==================+
                           | all:             |
                           | bit:             |
                           |    +-----------+ |
                           |    | ERROR_BITS| |
                           |    +===========+ |
                           |    | Error1:   | |
                           |    | Error2:   | |
                           |    | Error3:   | |
                           |    +-----------+ |
                           +------------------+

Das ist das Ziel.

Mittels

struct DATA G_Data;

hast du den Teil hier erzeugt:

  G_Data
  +--------------------+
  | DATA               |
  +====================+
  | pWriteData:        |
  | pError:            |
  +--------------------+

und wo ist der Rest? Wo kommen die anderen Rechtecke (=Variablen von 
einem bestimmten Typ) her, so dass du die Pointer in G_Data darauf 
zeigen lassen kannst? Mit deiner G_Data Variablen hast du sie nicht 
erzeugt. Das erzeugt nur ein struct DATA Objekt und nicht mehr. Steht ja 
auch so im Source Code.

[Anfänger (Gast)]

Ich habe ein Buch vor mir und versuche mit dessen Hilfe das hin zu 
bekommen. Aber aller Anfang ist schwer.Ja genau so soll das Grundgerüst 
aussehen.

[Karl H. (kbuchegg)]

Anfänger schrieb:
> bekommen. Aber aller Anfang ist schwer.Ja genau so soll das Grundgerüst
> aussehen.

Na, dann programmier das doch!

Du brauchst das struct DATA Objekt. Hier ist es

struct DATA G_Data;

  G_Data
  +--------------------+
  | DATA               |
  +====================+                       
  | pWriteData:   
  | pError:       
  +--------------------+

weiters brauchst du laut Zeichnung ein union ERROR_REG Objekt. Hier ist 
es

union ERROR_REG G_Errors;

  G_Data
  +--------------------+
  | DATA               |
  +====================+
  | pWriteData:   
  | pError:
  +--------------------+
                        

                            G_Errors
                           +------------------+
                           | ERROR_REG        |
                           +==================+
                           | all:             |
                           | bit:             |
                           |    +-----------+ |
                           |    | ERROR_BITS| |
                           |    +===========+ |
                           |    | Error1:   | |
                           |    | Error2:   | |
                           |    | Error3:   | |
                           |    +-----------+ |
                           +------------------+

damit stehen erst mal die Rechtecke (das RS232 Objekt ignoriere ich mal)

und dann muss man noch dafür sorgen, dass der Pointer in G_Data auf das 
G_Errors Objekt zeigt. Das kann man in der Initialisierung von G_Data 
machen, mann kann es aber auch ganz am Programmanfang machen:

int main
{
  G_Data.pError = &G_Errors;

und schon hat man den Pfeil vom G_Data Objekt zum G_Errors Objekt 
eingerichtet.

  G_Data
  +--------------------+
  | DATA               |
  +====================+
  | pWriteData:   
  | pError:       o--------+
  +--------------------+   |
                           |
                           |
                           |  G_Errors
                           |  +------------------+
                           |  | ERROR_REG        |
                           |  +==================+
                           +->| all:             |
                              | bit:             |
                              |    +-----------+ |
                              |    | ERROR_BITS| |
                              |    +===========+ |
                              |    | Error1:   | |
                              |    | Error2:   | |
                              |    | Error3:   | |
                              |    +-----------+ |
                              +------------------+

struct DATA G_Data;
union ERROR_REG G_Errors;

int main
{
  G_Data.pError = &G_Errors;

  // jetzt kannst du über den Pointer in G_Data auf das dadurch verlinkte
  // Error Objekt zugreifen

  G_Data.pError->bits.Error1 = 1;
}

Wenn du dir nicht sicher bist, dann zeichne deine Datenstruktur auf 
einem Stück Papier mit, so wie ich das hier gemacht habe! Dann kannst du 
nichts vergessen. Und Doku ist es ausserdem gleichzeitig auch noch.

[Anfänger (Gast)]

Besten Dank das:

G_Data.pError = &G_Errors;

war es was mir gefehlt hat.Jetzt funktioniert mein Programm.Danke für 
die geistige Anregung.