Strukturenaufruf wie Funktion

[Jürgen (Gast)]

name4->name2(name4,name7);  


typedef struct structname {
  void *name1;
  type name2;
  uchar name3;  
} tstructname;

typedef void (*type) (const struct structname * name5, char *name6);

extern const tstructname *name4;

als ich habe vollgenden Programcode bekommen und verstehe ihn nicht. ich 
mus leider zugeben das ich nicht der Beste Programmierer bin, hoffe aber 
das ihr mir helfen könnt es zu verstehen.

Die erste Zeile steht in meiner .c Datei der rest in der .h. für mich 
sah im ersten moment zeile 1 aus wie ein Funktionsaufruf. Scheint aber 
keiner zu sein. Sondern irgend ein "Sonderding" bei strukturen.

Ich danke euch für eure Hilfe

[(prx) A. K. (prx)]

"type" bzw. "name3" ist ein Zeiger auf eine Funktion. Und die wird exakt 
so aufgerufen.

[Yalu X. (yalu) (Moderator)]

Jürgen schrieb:
> Die erste Zeile steht in meiner .c Datei der rest in der .h. für mich
> sah im ersten moment zeile 1 aus wie ein Funktionsaufruf. Scheint aber
> keiner zu sein.

Doch, es ist einer. Schlag mal in deinem C-Buch das Kapitel "Funktions-
zeiger" bzw. "Functon Pointers" auf.

> Sondern irgend ein "Sonderding" bei strukturen.

Mit Strukturen hat das nur insofern etwas zu tun, dass der Funktionszei-
ger name2 Element einer Struktur (structname) ist. Er könnte aber auch
eine eigenständige Variable sein.

[Jürgen (Gast)]

Ich verstehe es leider noch nicht.

Also was ich denke / hoffentlich verstehe ist:

1) ich lege eine struktur mit drei "Variablen" an.
   name1, name2, name3.

const tstructname *name4 = NULL;

   so habe ich das im Code gefunden.

2) in name3 kann ich ein char abspeichern.

3) name1 ist ein zeiger auf eine Variable

was verbirgt sich jetzt hinter name2 ?

mit

 name4->name2(name4,name7);

 schreibe ich in meine Instanz name4 an die Stelle name2 was? Ich 
übergebe nur zwei Zeiger? Name5 und name 6

[Rolf M. (rmagnus)]

Jürgen schrieb:
> was verbirgt sich jetzt hinter name2 ?

Ein Zeiger auf eine Funktion.

> mit name4->name2(name4,name7);  schreibe ich in meine Instanz name4 an
> die Stelle name2 was?

Gar nichts. Du rufst die Funktion auf.

> Ich übergebe nur zwei Zeiger?

Ja.

[Karl H. (kbuchegg)]

Jürgen schrieb:

> was verbirgt sich jetzt hinter name2 ?

Ein Zeiger auf eine Funktion.
In name2 steht die Adresse einer Funktion. Die kann man aufrufen.


>
> mit

 name4->name2(name4,name7);

 schreibe ich in meine Instanz
> name4 an die Stelle name2 was? Ich übergebe nur zwei Zeiger? Name5 und
> name 6

du bist völlig falsch.

name4 ist ein Zeiger auf ein structur Objekt.
Dieses Strukturobjekt hat ein paar Member. Einen undefinierten (da void) 
Pointer, der überallhin zeigen kann, solange es nur Daten sind. Einen 
uchar. Und eben auch einen Zeiger auf eine Funktion.

Und genauso, wie man auf den uchar zugreift:
   name4->name3 = 'a';
   j = name4->name3;
um ihm etwas zuzuweisen bzw den dort abgespeicherten Wert zu holen, 
genauso spezifiziert man dann eben mit

   name4->name2

erst mal den Funktionspointer. So, was macht man damit? Man kann ihm zb 
die Adresse einer Funktion zuweisen

void meine_Funktion( const struct structname * name5, char *name6 )
{
  ...
}

    name4->name2 = meine_Funktion;


oder aber man kann die Funktion auch aufrufen

   name4->name2(       );

und da die Funktion 2 Argumente haben will, einen Pointer auf ein const 
structname und einen char Pointer, gibt man die dann eben beim Aufruf 
an.

Hättest du meine_Funktion direkt aufgerufen, hättest du das auch müssen

   meine_Funktion( iregendwas, irgendwas_anderes );

beim indirekten AUfruf über einen Funktionszeiger ist das auch nicht 
anders

   name4->name2( irgendwas, irgendwas_anderes );


Wie oben schon gesagt: Dein C Buch sollte das ganze noch wesentlich 
ausführlicher beschreiben.

[... (Gast)]

Da kann man auch schon mal durcheinander kommen, wenn alles "name"x 
heißt. Darum ist es guter Stil, die Namen so zu wählen, dass man gleich 
die Bedeutung/Funktion erkennt.

[Yalu X. (yalu) (Moderator)]

... schrieb:
> Da kann man auch schon mal durcheinander kommen, wenn alles "name"x
> heißt. Darum ist es guter Stil, die Namen so zu wählen, dass man gleich
> die Bedeutung/Funktion erkennt.

Da der Code nicht von Jürgen selbst stammt, vermute ich, dass da
ursprünglich andere Namen standen, aus denen die Funktion der einzelnen
Typen, Variablen und Elemente deutlicher hervorgegangen ist.

[Karl H. (kbuchegg)]

Yalu X. schrieb:
> ... schrieb:
>> Da kann man auch schon mal durcheinander kommen, wenn alles "name"x
>> heißt. Darum ist es guter Stil, die Namen so zu wählen, dass man gleich
>> die Bedeutung/Funktion erkennt.
>
> Da der Code nicht von Jürgen selbst stammt, vermute ich, dass da
> ursprünglich andere Namen standen, aus denen die Funktion der einzelnen
> Typen, Variablen und Elemente deutlicher hervorgegangen ist.

Das hoffe ich mal ganz stark.
Und auch an den Fragesteller die Aufforderung:
Bitte ersetzte solche vernünftige Namen nicht durch welche, die du dir 
gerade ausgedacht hast. Das ist nämlich auch beim Schreiben einer 
Antwort mehr als lästig, wenn man ständig rauf runter scrollen muss, nur 
um sich zu vergewissern ob man jetzt den richtigen Member genommen hat 
oder nicht. Mit einigermassen aussagekräftigen Variablennamen merkt man 
sich die leicht und selbst wenn man mal einen Tippfehler macht, ist das 
nicht so schlimm. Aber wenn das alles name1, name2, name5 test1, test2, 
test3, ... heißt, ist eine Verwechslung wahrscheinlich und auch nicht so 
leicht erkennbar.

[Jürgen (Gast)]

Das stimmt leider.
Da der Code nicht von mir ist, habe ich die richtigen Namen ersetzt. 
Beim nächsten mal werde ich mir bessere Namen ausdenken. :-)

[Jürgen (Gast)]

OK. Ich habe einiges verstanden, bin mir aber nicht ganz sicher.
Ich habe mal ein einfaches beispiel konstruiert:

mein .c File:

typedef struct klassenkammeraden {
  char name;
  int alter;
  int mathenote;  
  int deutschnote;
  type durchschnittsnote; 
} tklassenkammeraden;

typedef void (*tklassenkammeraden) (const struct klassenkameraden *mathenote, char *deutschnote)

mein .c file:

extern const tParamDescription *Jens;
extern const tParamDescription *Achim;

const klassenkammeraden Jens =
{ Schmidt, 16, 3,  5, berechnedurchschnittsnote};

const klassenkammeraden Achim =
{ Maier, 17, 1,  3, berechnedurchschnittsnote};

int berechnedurchschnittsnote(const tklassenkammeraden *mathenote, char *deutschnote)
{
  int durschnitt = 0;
  durchschnitt = (( mathenote + deutschnote) /2)
}
  return durchschnitt;
  
 indieservarsolldiedurschnittsnotevonjensstehen = Jens->durchschnittsnote(mathenote,deutschnote);

ist das so richtig??

[Jürgen (Gast)]

oben das soll das header file sein (zumindest teile daraus) und nich das 
c file

[Jürgen (Gast)]

Jürgen schrieb:
> extern const tParamDescription *Jens;
>
> extern const tParamDescription *Achim;

soll natürlich heißen:

 extern const tklassenkammeraden *Jens; 
 extern const tklassenkammeraden *Achim;

[Yalu X. (yalu) (Moderator)]

Jürgen schrieb:
> ist das so richtig??

Nein, durch die erneute Namensänderungen ist jetzt fast alles falsch,
was man falsch machen kann.

Wenn du die Namen unbedingt ändern musst, mach es wenigstens mit
Search/Replace und schau, ob der Compiler das Ergebnis noch ohne
Fehlermeldungen und Warnungen annimmt.

[Jürgen (Gast)]

ich habe das leider im Texteditor gemacht. da ich auf meinem Rechner 
keinen compiler installiert habe.

[Jürgen (Gast)]

Yalu X. schrieb:
> Nein, durch die erneute Namensänderungen ist jetzt fast alles falsch,
>
> was man falsch machen kann.

das ist bitter, ich versuche mal die sachen runterzuladen.

[Karl H. (kbuchegg)]

Dein Beispiel ist reichlich sinnlos. Es bringt auch nichts, wenn du 
extrem lange Namen für ein Beispiel wählst. Wenn dir gar nichts anderes 
einfällt, dann benutze für ein Beispiel die Situation "Auto" oder 
"Haustiere". Das funktioniert meistens recht gut.

// Datentyp für den Funktionspointer erzeugen
sruct Hund;
tpydef void (*Aktion) (struct Hund* dog);

// Ein Hund hat einen Namen und als Funktionspointer verknuepft
// eine Funktion die aufgerufen werden kann, wenn der Hund jemanden
// begruessen soll
struct Hund
{
  char*  Name;
  Aktion Begruessung;
}

//
// Hier sind die möglichen Begruessungsaktionen. Jeweils als
// Funktion implementiert
//
void wedeln( struct Hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung wedele ich mit dem Schwanz\n", dog->Name );
}

void hochSpringen( struct Hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung springe ich an dir hoch\n" dog->Name );
}

//
// Und dann gibt es noch 2 Hunde
// Sie haben jeweils unterschiedliche Namen und ihre Begruessungsaktionen
// sind verschiedene
//
struct Hund Fifi   = { "Fifi", wedeln };
struct Hund Brutus = { "Brutus", hochSpringen );


int main()
{
  // Beide Hunde sollen mal eine Begruessung machen

  // das kann jetzt so aussehen ...
  wedeln( &Fifi );
  hochSpringen( &Brutus );
  // .. aber dazu hat der Programmierer das Wissen benutzt, das
  // Fifi mit dem Schwanz wedelt und Brutus hochspringt. Diese
  // 'Verknuepfung' des Verhaltens ist an dieser Stelle direkt
  // im Programmcode enthalten.

  // genau das wollen wir aber manchmal nicht. Fifi soll selber
  // wissen, dass er mit dem Schwanz zu wedeln hat. Das weiß er auch.
  // Er weiß es in Form seines Funktionspointers, der zur Funktion
  // führt, die die Begruessung macht.
  // Also ....
  Fifi.Begruessung( &Fifi );
  Brutus.Begruessung( &Brutus );

  //
  // Soweit so gut. Interessant wird das ganze nämlich dann, wenn
  // im Code gar nicht mehr bekannt ist, um welchen Hund es sich
  // handelt.
  // Existiert nur ein Pointer auf irgendeinen Hund ....
  struct Hund* Koeter;

  // ... und zeigt dieser Pointer 'zufällig' auf Fifi ...
  Koeter = &Fifi;

  // ... dann wird ueber den Funktionspointer die jeweils
  // richtige Funktion ....
  Koeter->Begruessung( Koeter );

  // ... aufgerufen

  // und natuerlich auch, wenn dieser 'irgendein Hund' der andere
  // Hund ist.
  Koeter = &Brutus;
  Koeter->Begruessung( Koeter );

  // Man beachte: Der Funktionsaufruf ist in beiden Fällen syntaktisch
  // derselbe!
  // Koeter->Begruessung( Koeter );
  // und trotzdem wird je nachdem um welchen Hund es sich handelt, die
  // jeweils richtige Funktion aufgerufen. In der jeweiligen Objektinstanz
  // selber ist in Form eines Funktionspointers abgelegt, welche das ist.
  // Die Daten selber steuern die Programmausführung und nicht mehr
  // der Programmierer hat zur Entwicklungszeit festgelegt, welche Funktion
  // konkret aufzurufen ist.
  // D.h. er hat es schon festgelegt. So ein Programm kann ja auch nicht
  // zaubern. Aber er hat es hier
  //   struct Hund Fifi   = { "Fifi", wedeln };
  //   struct Hund Brutus = { "Brutus", hochSpringen );
  // an einer Stelle zentral festgelegt. Hier an dieser Stelle wurde
  // fuer jeden Hund seine Eigenschaften festgelegt. Nicht mehr quer
  // uber das Programm verstreut, sondern an einer Stelle zentral.
  //
  // Und wenn man diesen Gedanken weiterführt, noch ein paar Details ergänzt
  // dann führt dieser Gedankengang unmittelbar zu dem was man 'Objektorientierte
  // Programmierung" nennt.
}

[Jürgen (Gast)]

1000 Dank für eure Mühen. Ich analysiere das Programm mal und wenn noch 
fragen da sind, melde ich mich nochmal.

[Jürgen (Gast)]

Tatsächlich ist noch eine frage aufgekommen.

Was ich überhaupt nicht verstehe ist folgendes:

typedef struct Member {
  uchar name;
  uchar visits;  
} tMember;

extern const tMember membernumber;

Also wenn ich mehrere Member anlege, dtelle ich mir vor das für jeden 
Member Speicherplatz für den Namen und die Anzahl der Besuche festgelegt 
wird.
Was mach aber die Mitgliedsnummer? was ist der unterschied zu:

[c]
typedef struct Member {
  uchar name;
  uchar visits;
  int membernumber
} tMember;

[AVerr (Gast)]

membernumber ist eine Variable vom Typ tMember.

Mit

typedef struct Member {
  uchar name;
  uchar visits;  
} tMember;

wurde der Typ tMember definiert.

const tMember membernumber;

definiert eine Variable namens membernumber vom Typ tMember, also hat 
membernumber die Member name und visits.
Das Keyword extern besagt in dem Falle nur, dass membernumber in einer 
anderen Datei definiert wurde und in dieser Datei auch benutzt wird.

[AVerr (Gast)]

PS: membernumber ist ein ziemlich schlecht gewähler Name, da sich 
dahinter keine einfache Anzahl von Membern verbirgt.

[Jürgen (Gast)]

DAnke. Den namen muss ich dan wirklich noch ändern.
So habe die (vorerst) letzte Frage:

extern const tMember* const  list[];

hier wird ein array erzeugt, in dem alle Member stehen? Auch 
membernumber ? Kann ich tMember erzeugen die nicht in diesem array 
stehen?

Hups, jetzt sind es doch Fragen geworden.

[Karl H. (kbuchegg)]

Jürgen schrieb:
> DAnke. Den namen muss ich dan wirklich noch ändern.
> So habe die (vorerst) letzte Frage:
>
>

> extern const tMember* const  list[];
>

>
> hier wird ein array erzeugt, in dem alle Member stehen?

Nein.
Lies die Deklaration. In diesem Array stehen keine Member, sondern in 
diesem Array sind Pointer enthalten, die auf Objekte vom Typ tMember 
zeigen können.

(Ich lass die const erst mal weg um dich nicht zu verwirren)

   
                 list         list ist
                 list[]       list ist ein Array
               * list[]       list ist ein Array von Pointern
       tMember * list[]       list ist ein Array von Pointern, wobei
                              jeder Pointer auf ein tMember zeigen kann
extern tMember * list[]       list ist ein Array von Pointern, wobei
                              jeder Pointer auf ein tMember zeigen kann
                              und dieses Array wird nicht hier erzeugt,
                              sondern existiert irgendwo anders im
                              Program

Immer schon mit der rechts/links Regel beim Variablennamen anfangen und 
sich nach aussen durcharbeiten.

> Auch
> membernumber ?

Wenn da irgendjemand mal die Adresse von membernumber ins Array eintägt 
dann steht der drinnen. Wenn nicht, dann nicht.
Technisch möglich ist es. Denn in list werden die Speicheradressen von 
tMember Objekten abgelegt. membernumber ist ein tMember Objekt. Also 
kann man seine Speicheradresse in diesem Array ablegen.

> Kann ich tMember erzeugen die nicht in diesem array
> stehen?

In dem Array sind überhaupt keine Member enthalten, sondern nur Pointer 
auf  tMember Objekte. Wo auch immer die erzeugt wurden und welcher Code 
auch immer diese ins Array eingetragen hat.

Analogie:
Dieses Array entspricht dem Schlagwortkatalog in einer Bibliothek. Die 
Bücher stehen irgendwo in den heiligen Hallen in einem Regal. IM Katalog 
gibt es für jedes Buch ein Kärtchen, auf dem steht: "Kernighan&Ritchi 
findet sich in Gang A, Regal 5, 6. Buch von links". Das ist das, was 
dein list Array machen kann: Einen Verweis zu geben, wo das tatsächliche 
Buch zu finden ist (und das du dir ausborgen solltest). Aber im 
Schlagwortkatalog sind NICHT die Bücher selber eingelagert.

[Jürgen (Gast)]

ICH SAG EUCH BESSER NICHT WAS ICH MIR VORGESTELLT HABE WAS DAS IST

[Karl H. (kbuchegg)]

:-)
Ich kanns mir schon denken.

Du solltest den Hinweis im Bücherei-Beispiel ernst nehmen. Ich hab nicht 
ohne Grund dieses Buch ausgewählt.

[Jürgen (Gast)]

Karl Heinz Buchegger schrieb:
> Du solltest den Hinweis im Bücherei-Beispiel ernst nehmen. Ich hab nicht
>
> ohne Grund dieses Buch ausgewählt.

Sorry, verstehe ich nicht.

Mir ist aber noch eine Ungereimtheit aufgefallen:

Laut http://c-buch.sommergut.de/Kapitel13/Strukturen.shtml ist ...

struct{
  char szName[30];
  char szVorname[30];
  unsigned long ulTel;
  unsigned long ulPlz;
  } Kunde, Lieferant;

////////////////////////////////////////////////
struct adresse{
  char szName[30];
  char szVorname[30];
  unsigned long ulTel;
  unsigned long ulPlz;
  };

struct adresse Kunde, Lieferant;

... das (annähernd) Selbe.

AVerr schrieb:
> Mittypedef struct Member {
>
>   uchar name;
>
>   uchar visits;
>
> } tMember;
>
>
>
> wurde der Typ tMember definiert.const tMember membernumber;
>
>
>
> definiert eine Variable namens membernumber vom Typ tMember, also hat
>
> membernumber die Member name und visits.
>
> Das Keyword extern besagt in dem Falle nur, dass membernumber in einer
>
> anderen Datei definiert wurde und in dieser Datei auch benutzt wird.

das passt aber hiermit nicht zusammen. oder?

[Jürgen (Gast)]

Jürgen schrieb:
> Karl Heinz Buchegger schrieb:
>
>> Du solltest den Hinweis im Bücherei-Beispiel ernst nehmen. Ich hab nicht
>
>>
>
>> ohne Grund dieses Buch ausgewählt.
>
>
>
> Sorry, verstehe ich nicht.

hat sich erledigt. Halbschlaf ;-)

[Karl H. (kbuchegg)]

Jürgen schrieb:

> ... das (annähernd) Selbe.

Fast.
Das eine mal hat die Struktur einen Namen (und kann damit auch an 
anderen Stellen verwendet werden), das andere mal hat die Struktur 
keinen Namen. Da werden dann einfach 2 Variablen von diesem Typ erzeugt 
und das wars. Die STruktur kann abgesehen von diesen 2 Variablen 
nirgends anders mehr benutzt werden - weil sie ja keinen Namen hat mit 
dem man sie ansprechen könnte.

> das passt aber hiermit nicht zusammen. oder?

Das hat damit überhaupt nichts zu tun. Völlig andere Baustelle.


Bücherei:
Kernighan&Richtie
Programmieren in C

[Jürgen (Gast)]

Wie völlig andere Baustelle? Das ist doch das Selbe, oder nicht?

[Jürgen (Gast)]

Karl Heinz Buchegger schrieb:
> Bücherei:
>
> Kernighan&Richtie
>
> Programmieren in C

liegt hier neben mir

[AVerr (Gast)]

Jürgen schrieb:
> Wie völlig andere Baustelle? Das ist doch das Selbe, oder nicht?

Jürgen schrieb:
> Karl Heinz Buchegger schrieb:
>> Bücherei:
>> Kernighan&Richtie
>> Programmieren in C
> liegt hier neben mir

In dem Buch gibt es bestimmt einen Abschnitt über Structs und Typen ( 
Stichwort typedef ).

Ich kann mir schon denken, wo dein Problem liegt.
Wenn du so ein Struct siehst:

struct {
  int data;
} structVar

dann ist es auch richtig, dass structVar eine Variable ist, die diese 
Struktur erfüllt, du also auf das int structVar.data zugreifen kannst.
structVar hat in dem Fall einen konkreten Speicherbereich, in dem data 
gespeichert ist.

Im Falle

typedef struct {
  int data;
} tStruct;

ist tStruct nur der Name eines neuen Datentypen. Es bekommt keinen 
eigenen Speicher zugewiesen.
Du kannst nun aber Variablen dieses Typen erstellen, z.B. mit

tStruct structVar;

Diese structVar ist analog zu der oben, liegt im Speicher, du kannst 
structVar.data verändern.

Nun verstehst du hoffentlich auch, warum es eine komplett andere 
Baustelle ist ... aufgrund des Gebrauchs von typedef.

[Karl H. (kbuchegg)]

Jürgen schrieb:
> Wie völlig andere Baustelle? Das ist doch das Selbe, oder nicht?

WAS ist dasselbe?
Bitte wirf mir nicht Satzfetzen vor und ich darf mir dann raussuchen, 
wovon du eigentlich sprichst.

Die einzige Gemeinsamkeit besteht darin, dass eine Struktur vereinbart 
wird. Das wars aber dann auch schon.
Jetzt kann ich mir aussuchen, ob sich deine Frage über die Gemeinsamkeit 
auf
* den Strukturnamen
* den typedef
* oder den extern
bezieht. Gottlob lautet in den letzten 2 Fällen die Antwort: andere 
Baustelle.

[Martin G (Gast)]

so ich habe versuch das hunde Beispiel zu compilieren um es besser zu 
verstehen.
Leider geht es nicht und ich verstehe nicht warum.

typedef und struct ist einmal falsch geschrieben.

Ich bekomme drei Fehlermeldungen:

void wedeln( struct Hund* dog )

two or more data types in declaration of wedeln
Syntax error before dog

 struct Hund Brutus = { "Brutus", hochSpringen );

syntax error before )

danke für eure Hilfe

[Martin G (Gast)]

schon wieder der schiss mit dem Namen. ich bin Jürgen.

[Rufus Τ. F. (rufus)]

Martin G schrieb:
> schon wieder der schiss mit dem Namen. ich bin Jürgen.

Wir sind hier nicht besonders entzückt über Leute, die sich als mehrere 
unterschiedliche Leute ausgeben müssen.

Gewöhn' Dir das ab. Dringend.

[Martin G (Gast)]

Das macht ja gar keinen Sinn. Das eine bin ich das andere mein Bruder. 
Ist doch eh anonym.
Sieht zwar doof aus, das gebe ich zu, aber ich bin ich :-) und mein 
bruder mein Bruder

[Jürgen (Gast)]

so jetzt habe ich es :-)
Sorry

[Rufus Τ. F. (rufus)]

Martin G schrieb:
> Das macht ja gar keinen Sinn.

Doch, das hat sehr wohl einen Sinn, wir wollen hier schon wissen, mit 
welcher Instanz anonymer Benutzer wir es zu tun haben.

Andernfalls könnte ja auch jeder nicht angemeldete Benutzer von der 
Forensoftware als "Gast" bezeichnet werden ... dann haben wir viele 
Threads, in denen sich "Gast" mit "Gast" und "Gast" unterhält. Wenn dann 
noch "Gast", "Gast" und "Gast" dazukommen, wird es fast schon gemütlich.

[Jürgen (Gast)]

Das habe ich nicht gemeint. Es macht aus meiner Sicht keinen Sinn. Es 
gibt ca 10M Jürgens in Deutschland. Wenn ich meine Identität verstecken 
wollte hätte ich mich einfach Jupp genannt.
Aber sei es wie es ist. Ich bin ich und versuche immer oben zu gucken 
wer "eingeloggt" ist, ich oder mein Bruder.

Ich habe versucht mein Problem zu lösen. Habe leider noch kein 
ergebniss. kann mir da jemand helfen?

[Jürgen (Gast)]

So, selber probieren geht über studieren habe ich mit gedacht. Mein 
erstes Programm zum testen von Strukturen funktioniert:

struct hund 
       {
            char* name;
            int gewicht;
       };
       
struct hund Juergenshund   = { "Fifi", 15};
struct hund Sabineshund   = { "Ali", 11 };


int main ()
{
    while(1)
    {
            printf("%s wiegt %i \n", Juergenshund.name, Juergenshund.gewicht);
            printf("%s wiegt : %i \n", Sabineshund.name, Sabineshund.gewicht);        
    }  
}

Aber hier fangen schon die Probleme an. Das akzeptiert der compiler 
schon nicht:

struct hund 
       {
            char* name;
            int gewicht;
       }Michaelshund;
       
struct hund Juergenshund   = { "Fifi", 15};
struct hund Sabineshund   = { "Ali", 11 };

Michaelshund.name = "Bello";
Michaelshund.gewicht = 13;

int main ()
{
    while(1)
    {
            printf("%s wiegt %i \n", Juergenshund.name, Juergenshund.gewicht);
            printf("%s wiegt : %i \n", Sabineshund.name, Sabineshund.gewicht);
            printf("%s wiegt : %i \n", Michaelshund.name, Michaelshund.gewicht);        
    }  
}

und was auch nicht funktioniert ist:

typedef void (*Aktion) (struct hund* dog);

struct hund 
       {
            char* name;
            int gewicht;
            Aktion Begruessung;
       };
       
struct hund Juergenshund   = { "Fifi", 15, wedeln};
struct hund Sabineshund   = { "Ali", 11 , wedeln};

void wedeln( struct hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung wedele ich mit dem Schwanz\n", dog->Name );
}


int main ()
{
    while(1)
    {
            printf("%s wiegt %i \n", Juergenshund.name, Juergenshund.gewicht);
            printf("%s wiegt : %i \n", Sabineshund.name, Sabineshund.gewicht);        
    }  
}

Da wollte ich mal das mit den Funktionen testen. Wo liegen meine Fehler.

[Rufus Τ. F. (rufus)]

> Aber hier fangen schon die Probleme an. Das akzeptiert der compiler
> schon nicht:

struct hund 
       {
            char* name;
            int gewicht;
       }Michaelshund;
       
struct hund Juergenshund   = { "Fifi", 15};
struct hund Sabineshund   = { "Ali", 11 };

Michaelshund.name = "Bello";
Michaelshund.gewicht = 13;

Die beiden Zuweisungen an die Strukturelemente von "Michaelshund" sind 
außerhalb einer Funktion nicht zulässig, im Gegensatz zu den 
Initialisierungen von Juergens- und Sabineshund.

> und was auch nicht funktioniert ist:

typedef void (*Aktion) (struct hund* dog);

struct hund 
       {
            char* name;
            int gewicht;
            Aktion Begruessung;
       };
       
struct hund Juergenshund   = { "Fifi", 15, wedeln};
struct hund Sabineshund   = { "Ali", 11 , wedeln};

void wedeln( struct hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung wedele ich mit dem Schwanz\n", dog->Name );
}

Zum Zeitpunkt der Initialisierung von Juergens- und Sabineshund ist die 
Funktion "wedeln" nicht bekannt. Du musst diese Funktion dem Compiler 
vor der Initialisierung bekanntmachen, entweder mit einem Prototypen 
(einer Deklaration) oder durch das Verschieben der Definition der 
Funktion vor die Initialisierungen.


Beides sind Dinge, die in einem anständigen C-Buch beschrieben werden. 
Den allfälligen Literaturhinweis will ich deswegen nicht weglassen:
Brian Kernighan & Dennis Ritchie, "Programmieren in C", 2. Ausgabe, 
Hanser-Verlag.

Aber auch die Fehlermeldungen des C-Compilers weisen auf diese 
Probleme hin, die gilt es zu lesen und zu verstehen.

[Jürgen (Gast)]

das erste Problem ist gelöst. Danke.
Aber bei dem zweiten habe ich die Funktion verschoben, bekomme es aber 
immer noch nicht compeliert.

typedef void (*Aktion) (struct hund* dog); 

struct hund 
       {
            char* name;
            int gewicht;
            Aktion Begruessung;
       };
      
void wedeln( struct hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung wedele ich mit dem Schwanz\n", dog->Name );
}
       
struct hund Juergenshund   = { "Fifi", 15, wedeln};
struct hund Sabineshund   = { "Ali", 11 , wedeln};



int main ()
{
    while(1)
    {
            printf("%s wiegt %i \n", Juergenshund.name, Juergenshund.gewicht);
            printf("%s wiegt : %i \n", Sabineshund.name, Sabineshund.gewicht);        
    }  
}

Syntax error before Aktion

[Klaus W. (mfgkw)]

Jürgen schrieb:
> Syntax error before Aktion

Das ist nicht die ganze Meldung.
Ich glaube zwar, in welcher Zeile das ist - aber es ist dein Job das zu 
sagen.

Sollen hier alle rumraten, nur weil du zu faul bist, eine vernünftige 
Fehlerbeschreibung zu machen?

[Klaus W. (mfgkw)]

Abgesehen davon lässt du dir hier stückweise erzählen, was in jedem 
C-Buch steht.
Das ist nicht fein.

[Klaus W. (mfgkw)]

Jürgen schrieb:
> Karl Heinz Buchegger schrieb:
>> Bücherei:
>>
>> Kernighan&Richtie
>>
>> Programmieren in C
>
> liegt hier neben mir

Leg es doch mal vor dich, dann kannst du es lesen!

[Jürgen (Gast)]

ich habe das buch ja gelesen; aber leider kann ich es nicht besser.

es geht um diese Zeile:

 Aktion Begruessung;

die Fehlermeldung ist komplet.
danachkommt noch eine Warning: no semicolon at end of struct

[Klaus W. (mfgkw)]

Jürgen schrieb:
> es geht um diese Zeile:
>  Aktion Begruessung;

nein, oder dein Quelltext ist nicht komplett.
Bzw. sollte noch eine Fehlermeldung vorher kommen.

[Jürgen (Gast)]

das einzige was noch vorher kommt ist :

#include <stdio.h>
#include <stdlib.h>

mehr ist wirklich nicht.

[Klaus W. (mfgkw)]

Dann bekomme ich als Fehlermeldung:
t.cpp: In function ‘void wedeln(hund*)’:
t.cpp:15: error: ‘struct hund’ has no member named ‘Name’
t.cpp: At global scope:
t.cpp:18: warning: deprecated conversion from string constant to ‘char*’
t.cpp:19: warning: deprecated conversion from string constant to ‘char*’

(wenn ich es als C++ kompiliere) bzw.:

t.c:4: warning: ‘struct hund’ declared inside parameter list
t.c:4: warning: its scope is only this definition or declaration, which 
is probably not what you want
t.c: In function ‘wedeln’:
t.c:15: error: ‘struct hund’ has no member named ‘Name’
t.c: At top level:
t.c:18: warning: initialization from incompatible pointer type
t.c:19: warning: initialization from incompatible pointer type

als C.

[Karl H. (kbuchegg)]

Martin G schrieb:
> so ich habe versuch das hunde Beispiel zu compilieren um es besser zu
> verstehen.
> Leider geht es nicht und ich verstehe nicht warum.

Weil ich das Beispiel direkt hier im Editor eingetippt habe und mir 
dabei natürlich ein paar Tippfehler unterlaufen sind.

Für jemanden, der sein C zumindest soweit versteht, dass er sich in der 
Lage fühlt mit Funktionspointern rumzumachen, sollten die aber kein 
Problem sein.


> Ich bekomme drei Fehlermeldungen:
>
>

> void wedeln( struct Hund* dog )
>

> two or more data types in declaration of wedeln
> Syntax error before dog

Hier ....

// Ein Hund hat einen Namen und als Funktionspointer verknuepft
// eine Funktion die aufgerufen werden kann, wenn der Hund jemanden
// begruessen soll
struct Hund
{
  char*  Name;
  Aktion Begruessung;
}                <-------------------------------------------

//
// Hier sind die möglichen Begruessungsaktionen. Jeweils als
// Funktion implementiert
//

... fehlt ein ';'

Hier ....
>

>  struct Hund Brutus = { "Brutus", hochSpringen );
>

> syntax error before )
.... hab ich irrtümlich die falsche Klammer benutzt. ) anstelle von }

[Jürgen (Gast)]

typedef void (*Aktion) (struct hund* dog); 

struct hund 
       {
            char* name;
            int gewicht;
            Aktion Begruessung;
       };
      
void wedeln( struct hund* dog )
{
  printf( "Hi, ich bin %s und zur Begruessung wedele ich mit dem Schwanz\n", dog->name );
}
       
struct hund Juergenshund   = { "Fifi", 15, wedeln};
struct hund Sabineshund   = { "Ali", 11 , wedeln};



int main ()
{
    while(1)
    {
            printf("%s wiegt %i \n", Juergenshund.name, Juergenshund.gewicht);
            printf("%s wiegt : %i \n", Sabineshund.name, Sabineshund.gewicht);  
            wedeln( &Juergenshund );                 
    }  
}

So funktioniert es :-)
Mit den richtigen Fehlermeldungen kann man was anfangen. danke

[Jürgen (Gast)]

Karl Heinz Buchegger schrieb:
> Weil ich das Beispiel direkt hier im Editor eingetippt habe und mir
> dabei natürlich ein paar Tippfehler unterlaufen sind.
>
> Für jemanden, der sein C zumindest soweit versteht, dass er sich in der
> Lage fühlt mit Funktionspointern rumzumachen, sollten die aber kein
> Problem sein.

Nicht falsch verstehen. Ich bin dir ultra dankbar.

[Karl H. (kbuchegg)]

Jürgen schrieb:
> Karl Heinz Buchegger schrieb:
>> Weil ich das Beispiel direkt hier im Editor eingetippt habe und mir
>> dabei natürlich ein paar Tippfehler unterlaufen sind.
>>
>> Für jemanden, der sein C zumindest soweit versteht, dass er sich in der
>> Lage fühlt mit Funktionspointern rumzumachen, sollten die aber kein
>> Problem sein.
>
> Nicht falsch verstehen. Ich bin dir ultra dankbar.

OK. Dann war das wohl etwas zu subtil.
Nochmal Klartext: Du bist noch nicht soweit mit Funktionspointern 
rumzumachen. Mach deine Übungen in deinem Buch, arbeite die Kapitel 
durch, wenn dort Übungen angegeben sind, dann mach die, erfinde für dich 
Aufgaben. Lerne die Fehlermeldungen deines Compilers zu lesen. Lerne 
typische Fehlermeldungen und auch, dass sich die Meldung nicht unbedingt 
auf die gemeldete Zeile beziehen muss, sondern auch davor sein kann (und 
nur verschleppt wurde). Lerne wann das der Fall ist und auch wie es dazu 
kommt, dass ein Compiler beschwert, dass zb scheinbar eine Funktion 2 
Returntypen hat.
Und in ein paar Monaten bist du dann soweit, dass du dir den Kopf über 
Funktionspointer zerbrechen kannst.
Zu schnell vorzugehen bringt auch nichts. Ehrgeiz: ja. Aber falscher 
Ehrgeiz ist kontraproduktiv.

[Jürgen (Gast)]

Das she ich ja ähnlich.
Leider bin ich beruflich gezwungen, den kram sofort zu verstehen. ich 
würde auch lieber langsam machen.

[Klaus W. (mfgkw)]

Dann hast du zu spät damit angefangen :-)