Struct als Zeiger übergeben

[verwirrter Frickler (Gast)]

Mal auf's Wesentliche abgespeckt. Vor main:

struct someStuff_t{
    int SDM120reg;
 // char serial[20];
    };

void test(struct someStuff_t * xy){
 xy->SDM120reg = 30001;
//strcpy (xy->serial, "/dev/ttyS0");
}


int main (void){
    someStuff_t *someStuff;
    test(someStuff);

    return 0;
}

Das führt dazu, daß das Programm mit einer Meldung über einen internen 
Fehler sofort abgebrochen wird.
Was mache ich da falsch...? Kann es sein, daß die Compiler-Settings 
vielleicht irgendwie falsch eingestellt ist? Compiler ist 
mingw32-g++.exe für Win 10 unter Code Blocks mit Ausgabe im DOS-Fenster; 
alle Compiler-Settings default und seit Wochen ohne Probleme...

[jz23 (Gast)]

[ ] Du möchtest in einem Programmierbuch deiner Wahl nochmal das Kapitel 
über Zeiger durchlesen

[Der Pointler (Gast)]

Du versuchst einen nicht initialisierten Pointer zu dereferenzieren, das 
geht zu 99.999999% in die Hose.

[Garcon (Gast)]

Tip: worauf zeigt

someStuff

?

[Andreas S. (Firma: Schweigstill IT) (schweigstill)]

Wenn Du Dich auch nur eine Sekunde Deines Lebens mit der für die 
Verwendung von Zeigern erforderlichen Gedanken über die 
Speicherverwaltung beschäftigt hättest, dann wäre Dir die Sache völlig 
klar. Aber leider scheint heutzutage eine Beschäftigung mit den 
Grundlagen bei vielen, nicht allen(!), ziemlich verpönt zu sein. Statt 
sich das nötige Wissen selbst zu erarbeiten, wird dann einfach auf 
irgendwelche Webforen zurückgegriffen.

Aber natürlich ist das alles nicht Deine Schuld, sondern der böse, böse 
Compiler ist dafür verantwortlich.

Genau diese Art von Unverständnis über die Verwendung von Zeigern führte 
übrigens dazu, dass ehemalige Kollegen völlig zu Recht die Entlassung 
eines anderen Kollegen forderten, da sie es leid waren, dessen Fehler 
immer wieder auszubügeln. Dummerweise machen sich derartige Fehler 
häufig nicht an der Stelle bemerkbar, an der sie verursacht werden, 
sondern ggf. sogar in ganz anderen Modulen der Software.

[verwirrter Frickler (Gast)]

>Du versuchst einen nicht initialisierten Pointer zu dereferenzieren
Aaahhhh! Natürlich, ich Depp!

Das hier hat geholfen.

    someStuff_t *someStuff, st;
    someStuff = &st;

[Garcon (Gast)]

verwirrter Frickler schrieb:
> Du versuchst einen nicht initialisierten Pointer zu
> dereferenzieren
>
> Aaahhhh! Natürlich, ich Depp!
>
> Das hier hat geholfen.    someStuff_t *someStuff, st;
>     someStuff = &st;

Ich wollte zuerst was zu Schweigstills Kommentar schreiben aber das hat 
mich dann doch davon abgehalten, weil er scheinbar doch klüger ist und 
recht hat...

Tldr: Überdenk deine Lösung nochmal...

[Der Pointler (Gast)]

verwirrter Frickler schrieb:
> Das hier hat geholfen.    someStuff_t *someStuff, st;
>     someStuff = &st;

Ich wage zu bezweifeln, dass dein Compiler das ohne zu motzen 
akzeptiert.

[verwirrter Frickler (Gast)]

Autor: Andreas Schweigstill (Firma: Schweigstill IT) (schweigstill) 
schrieb:
>Wenn Du Dich auch nur eine Sekunde Deines Lebens mit der für die
>Verwendung von Zeigern erforderlichen Gedanken über die
>Speicherverwaltung beschäftigt hättest

Sag doch nicht so was. Ich frickle seit Jahren vor mich hin und schaue 
ab und zu auch tatsächlich in das Ritchie-Buch - aber wenn man nur alle 
Schaltjahr Code schreibt, dann vergisst man halt einiges...

Anyway, Montessori-Pädagogik (hilf, damit du dir selbst helfen kannst) 
wie von Garcon praktiziert ist bei weitem besser als hier deinen Frust 
über einen unfähigen Kollegen abzulassen...

[Nop (Gast)]

Der Pointler schrieb:
> verwirrter Frickler schrieb:
>> Das hier hat geholfen.    someStuff_t *someStuff, st;
>>     someStuff = &st;
>
> Ich wage zu bezweifeln, dass dein Compiler das ohne zu motzen
> akzeptiert.

Ich würde das nicht wagen. Die Deklaration deklariert erst einen Zeiger 
auf das struct und dann ein struct selber. Der Asterisk bindet sich an 
den Variablennamen und nicht an den Datentyp. Es werden hier also 
keineswegs zwei Zeiger deklariert.

[jz23 (Gast)]

Schön ist das aber nicht und wozu man überhaupt einen Zeiger an der 
Stelle benutzt ist mir auch nicht klar.

[Nop (Gast)]

jz23 schrieb:
> Schön ist das aber nicht

Stimmt, und genau weil man beim schnellen Lesen so eine Art Deklaration 
mißversteht, deklariere ich Zeiger und Daten nie auf diese Weise in 
derselben Zeile.

> und wozu man überhaupt einen Zeiger an der Stelle benutzt ist mir auch nicht 
klar.

Klar ist der überflüssig, man kann auch direkt mit &st rangehen.

[Johann L. (gjlayde)]

verwirrter Frickler schrieb:

typedef struct
{
     int SDM120reg;
} someStuff_t;

void test (someStuff_t *xy)
{
  xy->SDM120reg = 30001;
}

int main (void)
{
      someStuff_t someStuff;
      test (&someStuff);

      return 0;
}

[Jobst Q. (joquis)]

Nop schrieb:
> Der Pointler schrieb:
>> verwirrter Frickler schrieb:
>>> Das hier hat geholfen.    someStuff_t *someStuff, st;
>>>     someStuff = &st;
>>
>> Ich wage zu bezweifeln, dass dein Compiler das ohne zu motzen
>> akzeptiert.
>
> Ich würde das nicht wagen. Die Deklaration deklariert erst einen Zeiger
> auf das struct und dann ein struct selber. Der Asterisk bindet sich an
> den Variablennamen und nicht an den Datentyp. Es werden hier also
> keineswegs zwei Zeiger deklariert.

Soll ja wohl auch nicht. Neben dem Zeiger wird ein Struct selbst, also 
eine Speicherstelle deklariert. So funktioniert es, mit zwei Pointern 
nicht.

[Nop (Gast)]

Jobst Q. schrieb:

> Soll ja wohl auch nicht. Neben dem Zeiger wird ein Struct selbst, also
> eine Speicherstelle deklariert. So funktioniert es, mit zwei Pointern
> nicht.

Eben, also wieso sollte der Compiler da motzen? :-)

[Jobst Q. (joquis)]

Ok, ich habs falsch verstanden. Als würdest du es nicht wagen, das so zu 
deklarieren. Zu schnell gelesen.

[Yalu X. (yalu) (Moderator)]

Die Zeile

    someStuff_t *someStuff, st;

hat IMHO nichts Mehrdeutiges oder Missverständliches an sich, solange
man nicht der von Stroustrup in die Welt gesetzte Unsitte verfällt, den
Stern an den Typ- statt an den Variablennamen zu kleben:

    someStuff_t* someStuff, st;

Diese Schreibweise erweckt tatsächlich den Eindruck, dass auch st ein
someStuff_t-Zeiger sei.

Da aber der verwirrte Frickler die logisch korrektere von beiden
Schreibweisen verwendet hat, meckern weder der Compiler noch die meisten
Leser mit etwas C/C++-Erfahrung. Wenn einer meckert, dann höchstens
Stroustrup höchstpersönlich, der, um den Unsinn wenigstens etwas zu
kaschieren, vermutlich vorschlagen würde, die Deklaration aufzuteilen:

    someStuff_t* someStuff;
    someStuff_t st;

PS: Nicht, dass ein falscher Eindruck entsteht: Abgesehen von diesem
Punkt habe ich großen Respekt vor Stroustrup.

[Rolf M. (rmagnus)]

Das * ist Teil des Typs und nicht Teil des Namen. Deshalb ist es 
Quatsch, es zum Namen zu schreiben. Die "Unsitte" ist schon viel früher 
bei K&R passiert. Stroustrup kann man höchstens vorwerfen, dass er in 
C++ die semantischen Regeln nicht gleich mit bereinigt hat, so dass das 
obige tatsächlich zwei Zeiger definiert. Das hat aber vermutlich 
historische Gründe.

[mec (Gast)]

Rolf M. schrieb:
> Das * ist Teil des Typs und nicht Teil des Namen. Deshalb ist es
> Quatsch, es zum Namen zu schreiben. Die "Unsitte" ist schon viel früher
> bei K&R passiert. Stroustrup kann man höchstens vorwerfen, dass er in
> C++ die semantischen Regeln nicht gleich mit bereinigt hat, so dass das
> obige tatsächlich zwei Zeiger definiert. Das hat aber vermutlich
> historische Gründe.

So wie ich das Verstanden habe, kommen solche Dinge wie "int *i,ii" aus 
einer Zeit wo noch jedes gesparte Zeichen, sehr teuren Speicher sparte. 
Wurde Sowas eigentlich noch in Lochkarten gestanzt?

[Markus F. (mfro)]

Yalu X. schrieb:
> Wenn einer meckert, dann höchstens
> Stroustrup höchstpersönlich, der, um den Unsinn wenigstens etwas zu
> kaschieren, vermutlich vorschlagen würde, die Deklaration aufzuteilen

Ich nehme an, daß er den '*' an den Datentyp "geklebt" hat, als er 
gerade die Referenz erfunden hatte.

int* &i;      // 1. Referenz auf einen Zeiger
int *&i;      // 2. Huh?
int * &i;     // 3. so kann man's durchgehen lassen

Einen Zeiger auf eine Referenz gibt's nicht, also steht

int& *i;      // Fehler

(zum Glück) nicht zur Debatte. Ich persönlich bevorzuge #3.

[Eric B. (beric)]

Hm, habe gerade kein C Compiler zum greifen bereit:

int*i; // 4. Und so, ganz ohne Leerzeichen?

[Eric B. (beric)]

Rolf M. schrieb:
> Das * ist Teil des Typs und nicht Teil des Namen.

Eben nicht, sonst gäbe es die ganze Debatte nicht. ;-)

> Die "Unsitte" ist schon viel früher bei K&R passiert.

Da gebe ich dir völlig Recht.

> Stroustrup kann man höchstens vorwerfen, dass er in
> C++ die semantischen Regeln nicht gleich mit bereinigt hat, so dass das
> obige tatsächlich zwei Zeiger definiert. Das hat aber vermutlich
> historische Gründe.

Kompatibilität zur C, halt.