Übergabe einer Struktur

[Renn]

Hallo!

Ich habe hier mal ein kleines Prog. wo mir an einigen Stellen der Code noch nicht so richtig einleuchtet. Vielleicht könnt ihr mit das ja erklären.

#include <string> 
#include <conio.h>
#include <iostream>
#include <iomanip.h>
using namespace std;

struct styp { int nr;
              double wert;
            };

void cystruct (styp x, styp *y);

int main()
{   styp a={1, 111.1}, b={2, 999.9};

    cout <<"\nvor dem Funktionsaufruf: ";
    cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert;
    cout <<"\nb-Struktur Nr=" <<b.nr <<" Wert=" <<b.wert;

    cystruct (a,&b);

    cout <<"\n\nnach dem Funktionsaufruf: ";
    cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert; 
    cout <<"\nb-Struktur Nr=" <<b.nr <<" Wert=" <<b.wert;        

    getch();
}

void cystruct (styp x, styp *y)
{    cout <<"\n\nin der Funktion: ";
     y->nr=x.nr;
     y->wert=x.wert;
     cout <<"\nb-Struktur Nr=" <<y->nr <<" Wert=" <<y->wert;
}

1. Was beudeutet folgendes

styp a={1, 111.1}, b={2, 999.9};

eigentlich nur das, was in den Klammern steht. Ist das eine Art Array?

cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert;

. Woher weis das Prog, das 'a.nr' die 1 und zu 'a.wert' die 111.1 zugeteilt wird u. nicht zu Bsp umgekehrt? Liegt das an der Reihenfolge?

3. Was passiert hier eigentlich

y->nr=x.nr;

y->wert=x.wert;

Mir ist klar, das in "y" die Werte von "x" geschrieben werden und über die Adresse auf die Variable "b" zugegriffen wird und die Werte letzlich von "a" in "b" geschrieben werden. Nur die Art mit dem -> (Pfeil) kenne ich nicht. Geht das auch anders oder kann man das nur so machen bzw. in welchen Fällen muss man sogar über diese Weise arbeiten. Müsste das nicht eigentlich auch *y->nr=x.nr; also mit dem * davor sein?

Wäre nett, wenn mir einer von euch da mal erklären kann.

Vielen Dank
Renn

[shapeless]

Renn schrieb:

Hallo!

Ich habe hier mal ein kleines Prog. wo mir an einigen Stellen der Code noch nicht so richtig einleuchtet. Vielleicht könnt ihr mit das ja erklären.

#include <string> 
#include <conio.h>
#include <iostream>
#include <iomanip.h>
using namespace std;

struct styp { int nr;
              double wert;
            };

void cystruct (styp x, styp *y);
            
int main()
{   styp a={1, 111.1}, b={2, 999.9}; // struktur a werden für nur 1 und für wert 111.1 zu gewiesen
// b bekommt 2 und 999.9

    cout <<"\nvor dem Funktionsaufruf: ";
    cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert;
// wir geben den wer von a.nr aus (oben zugewiesen) und den von a.wert 
    cout <<"\nb-Struktur Nr=" <<b.nr <<" Wert=" <<b.wert;
//das gleiche nur für b
    
    cystruct (a,&b);// b bekommt neue werte --siehe unten
    
    cout <<"\n\nnach dem Funktionsaufruf: ";
    cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert;// ausgabe
    cout <<"\nb-Struktur Nr=" <<b.nr <<" Wert=" <<b.wert;//ausgabe
//siehe oben nur diesmal sind die werte gleich
    getch();
}

void cystruct (styp x, styp *y)
{    cout <<"\n\nin der Funktion: ";
     y->nr=x.nr;// -> verweist auf b.nr welches den wert von x.nr(a.nr) bekommt 
     y->wert=x.wert;//siehr oben
     cout <<"\nb-Struktur Nr=" <<y->nr <<" Wert=" <<y->wert;
//ausgabe con b.nr und b.wert / welche ja y->nr und y->wert sind
// alles in allem werden die werte von struct b mit denen von a "überschrieben" 
//folglich haben beide nach dem aufruf die gleichen werte für nr und wert
}

1. Was beudeutet folgendes

styp a={1, 111.1}, b={2, 999.9};

eigentlich nur das, was in den Klammern steht. Ist das eine Art Array?
// es werden den membern der struktur die werte in den {} zugewiesen

cout <<"\na-Struktur Nr=" <<a.nr <<" Wert=" <<a.wert;

. Woher weis das Prog, das 'a.nr' die 1 und zu 'a.wert' die 111.1 zugeteilt wird u. nicht zu Bsp umgekehrt? Liegt das an der Reihenfolge?
// weil wir die werte zugewiesen haben

3. Was passiert hier eigentlich

y->nr=x.nr;

y->wert=x.wert;

//dem nr der struktur auf die y zeigt wird der wert von x.nr zugewiesen

Nur die Art mit dem -> (Pfeil) kenne ich nicht.
//wenn man einen zeiger auf eine struct /class hat ruft man sieh mit -> auf //eigentlich ists nur eine vereinfachung der schreibweise (*y).nr alsem ruft man //den member nr des wertes (*-operator) der adresse von y auf

*y->nr=x.nr; also mit dem * davor sein?
// nein siehe oben

[Renn]

Danke