Frage zur Wertübergabe an eine Funktion bei Strukturen

[S. L. (lonci)]

Hallo!
Ich möchte mir eine "RTC" programmieren und übergebe an die Funktion 
leap_year die Adresse des Strukturelements year.

Meine Frage: Warum muss meine Pointervariable *year_ptr vom Datentyp 
unsigned int sein? Der Datentyp der Strukturelemente ist doch eigentlich 
RTC oder?

#include <avr/io.h>

typedef struct
{
  unsigned int second;    // value of the actual second
  unsigned int minute;    // value of the actual minute
  unsigned int hour;      // value of the actual hour
  unsigned int monthDay;    // value of the actual day in the month
  unsigned int month;      // value of the actual month
  unsigned int year;      // value of the actual year
}RTC;              // Datatype = RTC

/*** Funktion Schaltjahr berechnen. (Parameterübergabe call by reference) ***/
int check_leapyear (unsigned int *year_ptr)
{
  unsigned int year_value = *year_ptr;
  
  if ( (year_value % 4 == 0 && year_value % 100 != 0) || (year_value % 400 == 0) )
    return 29;
}

RTC time, date;          // Deklaration der Variablen time und date vom Datentyp RTC
int x, schaltjahr = 0;

int main(void)
{
  time.second    = 0;    // Initialisierungswert = 0
  time.minute    = 0;    // Initialisierungswert = 0
  time.hour    = 0;    // Initialisierungswert = 0
  date.monthDay  = 1;    // Initialisierungswert = 1 (1 = Montag)
  date.month    = 1;    // Initialisierungswert = 1 (1 = Jänner)
  date.year    = 2016;    // Initialisierungswert = 2016
  
  while(1)
  {
    if ( (x = check_leapyear(&date.year)) == 29 )  // Parameterübergabe = Adresse des Strukturelements year
      schaltjahr = 1;    // Ein Schaltjahr wurde erkannt
    else
      schaltjahr = 0;    // Kein Schaltjahr
  }
}

[Rufus Τ. F. (rufus)]

S. Lonci schrieb:
> Meine Frage: Warum muss meine Pointervariable *year_ptr vom Datentyp
> unsigned int sein?

Weil das der Datentyp des Strukturelements ist:

>   unsigned int year;      // value of the actual year


> Der Datentyp der Strukturelemente ist doch eigentlich
> RTC oder?

Nein. Das ist der Datentyp der gesamten Struktur, nicht aber ihrer 
Elemente.

Hast Du schon mal einen Blick in ein C-Buch geworfen?

[S. L. (lonci)]

Rufus Τ. Firefly schrieb:
> S. Lonci schrieb:
>> Meine Frage: Warum muss meine Pointervariable *year_ptr vom Datentyp
>> unsigned int sein?
>
> Weil das der Datentyp des Strukturelements ist:
>
>>   unsigned int year;      // value of the actual year
>
>
>> Der Datentyp der Strukturelemente ist doch eigentlich
>> RTC oder?
>
> Nein. Das ist der Datentyp der gesamten Struktur, nicht aber ihrer
> Elemente.

ja, dass klingt jetzt logisch! Danke für den Hinweis!

> Hast Du schon mal einen Blick in ein C-Buch geworfen?

Würde denn ein Blick in ein C-Buch dieses wunderbare Forum ersetzen? ;-)

[San L. (zwillingsfreunde)]

S. Lonci schrieb:
> Würde denn ein Blick in ein C-Buch dieses wunderbare Forum ersetzen? ;-)

Nein, aber viele unnötige/extrem simple Fragen.

[S. L. (lonci)]

San Lue schrieb:
> S. Lonci schrieb:
>> Würde denn ein Blick in ein C-Buch dieses wunderbare Forum ersetzen? ;-)
>
> Nein, aber viele unnötige/extrem simple Fragen.

unnötig für wen?
Strukturen und Pointer sind extrem simple? Klar, damit beginnt jeder der 
lernt C zu programmieren! ;-)
Aber da haben wohl die "Profis" andere Ansichten!

[foobar (Gast)]

int check_leapyear (unsigned int *year_ptr)
{
  unsigned int year_value = *year_ptr;
  
  if ( (year_value % 4 == 0 && year_value % 100 != 0) || (year_value % 400 == 0) )
    return 29;
}

Sollte man nicht der Form halber noch irgendwo definieren was die 
Funktion zurückgibt wenn die Bedingung nicht erfüllt ist?

Außerdem halte ich den Rückgabewert 29 für nicht sehr glücklich gewählt 
wenn die Funktion check_leapyear heißt, aber das ist vielleicht 
Geschmackssache...

[Rufus Τ. F. (rufus)]

foobar schrieb:
> Sollte man nicht der Form halber noch irgendwo definieren was die
> Funktion zurückgibt wenn die Bedingung nicht erfüllt ist?

Da sollte eigentlich der Compiler eine Fehlermeldung ausgeben, à la "not 
all control paths return a value".

[Peter II (Gast)]

dann könnte man ja gleich fragen warum ein Pointer übergeben wird und 
dann gleich eine Kopie gemacht wird

int check_leapyear (unsigned int *year_ptr)
{
  unsigned int year_value = *year_ptr;

da kann man gleich

int check_leapyear (unsigned int year_value)

schreiben.

[S. L. (lonci)]

Peter II schrieb:
> dann könnte man ja gleich fragen warum ein Pointer übergeben wird und
> dann gleich eine Kopie gemacht wird
>
>

> int check_leapyear (unsigned int *year_ptr)
> {
>   unsigned int year_value = *year_ptr;
>

Ich muss mit dem Wert rechnen...das geht mit der Pointervariablen aber 
nicht!

if ( (year_value % 4 == 0 && year_value % 100 != 0) || (year_value % 400 == 0) )
    return 29;

> da kann man gleich
>
>

> int check_leapyear (unsigned int year_value)
>

>
> schreiben.

Ja, kann man. Das verbraucht aber Speicher! Und ich persönlich finde es 
per Pointer einfach eleganter.

[Peter II (Gast)]

S. Lonci schrieb:
> Ich muss mit dem Wert rechnen...das geht mit der Pointervariablen aber
> nicht!

warum sollte man damit nicht rechnen können?

if ( (*year_value % 4 == 0 && *year_value % 100 != 0) || (*year_value % 400 == 0) )
    return 29;

> Ja, kann man. Das verbraucht aber Speicher!
nein, es braucht weniger Speicher als deine Lösung. du braucht extra 
noch 2 Byte auf dem Stack.

> Und ich persönlich finde es per Pointer einfach eleganter.
ich nicht, dann kann man nicht erkennen ob jemand den wert ändert.

[Karl H. (kbuchegg)]

S. Lonci schrieb:

> Ich muss mit dem Wert rechnen...das geht mit der Pointervariablen aber
> nicht!

Könnte man genausogut. Aber eigentlich geht das am Kern der Frage 
vorbei. Denn der lautet: Wozu überhaupt der Pointer? Den braucht doch 
keiner.

Benutze keine Pointer, wenn du nicht musst!

> Ja, kann man. Das verbraucht aber Speicher!

Und deine lokale Variable verbraucht keinen Speicher?
Tatsächlich braucht deine Lösung sogar noch mehr Speicher. Denn in 
deiner Version muss für die vom Aufrufer übergebene Adresse eine lokale 
Pointer Variable eingerichtet werden, in die der Adresswert kopiert 
wird. Und das dann noch zusätzlich zum unsigned int, der dann den Wert 
kriegt.

> Und ich persönlich finde es
> per Pointer einfach eleganter.

Das ist nicht nicht mal Ansichtssache. So wie geschrieben ist das die 
uneleganteste Form.

Die Peter II Version kann ich auch in dieser Form benutzen

   Tage = check_leapyear( 2025 );

um die Anzahl der Tage im Februar des Jahres 2025 feststellen zu lassen. 
Bei deiner Version geht das nicht. Da brauch ich erst mal etwas, dessen 
Adresse ich bestimmen kann

  unsigned int checkYear = 2025;
   Tage = check_leapyear( &checkYear );

Elegant ist das nicht gerade.

Benutze Pointer dann, wenn du Pointer benutzen musst! Aber nicht einfach 
so. Diese Version braucht keinen Pointer als Argument. Die Funktion ist 
vollkommen zufrieden, wenn sie eine Jahreszahl bekommt, die sie 
überprüfen soll. Mehr braucht sie nicht. Also mach auch nicht mehr 
draus.

Pointer als Funktionsargument brauchst du, wenn die Funktion in der Lage 
sein soll, auf eine oder mehrere Variablen des Aufrufers schreibend 
zuzugreifen. Pointer brauchst du, wenn du einer Funktion ein komplettes 
Strukturobjekt zur Verfügung stellst und du die Kosten zur Erzeugung 
einer Kopie des Strukturobjektes nicht tragen willst oder kannst. In 
allen andern Fällen brauchst du an dieser Stelle keinen Pointer.

[Karl H. (kbuchegg)]

Wenn wir schon über Speicherverbrauch reden

typedef struct
{
  unsigned int second;    // value of the actual second

ein unsigned int, also etwas mit einem Wertebereich von 0 bis 65535 
(weil 16 BIt), um einen Wert zu speichern, der sich immer im Bereich 0 
bis 59 abspielen wird, also locker in 8 Bit (= 1 Byte) untergebracht 
werden kann?
Das nenn ich mal sinnlose Speicherverschwendung.