Resource icon

Kleines Kalenderprogramm in QT 2019-05-07

No permission to download
Programmiersprache(n)
C++, Qt
Betriebssystem(e)
Linux
Hallo Leute!

Habt Ihr euch eigentlich schon mal gefragt, an welchen Wochentag Ihr geboren wurdet? Dieses Kleine Programm in QT geschrieben berechnet euch das. So was kann einem zum Verhängnis werden!

Zuerst einmal etwas Geschichte:
Auf dem Konzil von Nicäa (325 n. Chr.) wurde festgelegt, dass Ostern immer auf den Sonntag nach dem ersten Frühlingsvollmond fällt. Da die Dauer eines Jahres kein Vielfaches der Dauer eines Mondumlaufs um die Erde ist, wird Ostern zu einem beweglichen Fest zwischen dem 22. März und 25. April eines jeden Jahres. Weitere kirchliche Feiertage leiten sich aus dem Ostersonntag ab. So ist Aschermittwoch 46 Tage vor Ostersonntag. Christi Himmelfahrt ist 39 Tage, Pfingstsonntag 49 Tage und Fronleichnam 60 Tage nach Ostersonntag. Der Dreifaltigkeits(sonn)tag ist der 1te Sonntag nach dem Pfingstsonntag Diese Regeln gelten bis heute! Zu Beachten ist allerdings: Die Vollmondrechnung für Ostern basiert auf einer kirchlichen Vollmondrechnung und nicht auf der astronomischen Vollmondrechnung!

Warum ist Ostern ein beweglicher Feiertag?

Zur Zeit der Kreuzigung Jesu wurde im Judentum ein lunisolarer Kalender zur Festlegung der Feiertage herangezogen, der sich in erster Linie an den Mondphasen orientierte. Heute gilt der solare gregorianische Kalender, der sich durch das Sonnenjahr definiert. Da Mondphasen (Lunationen) und Sonnenjahre unterschiedliche und gegenseitig unvereinbare Zeitspannen vorgeben – das Sonnenjahr als Zeitspanne ist nicht restlos durch eine Anzahl von Lunationen teilbar – fällt ein bestimmtes Datum in einem Kalendersystem auf ein immer anderes Datum im anderen Kalendersystem.

Pessach (auch: Pascha) beginnt am 15. Tag des Monats Nisan, des ersten Monats im Hebräischen Kalender, und dauert sieben oder acht Tage. Im Gregorianischen Kalender fällt das Fest meist in den April. Zu diesem Anlass gedenken Juden der Befreiung der Israeliten aus der Sklaverei und des Auszuges des Volkes aus Ägypten vor etwa 3000 Jahren.

Die Umstellung vom julianischen zum gregorianischen Kalender fand 1582 statt. Eine päpstliche Anordnung legte das wie fest. Um euch etwas Sucherei im Web zu ersparen folgendes:
Die Bulle dekretierte, dass zehn Tage (5. bis einschließlich 14. Oktober 1582) zu entfallen haben und dass der Tag, der auf den 4. Oktober folge, als der 15. Oktober 1582 gezählt werden solle. An diesem und den folgenden Tagen seien auch etliche Heiligenfeste nachzufeiern, nach dem 17. Oktober jedoch alles wieder wie bisher. Auf diese Weise werde im Jahre 1583 das Frühjahrsäquinoktium wieder auf den 21. März fallen.
Wenn euch also jemand erzählt das an einem Tag zwischen den 5ten und 14ten Oktober 1582 etwas bedeutsames stattgefunden habe, der hat euch einen Bären aufgebunden.

Um den Kalender stabil zu halten, legte die Bulle fest, dass wie bisher alle vier Jahre ein Schaltjahr gehalten werden solle, auch im Jahr 1600, dann aber von jeweils vier folgenden Säkularjahren immer nur das letzte (1700, 1800 und 1900 nicht, dafür 2000 wieder, und so weiter).

Die eigentliche Ermittlung des Osterdatums solle sich ab 1583 nicht mehr nach der Goldenen Zahl, sondern nach dem neu eingeführten, auf der Goldenen Zahl basierenden Zyklus der Epakten richten. Da die Folge der Wochentage beibehalten wurde, fiel der auf Donnerstag, den 4. Oktober, folgende 15. Oktober auf einen Freitag, nicht auf einen Montag.
Damit ging einher, dass der Sonntagsbuchstabe von G auf C wechselte.
Bemerkt sei nur, dass der daselbst verzeichnete 21. März niemals Ostertag sein kann.

Vor dem gregorianischen Kalender galt der julianische Kalender, den Julius Cäsar 45 v.Chr. einführte.
Eine Kalenderreform war dringend notwendig geworden, da mittlerweile der Januar etwa 80 Tage zu früh begann und damit in den Herbst fiel. Julius Cäsar beauftragte deshalb den alexandrinischen Astronomen Sosigenes mit der Ausarbeitung eines neuen Kalenders. Nach dem Vorbild des ägyptischen Kalenders wurde der julianische Kalender ein reiner Sonnenkalender. Sosigenes schlug Cäsar eine Schaltjahresregel vor. Auf Anordnung Cäsars wurde dann das Jahr 46 v.Chr. auf 445 Tage verlängert, um die Monate wieder mit den Jahreszeiten abzustimmen und 45 v.Chr. war dann das erste Schaltjahr. Mit diesem Kalender wurde zum ersten Mal eine periodische Schaltjahresregel eingeführt. Jedes vierte Schaltjahr sollte ein Schaltjahr sein. Das war für die damalige Zeit eine äußerst genaue Regel. Es dauerte etwa 1600 Jahre bis sich der Fehler des julianischen Kalenders auf die 11 Tage aufaddierte, die dann bei der Einführung des gregorianischen Kalenders übersprungen wurden. Als Cäsar 44 v.Chr. starb wurde zwar ihm zu Ehren der römische
Monat "quintilis" in "iulius" umbenannt, daher unser Monatsname Juli, doch die Schaltjahresregel wurde falsch angewandt und jedes dritte Jahr zum Schaltjahr erklärt. Kaiser Augustus erkannte und korrigierte diesen Fehler, in dem er ab dem Jahre 8 v.Chr. für 12 Jahre keine Schaltjahre mehr zuließ. Zu Ehren von Augustus wurde nun der sechste Monat des römischen Kalenders, der "sextilis" in "augustus" umbenannt, daher unser Monatsname August. Damit ergeben sich ab dem Jahre 45 v.Chr. folgende Jahre als Schaltjahre :

-45 -42 -39 -36 -33 -30 -27 -24 -21 -18 -15 -12 -9




Anwendungs-Beispiel dieses Programms:
Als ich in der Zeit meiner Umschulung im Osterurlaub als Fußgänger angefahren wurde und einen Bruch des Felsenbeins erlitt(vertikal UND horizontal!!), inklusive Ertaubung linksseitig mit Verlust des Gleichgewichtsorganes, teilamputierter Zeigefinger rechts, Lappenplastik linke Hand(wege multiresistenter staphylococcus Edidermidis, nun teilweise Steif) , mit Osteochondritis im Knie und Gonathrose, sowie Teilablösung der Netzhaut am Auge, reichte ich bei der Deutschen Rentenversicherung meinen Rentenantrag ein. Dabei hatte ich versehentlich den Tag der mündlichen Prüfung zum Gesellenbrief als Dreher nicht richtig angegeben(klar, nach 27Jahren, wie soll man das dann noch Wissen?). Der Antrag wurde übrigens abgelehnt.
Einer Bekannten wurde die Frage gestellt, warum diese 1983(!!!!!) ihre Lehre als Damenschneiderin drei Tage vor den im Lehrvertrag stehenden Termin antrat(war so eine Art Probearbeit).
Damit euch das oder ähnliches nicht passiert, dieses Programm.

Zuerst muss aber festgestellt werden, ob das Jahr des gesuchten Datums ein Schaltjahr war oder nicht:
Code:
int Schaltjahr(int jhr)
{
/*
* Wenn Jahreszahl ohne Rest durch Vier teilbar ist,
* ist die Jahreszahl ein Schaltjahre.
* Ausnahme1:
* Wenn die Jahreszahl außerdem durch 100 teilbar ist, dann
* liegt kein Schaltjahr vor(sp=0).
* Ausnahme von der Ausnahme1:
* Wenn die Jahreszahl durch 400 teilbar ist, liegt doch
* ein Schaltjahr vor(sp=1).
*/
int dsp, s1, s2, s3;
dsp = 0;
s1 = jhr % 4;
s2 = jhr % 400;
s3 = jhr % 100;

if ((s1 == 0) || (s2 == 0))  dsp = 1;
if ((s2 != 0) && (s3 == 0))  dsp = 0;

return dsp;
}

int Kalender::leapyear(void)
{
/*
* Wenn Jahreszahl ohne Rest durch Vier teilbar ist,
* ist die Jahreszahl ein Schaltjahre.
* Ausnahme1:
* Wenn die Jahreszahl außerdem durch 100 teilbar ist, dann
* liegt kein Schaltjahr vor(sp=0).
* Ausnahme von der Ausnahme1:
* Wenn die Jahreszahl durch 400 teilbar ist, liegt doch
* ein Schaltjahr vor(sp=1).
*/
int dsp, s1, s2, s3;
dsp = 0;
s1 = jahr % 4;
s2 = jahr % 400;
s3 = jahr % 100;

if ((s1 == 0) || (s2 == 0))  dsp = 1;
if ((s2 != 0) && (s3 == 0))  dsp = 0;


sjahr = dsp;
return dsp;
}
Erstere Funktion für allgemeine Anwendungen, leapyear für c++ und QT.

Bevor ich auf den Algorithmus von Gauss gestoßen bin, habe ich mir eine eigene Version geschrieben.
Folgendes von Gauss dazu:
Code:
int Kalender::GaussWochentag(int jahr, int m, int d)
{
int c, y, x, w, sj, wo;

/*Feststellen, ob ein Schaltjahr vorliegt*/

/*Wenn Schaltjahr dann sj auf 1 sonst auf 0*/
sj = leapyear();

c = (jahr / 100);       // Die ersten beiden Zahlen der Jahresangabe; die Jahrhunderte
y = jahr - (c * 100);   // Die letzten beiden Jahre der Jahresangabe; die Jahre
if (y == 0) y = 100;
//cout << "\ny="<<y;
if ((m < 3) && (sj == 0)) c -= 1;// alt war ac, nicht sj
m -= 2;                 // Setzt den März auf eins, den Januar auf 11 und Februar auf 12 als Monatszahl

if (m < 1) m+= 12;

if (m > 10) y -= 1;     // Bei Januar oder Februar als Monat y - 1

x = (2.6 * m) - 0.2;
wo = (d + x + y + (y/4) + (c/4)- (2 * c)); //%7;
if (wo < 0) wo += 7;
w = wo %7;

return w;
}
Da mir nicht bekannt ist, in welchen Jahresgrenzen diese arbeitet, habe ich beide Versionen, meine und von Gauss genutzt.
Hier der Osteralgorithmus:
Code:
*Butcher'sche Osteralgorithmus */
void Kalender::ostern(void)
{
int a,b,c,d,e,f,g,h,i,k,l,m,n,p;

a = jahr % 19;
b = jahr / 100;
c = jahr % 100;

d = b / 4;
e = b % 4;
f = (b + 8 ) / 25;

g = (b - f + 1) / 3;
h = ((19*a) + b -d -g +15) % 30;
i = c / 4;

k = c % 4;
l = (32 +(2*e) + (2*i) -h -k) % 7;
m = (a + (11*h) + (22*l))/ 451;

n = (h+l-(7*m)+114)/31;
p = ((h+l-(7*m)+114) % 31) + 1;
ostertag = p;
ostermonat = n;
}
Um die weiteren Feiertag zu bestimmen muss das Datum umgerechnet werden, zum Tag im Jahr:
Code:
// Berechnet an welchen Tag im Jahr das gesuchte Datum ist
int Kalender::DatetoDayofyear(void)
{
int dsp = leapyear();
int slei, rewer = 0;
int monatslaenge[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

monatslaenge[1] += dsp;
rewer += tag;
for (slei = 0; slei < monat - 1; slei++)
  {
    rewer += monatslaenge[slei];
  }

return rewer;
}

int Kalender::DatumzuTagimJahr(int monnum, int tgimmon)
{
// leapyear arbeitet mit einer Klassen-internen Variable(public)
// Daher kein Parameter für die Jahreszahl, kann aber
// umgeschrieben werden.
int dsp = leapyear();
int slei, rewer = 0;
int monatslaenge[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

monatslaenge[1] += dsp;
rewer += tgimmon;

if(monnum > 1)
for (slei = 0; slei < monnum -1; slei++)
  {
   rewer += monatslaenge[slei];
  }

return rewer;
}

//Errechnet aus Datum im welcher Kalenderwoche der gesuchte Tag liegt
void Kalender::Weekofyear(void)
{
int dsp = leapyear();
int rewer = -31, slei;
int monatslaenge[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

monatslaenge[1] += dsp;
rewer += tag;
for (slei = 0; slei < monat; slei++)
  {
  rewer += monatslaenge[slei];
  }

wocheimjahr = ((rewer-1) / 7) + 1; // Kalenderwochen beginnen immer am Montag, da 1ter Arbeitstag
}
Nun müssen wir, um die weiteren Feiertage zu berechnen etwas in der Geschichte der römisch-katholischen Kirche kramen:
Auf dem Konzil von Nicäa (325 n. Chr.) wurde festgelegt, dass Ostern immer auf den Sonntag nach dem ersten Frühlingsvollmond fällt. Da die Dauer eines Jahres kein Vielfaches der Dauer eines Mondumlaufs um die Erde ist, wird Ostern zu einem beweglichen Fest zwischen dem 22. März und 25. April eines jeden Jahres. Weitere kirchliche Feiertage leiten sich aus dem Ostersonntag ab. So ist Aschermittwoch 46 Tage vor Ostersonntag. Christi Himmelfahrt ist 39 Tage, Pfingstsonntag 49 Tage und Fronleichnam 60 Tage nach Ostersonntag. Diese Regeln gelten bis heute! Zu Beachten ist allerdings: Die Vollmondrechnung für Ostern basiert auf einer kirchlichen Vollmondrechnung und nicht auf der astronomischen Vollmondrechnung!

Nachdem wir also diese Tage von der Variablen welche aus dem Datum dem Tag im Jahr berechnet, abgezogen oder dazu gezählt haben, müssen wir daraus wieder ein Datum machen:

Code:
int Kalender::TagNummerzuMonat(int jahr, int tagnummer)
{
int monatsnummer, tn, dsp, slei;
int monat[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

monatsnummer = 0;
tn = tagnummer;

dsp = Schaltjahr(jahr);
monat[1] += dsp;

for (slei = 0; slei < 11; slei++)
{
  monatsnummer = slei;
   if(tn <= monat[slei]) break;
tn = tn - monat[slei];
}

return monatsnummer + 1;
}

int Kalender::TagNummerzuTagimMonat(int jahr, int tagnummer)
{
int monatsnummer, tn, dsp, slei;
int monat[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

monatsnummer = 0;
tn = tagnummer;

dsp = Schaltjahr(jahr);
monat[1] += dsp;

for (slei = 0; slei < 11; slei++)
{
  monatsnummer = slei;
   if(tn <= monat[slei]) break;
tn = tn - monat[slei];
}

return tn;
}
Das ist eine grobe Übersicht zu den Methoden.
Für libreoffice habe ich es hier mal schon vorgestellt, aber noch nicht in QT. So entfällt das aufrufen mit libreoffice.

Nun noch ein kleines Programm in c++ das mit Zellers Kongruenz arbeitet.
Damit lassen sich auch Wochentage und Ostertage im Juljanischen Kalender berechnen.
Zuerst zeller.h:
Code:
#include <iostream>
class Kalender
{
public:
  Kalender();
  ~Kalender();

struct uzeit
{
int stunde;
int minute;
int sekunde;
int jahr;
int monat;
int tag;
int wotag;
int sjahr;
} uhzt;

struct getyear
{
int jahr;
int monat;
int tag;
int ostertag;
int ostermonat;
int pfingsttag;
int pfingstmonat;
int fita[12];
int letzta[12];
int monlen[12];
std::string monam[12];
std::string wotag[7];
int mondat[12][31];
int tagname;
int sjahr;
int tz;
int lz;
int tagimjahr;
int dayofyear;
int xmonat;
int xtag;
int aschermitgimjahr;
int aschmonat;
int aschtag;
int chtagimjahr;
int chmonat;
int chtag;
} gtjr;

int watu;
void EingabeDatum(void);
int Schaltjahr(void);
void IstSchaltjahr(void);
int Zeller_hgreg(void);
int Zeller_jul(void);
void ZeigeTag(void);
int Zeller_Osternjul(void);
int Zeller_Osterngreg(void);
int DatetoDayofyear(void);
int TagNummerzuMonat(int tagnummer);
int TagNummerzuTagimMonat(int tagnummer);
void Pfingsten(void);
int DayofyeartoDate(int tagimjahr);
int Fehlertest(void);
void Uhrzeit(void);
int leapyear(int jhr);

};
nun zeller.cpp:
Code:
#include "zeller.h"

Kalender::Kalender(void)
{
int i;
watu = 8;
int monatslaenge[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

//Samstag ist 0, Freitag 6 
std::string wtag[7] = { "Samstag", "Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag"};
std::string monatsnamen[12] = { "Januar",  "Februar", "März",\
                       "April",   "Mai",     "Juni",\
                       "Juli",    "August",  "September",\
                       "Oktober", "November","Dezember"};


for (i = 0; i < 7; i++)
  gtjr.wotag[i] = wtag[i];   

for (i = 0; i < 12; i++)
  {
   gtjr.monam[i] = monatsnamen[i];
   gtjr.monlen[i] = monatslaenge[i];
  }

}

Kalender::~Kalender(void)
{

}

void Kalender::EingabeDatum(void)
{
  std::cout << "Jahr.: ";
  std::cin >> gtjr.jahr;
    
  std::cout << "Monat: ";
  std::cin >> gtjr.monat;

  std::cout << "Tag..: ";
  std::cin >> gtjr.tag;   
}

/* Ausser bei Schaltjahren ist der erste Tag im Jahr, also der
* 1te Januar derselbe Wochentag wie der 31te Dezember, weil in
*   ------------------------------------------
*      Jahr   Beginn    Ende     Schaltjahr
*   ------------------------------------------
*      2004   Do        Fr        Ja
*      2003   Mi        Mi        nein
*      2002   Di        Di        nein
*      2001   Mo        Mo        nein
*      2000   Sa        So        Ja
*      1999   Fr        Fr        nein
*      1998   Do        Do        nein
*      1997   Mi        Mi        nein
*      1996   Mo        Di        ja
*   ------------------------------------------
*/


int Kalender::Schaltjahr(void)
{
/*
* Wenn Jahreszahl ohne Rest durch Vier teilbar ist,
* ist die Jahreszahl ein Schaltjahre.
* Ausnahme1:
* Wenn die Jahreszahl ausserdem durch 100 teilbar ist, dann
* liegt kein Schaltjahr vor(sp=0).
* Ausnahme von der Ausnahme1:
* Wenn die Jahreszahl durch 400 teilbar ist, liegt doch
* ein Schaltjahr vor(sp=1).
*/
int dsp, s1, s2, s3;
dsp = 0;
s1 = gtjr.jahr % 4;
s2 = gtjr.jahr % 400;
s3 = gtjr.jahr % 100;

if ((s1 == 0) || (s2 == 0))  dsp = 1;
if ((s2 != 0) && (s3 == 0))  dsp = 0;


gtjr.sjahr = dsp;
return dsp;
}

void Kalender::IstSchaltjahr(void)
{
std::cout << "Schaltjahr: ";
if (gtjr.sjahr == 0) std::cout << "nein" << std::endl; 
  else
   {
    std::cout << "ja" << std::endl;
    gtjr.monlen[1] = 29;
   } 
}



// Wochentagsberechnung nach Zellers Kongruenz fuer den gregorianischen Kalender
int Kalender::Zeller_hgreg(void)
{
int hgreg = 0, q, m, J, K; // J=Jahrhunderzahl, K die beiden letzten Ziffern der Jahreszahl;

if (gtjr.monat >= 3) m = gtjr.monat;
  else
  {
   m = gtjr.monat + 12;
   gtjr.jahr -= 1;   
  }   

  //std::cout << "**m:" << m << std::endl;

K = gtjr.jahr % 100;
J = gtjr.jahr / 100;
q = gtjr.tag;

  hgreg = (q + (((m + 1) *13) / 5) + K + (K/4) + (J/4) -(2*J)) % 7;
  if (hgreg < 0) hgreg += 7;

  //std::cout << "q: " << q << "\nm:" << m << std::endl;
  //std::cout << "J: " << J << "   K:" << K << std::endl;

return hgreg;
}

// Wochentagsberechnung nach Zellers Kongruenz fuer den julianischen Kalender
int Kalender::Zeller_jul(void)
{
int hgreg = 0, q, m, J, K; // J=Jahrhunderzahl, K die beiden letzten Ziffern der Jahreszahl;

if (gtjr.monat >= 3) m = gtjr.monat;
  else
  {
   m = gtjr.monat + 12;
   gtjr.jahr -= 1;   
  }   

  //std::cout << "**m:" << m << std::endl;

K = gtjr.jahr % 100;
J = gtjr.jahr / 100;
q = gtjr.tag;

  hgreg = (q + (((m + 1) *13) / 5) + K + (K/4) + 5 -J) % 7;
  if (hgreg < 0) hgreg += 7;

  //std::cout << "q: " << q << "\nm:" << m << std::endl;
  //std::cout << "J: " << J << "   K:" << K << std::endl;

return hgreg;
}


void Kalender::ZeigeTag(void)
{
std::cout << "Datum......: "<< gtjr.tag << "." << gtjr.monat << "." << gtjr.jahr << std::endl;
std::cout << gtjr.wotag[gtjr.tagname] << " Anno " << gtjr.jahr << " den " << gtjr.tag << "ten " << gtjr.monam[gtjr.monat] << std::endl;
std::cout << "Tagname....: " << gtjr.tagname << "=" <<  gtjr.wotag[ gtjr.tagname] << std::endl;
std::cout << "Tag im Jahr: " << gtjr.tagimjahr << std::endl;
}

int Kalender::Zeller_Osternjul(void)
{
int jota = 0, a, b, d, J, K, m = 0; // J=Jahrhunderzahl, K die beiden letzten Ziffern der Jahreszahl;

K = gtjr.jahr % 100;
J = gtjr.jahr / 100;
m = 3;  // gemeint ist der März, da 1 = Januar

  a = (K + (5*J)) % 19;
  b = ((19*a) + 15) % 30;
  d = (b + K + (K/4) -J) % 7;
  jota = b + 7 - d; // Ostern ist dann 21 Tage nach den 21ten Maerz
  jota += 21;



  if((jota + 21) > gtjr.monlen[2]) // Maerz
   {
    jota -= gtjr.monlen[2]; 
    m++;
   }   

  gtjr.ostertag = jota;
  gtjr.ostermonat = m;

  //std::cout << "a: " << a << "   b:" << b << std::endl;
  //std::cout << "J: " << J << "   K:" << K << std::endl;
  //std::cout << "d: " << d << "   Jahr" << gtjr.jahr << std::endl;
  std::cout << "Tag..: " << gtjr.ostertag << std::endl;
  std::cout << "Monat: " << gtjr.ostermonat << std::endl;

return jota;
}


int Kalender::Zeller_Osterngreg(void)
{
int jota = 0, a, b, d, f, g, J, K, m = 0; // J=Jahrhunderzahl, K die beiden letzten Ziffern der Jahreszahl;

K = gtjr.jahr % 100;
J = gtjr.jahr / 100;
m = 3;  // gemeint ist der März, da 1 = Januar

  a = (K + (5*J)) % 19;
  g = J - (J/4) - (J/3);
  b = ((19*a) + 15 + g) % 30;
  d = (b + K + (K/4) +(J/4) + 2 + (5*J)) % 7;
  f = (b + (a/11)) / 29;
  jota = 21 + b + 7 - d- ((6- d) / 6) * f * 7; // Ostern ist dann 21 Tage nach den 21ten Maerz




  if((jota + 21) > gtjr.monlen[2]) // Maerz
   {
    jota -= gtjr.monlen[2]; 
    m++;
   }   

   gtjr.ostertag = jota;
   gtjr.ostermonat = m;

  //std::cout << "a: " << a << "   b:" << b << std::endl;
  //std::cout << "J: " << J << "   K:" << K << std::endl;
  //std::cout << "d: " << d << "   Jahr" << jahr << std::endl;
  std::cout << "Osterjahr.: " << gtjr.jahr << std::endl;
  std::cout << "Ostertag..: " << gtjr.ostertag  << std::endl;
  std::cout << "Ostermonat: " << gtjr.ostermonat << std::endl;


return jota;
}

int Kalender::DatetoDayofyear(void)
{
int dsp = Schaltjahr();
int rewer = 0, slei;

if ((gtjr.monlen[1] == 28) && (dsp == 1))  gtjr.monlen[1] += dsp;
  rewer += gtjr.tag;

if(gtjr.monat > 1)
for (slei = 0; slei < gtjr.monat - 1; slei++)
  {
   //std::cout << "dito\n"; 
   rewer += gtjr.monlen[slei];
  }
return rewer;
}

int Kalender::TagNummerzuMonat(int tagnummer)
{
int monatsnummer, tn, dsp, slei;
//int monat[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

monatsnummer = 0;
tn = tagnummer;

dsp = Schaltjahr();
if ((gtjr.monlen[1] == 28) && (dsp == 1))  gtjr.monlen[1] += dsp;

for (slei = 0; slei < 11; slei++)
{
  monatsnummer = slei;
  if(tn <= gtjr.monlen[slei]) break;
  tn = tn - gtjr.monlen[slei];
}

return monatsnummer + 1;
}

int Kalender::TagNummerzuTagimMonat(int tagnummer)
{
int monatsnummer, tn, dsp, slei;

monatsnummer = 0;
tn = tagnummer;

dsp = Schaltjahr();
if ((gtjr.monlen[1] == 28) && (dsp == 1))  gtjr.monlen[1] += dsp;

for (slei = 0; slei < 11; slei++)
{
  monatsnummer = slei;
  if(tn <= gtjr.monlen[slei]) break;
  tn = tn - gtjr.monlen[slei];
}

return tn;
}

void Kalender::Pfingsten(void)
{
int tdif, mdif;

tdif = (gtjr.monlen[gtjr.ostermonat -1] - gtjr.ostertag);
if ((49 - tdif) > gtjr.monlen[gtjr.ostermonat])
   {
    mdif = 49 - gtjr.monlen[gtjr.ostermonat] - tdif;
    gtjr.pfingsttag = mdif;
    gtjr.pfingstmonat = gtjr.ostermonat + 2;
   }
    else
    {
     mdif = 49 - tdif;
     gtjr.pfingsttag = mdif;
     gtjr.pfingstmonat = gtjr.ostermonat + 1;
    }
  std::cout << "Pfingsttag..: " << gtjr.pfingsttag  << std::endl;
  std::cout << "Pfingstmonat: " << gtjr.pfingstmonat << std::endl;
}

int Kalender::DayofyeartoDate(int tagimjahr)
{
int dsp = Schaltjahr();
int rewer = tagimjahr, slei;
int monatslaenge[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

monatslaenge[1] += dsp;
rewer = tagimjahr;

//cout << "    rewer: " << rewer << endl;
for (slei = 0; slei < 12; slei++)
  {
   gtjr.xmonat = slei + 1;
   gtjr.xtag = rewer;
   if (rewer <= 31) break;
    rewer -= monatslaenge[slei];
  }
//cout << "tagimjahr: " << tagimjahr << "   " << "Monat: " << gtjr.xmonat << "   Tag: " << gtjr.xtag << endl;
return rewer;
}


int Kalender::Fehlertest(void)
{
int rewer = 0, slei;


   if (gtjr.monlen[gtjr.monat -1] < gtjr.tag) rewer = 1;
   if (gtjr.tag < 1) rewer = 2;
   if (gtjr.monat < 1) rewer = 3;
   if (gtjr.monat > 12) rewer = 4;

   if (rewer) std::cout <<"Falsche Eingabe beim Datum: Fehler Nr.: " << rewer << std::endl;
  
return rewer; 
}

void Kalender::Uhrzeit(void) //struct uzeit *uhzt)
{
time_t     encoded_time;
struct tm *decoded_time;

encoded_time = time(NULL);
decoded_time = localtime(&encoded_time);
uhzt.jahr  = decoded_time->tm_year + 1900;
uhzt.sjahr = leapyear(uhzt.jahr);

uhzt.monat = decoded_time->tm_mon + 1;
uhzt.tag   = decoded_time->tm_mday;
uhzt.wotag = decoded_time->tm_wday;

uhzt.stunde  = decoded_time->tm_hour;
uhzt.minute  = decoded_time->tm_min;
uhzt.sekunde = decoded_time->tm_sec;
}

int Kalender::leapyear(int jhr)
{
/*
* Wenn Jahreszahl ohne Rest durch Vier teilbar ist,
* ist die Jahreszahl ein Schaltjahre.
* Ausnahme1:
* Wenn die Jahreszahl au�erdem durch 100 teilbar ist, dann
* liegt kein Schaltjahr vor(sp=0).
* Ausnahme von der Ausnahme1:
* Wenn die Jahreszahl durch 400 teilbar ist, liegt doch
* ein Schaltjahr vor(sp=1).
*/
int dsp = 0, s1, s2, s3;

s1 = jhr % 4;
s2 = jhr % 400;
s3 = jhr % 100;

if ((s1 == 0) || (s2 == 0))  dsp = 1;
if ((s2 != 0) && (s3 == 0))  dsp = 0;

return dsp;
}
nun main.cpp:
Code:
#include "zeller.h"

int main(int argc, char **argv)
{
  Kalender gtdat;

  gtdat.Uhrzeit(); // &tgzt);


do switch(gtdat.watu)
{
  default:
      std::cout << "\nWochentag nach Zeller" << std::endl;
      std::cout << "Datum heute: " << gtdat.uhzt.tag << "." << gtdat.uhzt.monat << "." << gtdat.uhzt.jahr << std::endl;
      std::cout << "Programmende.....................0" << std::endl;
      std::cout << "Datumsberechnung gregorianisch...1" << std::endl;
      std::cout << "Datumsberechnung julianisch......2" << std::endl;
      std::cout << "Osterberechnung julianisch.......3" << std::endl;
      std::cout << "Osterberechnung gregorianisch....4" << std::endl;
      std::cout << "Ihre Wahl: ";
      std::cin >> gtdat.watu;
     break;


case 0:
      std::cout << "Programmende" << std::endl;
    return 0;

case 1:
      std::cout << std::endl << "Datumsberechnung gregorianisch" << std::endl;
      gtdat.EingabeDatum();
    
          
      if ((gtdat.gtjr.jahr  <= 1582) && (gtdat.gtjr.monat <= 10) && (gtdat.gtjr.tag <= 14))
       {
        std::cout <<"Fehler:  Kein Datum vor dem 15ten Oktober 1582, da" << std::endl << "Jahr der Umstellung auf gregorianichen Kalender" << std::endl;
        gtdat.watu = 9;
        break; 
        } 
    
      gtdat.Schaltjahr();
      gtdat.IstSchaltjahr();
      if ((gtdat.Fehlertest()) != 0) { gtdat.watu = 9; break;}
      gtdat.gtjr.tagimjahr = gtdat.DatetoDayofyear();
      gtdat.gtjr.tagname = gtdat.Zeller_hgreg();
      gtdat.ZeigeTag();
      gtdat.Zeller_Osterngreg();
      gtdat.Pfingsten();
      gtdat.gtjr.monat = gtdat.gtjr.ostermonat;
      gtdat.gtjr.tag = gtdat.gtjr.ostertag;
      gtdat.gtjr.dayofyear = gtdat.DatetoDayofyear();
      gtdat.gtjr.aschermitgimjahr = gtdat.gtjr.dayofyear - 46;
      gtdat.DayofyeartoDate(gtdat.gtjr.aschermitgimjahr);
      gtdat.gtjr.aschmonat = gtdat.gtjr.xmonat;
      gtdat.gtjr.aschtag = gtdat.gtjr.xtag;
      std::cout << "\nAschermittwoch: " << gtdat.gtjr.xtag << "." << gtdat.gtjr.xmonat  << std::endl; //<< "er   " << gtdat.gtjr.wotag[ gtdat.gtjr.mondat[gtdat.gtjr.aschmonat -1][gtdat.gtjr.aschtag-1]] << std::endl;
      gtdat.gtjr.chtagimjahr = gtdat.gtjr.dayofyear + 39;
      gtdat.DayofyeartoDate(gtdat.gtjr.chtagimjahr);
      gtdat.gtjr.chmonat = gtdat.gtjr.xmonat;
      gtdat.gtjr.chtag = gtdat.gtjr.xtag;
      std::cout << "Christi Himmelfahrt: " << gtdat.gtjr.chtagimjahr << "   Tag im Jahr = " << gtdat.gtjr.chmonat << "." << gtdat.gtjr.chtag  << std::endl; //<<"er   " << gtdat.gtjr.wotag[ gtdat.gtjr.mondat[gtdat.gtjr.chmonat -1][gtdat.gtjr.chtag-1]] << endl;
      gtdat.watu = 9;
    break;

case 2:
     std::cout << "\nDatumsberechnung julianisch" << std::endl;   
     gtdat.EingabeDatum();

     gtdat.Schaltjahr();
     gtdat.IstSchaltjahr();
     if ((gtdat.Fehlertest()) != 0) { gtdat.watu = 9; break;}
  
     if ((gtdat.gtjr.jahr  >= 1582) && (gtdat.gtjr.monat >= 10) && (gtdat.gtjr.tag > 14))
       {
        std::cout <<"Fehler:  Kein Datum nach dem 15ten Oktober 1582, da" << std::endl << "Jahr der Umstellung auf gregorianichen Kalender" << std::endl;
        gtdat.watu = 9;
        break; 
        }


     gtdat.gtjr.tagname = gtdat.Zeller_jul();

     gtdat.ZeigeTag();
     gtdat.Zeller_Osternjul();

     gtdat.watu = 9;
   break;

case 3:
      std::cout << "Osterberechnung julianisch" << std::endl;
    
      std::cout << "Jahr: ";
      std::cin >> gtdat.gtjr.jahr;
    
      if (gtdat.gtjr.jahr  > 1582)
       {
        std::cout <<"Fehler:  Kein Datum nach dem 15ten Oktober 1582, da" << std::endl << "Jahr der Umstellung auf gregorianichen Kalender" << std::endl;
        gtdat.watu = 9;
        break; 
        } 
    
      gtdat.Zeller_Osternjul();
     gtdat.watu = 9;
   break;

case 4:
      std::cout << "Osterberechnung gregorianisch" << std::endl;
    
      std::cout << "Jahr: ";
      std::cin >> gtdat.gtjr.jahr;
      if (gtdat.gtjr.jahr  < 1582)
       {
        std::cout <<"Fehler:  Kein Datum vor den 15ten Oktober 1582, da" << std::endl << "Jahr der Umstellung auf gregorianichen Kalender" << std::endl;
        gtdat.watu = 9;
        break; 
        }   
    
    
     gtdat.Zeller_Osterngreg();
     gtdat.watu = 9;
   break; 

}while(gtdat.watu != 0);


return 0;
}


Viel Spaß beim Testen.
Autor
rustyoldguy
Downloads
1
First release
Last update
Bewertung
0,00 Stern(e) 0 Bewertungen

Latest updates

  1. Kleines Kalenderprogramm in QT Version 03

    Die Zeile mitostertagimjahr = DatumzuTagimJahr(4,1); //ostermonat, ostertag); verursachete einen...
Oben