huaqo/courses
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added ws202425 courses

Browse Source
This commit is contained in:
huaqo
2024-11-14 13:11:04 +01:00
parent 800282c2e8
commit beb31897b1
461 changed files with 20368 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
2023_Informatik_b/8/klassen.cpp
+162
View File
@@ -0,0 +1,162 @@
#include <string>
#include <iostream>
/*
EScooter
-------------------------
- Marke: std::string
- PS: int
- Akku: int
-------------------------
+ EScooter(m: std::string, p: int, a: int)
+ ~EScooter()
+ getModell(): std::string
+ getPS(): int
+ getAkku(): int
+ setPS(p: int): void
+ operator<(other: EScooter): bool
*/
class EScooter
{
private:
// Attribute
std::string Marke;
int PS;
int Akku;
public:
/*
Voraussetzungen: Die Funktion kann mit einem String und zwei Integers aufgerufen werden.
Ergebnis: Es wird kein Ergebnis zurückgegeben.
Effekt: Ein neues EScooter-Objekt wird mit den angegebenen Marken-, PS- und Akkuwerten erstellt.
*/
EScooter(std::string m, int p, int a) : Marke(m), PS(p), Akku(a) {}
/*
Voraussetzungen: Keine. Der Destruktor wird aufgerufen, wenn ein EScooter-Objekt gelöscht wird.
Ergebnis: Es wird kein Ergebnis zurückgegeben.
Effekt: Das EScooter-Objekt wird aus dem Speicher entfernt.
*/
~EScooter() {}
/*
Voraussetzungen: Diese Methoden können aufgerufen werden, um die entsprechenden Attribute eines EScooter-Objekts zu erhalten.
Ergebnis: Jede Methode gibt den entsprechenden Attributwert zurück.
Effekt: Kein weiterer Effekt.
*/
std::string getModell()
{
return Marke;
}
int getPS()
{
return PS;
}
int getAkku()
{
return Akku;
}
/*
Voraussetzungen: Die Methode kann aufgerufen werden, um den PS-Wert eines EScooter-Objekts zu ändern.
Ergebnis: Es wird kein Ergebnis zurückgegeben.
Effekt: Der PS-Wert des EScooter-Objekts wird auf den übergebenen Wert gesetzt.
*/
void setPS(int p)
{
PS = p;
}
/*
Voraussetzungen: Die Methode kann aufgerufen werden, um zwei EScooter-Objekte auf der Basis ihrer PS-Werte zu vergleichen.
Ergebnis: Die Methode gibt ein boolsches Ergebnis zurück, das angibt, ob das aktuelle EScooter-Objekt weniger PS hat als das andere.
Effekt: Kein weiterer Effekt.
*/
bool operator<(const EScooter &other) const
{
return PS < other.PS;
}
};
/*
Kochfeld
-------------------------
- Marke: std::string
- AnzahlBrenner: int
- istEingeschaltet: bool
-------------------------
+ Kochfeld(m: std::string, b: int)
+ ~Kochfeld()
+ getMarke(): std::strinsg
+ getAnzahlBrenner(): int
+ einschalten(): void
+ ausschalten(): void
+ istAn(): bool
*/
class Kochfeld
{
private:
std::string Marke;
int AnzahlBrenner;
bool istEingeschaltet;
public:
// Konstruktor
Kochfeld(std::string m, int b) : Marke(m), AnzahlBrenner(b), istEingeschaltet(false) {}
// Destruktor
~Kochfeld() {}
// Methoden
std::string getMarke() const
{
return Marke;
}
int getAnzahlBrenner() const
{
return AnzahlBrenner;
}
void einschalten()
{
istEingeschaltet = true;
}
void ausschalten()
{
istEingeschaltet = false;
}
bool istAn() const
{
return istEingeschaltet;
}
};
int main()
{
// Test EScooter
EScooter meinScooter("voi", 250, 100);
std::cout << "Marke: " << meinScooter.getModell() << std::endl;
std::cout << "PS: " << meinScooter.getPS() << std::endl;
std::cout << "Akku: " << meinScooter.getAkku() << std::endl;
EScooter andererScooter("lime", 300, 120);
std::cout << "Ist mein Scooter schwächer als der andere? " << (meinScooter < andererScooter ? "Ja" : "Nein") << std::endl;
meinScooter.setPS(350);
std::cout << "Nach dem Tuning: " << std::endl;
std::cout << "PS: " << meinScooter.getPS() << std::endl;
std::cout << "Ist mein Scooter jetzt schwächer als der andere? " << (meinScooter < andererScooter ? "Ja" : "Nein") << std::endl;
// Test Kochfeld
Kochfeld meinKochfeld("Bosch", 4);
std::cout << "Marke: " << meinKochfeld.getMarke() << std::endl;
std::cout << "Anzahl der Brenner: " << meinKochfeld.getAnzahlBrenner() << std::endl;
std::cout << "Ist das Kochfeld eingeschaltet? " << (meinKochfeld.istAn() ? "Ja" : "Nein") << std::endl;
meinKochfeld.einschalten();
std::cout << "Ist das Kochfeld eingeschaltet? " << (meinKochfeld.istAn() ? "Ja" : "Nein") << std::endl;
meinKochfeld.ausschalten();
std::cout << "Ist das Kochfeld eingeschaltet? " << (meinKochfeld.istAn() ? "Ja" : "Nein") << std::endl;
}
2023_Informatik_b/8/konto.cpp
+64
View File
@@ -0,0 +1,64 @@
#include <iostream>
#include <vector>
class Konto
{
private:
unsigned pin;
int kontostand;
public:
Konto(unsigned pin, int kontostand) : pin(pin), kontostand(kontostand) {}
void abheben(unsigned pin, unsigned betrag)
{
if (this->pin == pin)
{
kontostand = kontostand - betrag;
}
else
{
std::cout << "Falsche Pin.\n";
}
}
void einzahlen(unsigned pin, unsigned betrag)
{
if (this->pin == pin)
{
std::cout << "Alter Kontostand: " << kontostand << std::endl;
kontostand = kontostand + betrag;
std::cout << "Neuer Kontostand: " << kontostand << std::endl;
}
else
{
std::cout << "Falsche Pin.\n";
}
}
void mehr_einzahlen(unsigned pin, std::vector<unsigned> betraege)
{
if (this->pin == pin)
{
for (unsigned i; i < betraege.size(); i++)
kontostand = kontostand + betraege[i];
}
else
{
std::cout << "Falsche Pin.\n";
}
}
~Konto()
{
std::cout << "Konto wurde gelöscht.\n";
}
};
int main()
{
int betrag;
std::cin >> betrag;
Konto meinKonto(1234, 6000);
meinKonto.einzahlen(1234, betrag);
}
2023_Informatik_b/8/merkregeln.cpp
+102
View File
@@ -0,0 +1,102 @@
/*
(a) Attribute und Hilfsmethoden sollen als private deklariert sein.
Dies gewährleistet die Datenkapselung und Datenintegrität, indem sichergestellt wird, dass interne Zustände und Hilfsmethoden nicht direkt von außerhalb der Klasse modifiziert werden können.
*/
class BeispielKlassePriPub
{
private:
int attribut; // Privates Attribut
void hilfsMethode()
{ // Private Hilfsmethode
attribut *= 2;
}
public:
BeispielKlassePriPub() : attribut(5) {}
void offentlicheMethode()
{
hilfsMethode();
}
};
/*
(b) Methoden, die public sind, sowie die Konstruktoren als auch der Destruktor sollen spezifiziert sein. (Hier müssen Sie keine Code-Beispiele angeben.)
Dies bietet eine schriftliche Schnittstelle für andere um die Klasse richtig benutzen zu können.
*/
/*
(c) Das Signalwort const soll immer dort benutzt werden, wo es sinnvoll ist.
Durch Verwendung von const können wir sicherstellen, dass eine Methode den internen Zustand des Objekts nicht ändert. Dies kann besonders hilfreich sein, wenn wir das Objekt in einer Situation verwenden möchten, in der es unverändert bleiben muss.
*/
class BeispielKlasseConst
{
private:
int attribut;
public:
BeispielKlasseConst(int wert) : attribut(wert) {}
// Eine const Methode, die das Attribut nicht ändern kann
int getAttribut() const
{
return attribut;
}
};
/*
(d) Jede Klasse, die mit new eigenen Speicher alloziert, soll einen Destruktor, einen Copy-Konstruktor und einen Copy-Assignment-Operator implementieren.
Dies sind die großen vier in C++. Wenn eine dieser Operationen benötigt wird, werden wahrscheinlich alle benötigt werden. Sie helfen dabei, Speicherlecks zu verhindern und sicherzustellen, dass das Objekt korrekt kopiert wird.
*/
class BeispielKlasse3
{
private:
int *attribut;
public:
// Konstruktor
BeispielKlasse3(int wert) : attribut(new int(wert)) {}
// Destruktor
~BeispielKlasse3()
{
delete attribut;
}
// Kopierkonstruktor
BeispielKlasse3(const BeispielKlasse3 &andere) : attribut(new int(*(andere.attribut))) {}
// Kopierzuweisungsoperator
BeispielKlasse3 &operator=(const BeispielKlasse3 &andere)
{
if (this != &andere)
{
delete attribut;
attribut = new int(*(andere.attribut));
}
return *this;
}
};
/*
(e) Benutze Call-by-Reference in Verbindung mit const statt Call-by-Value, wenn das übergebene Objekt nicht verändert werden soll.
Dies ist nützlich, um teure Kopien von großen Objekten zu vermeiden und gleichzeitig sicherzustellen, dass das ursprüngliche Objekt unverändert bleibt.
*/
class AndereKlasse
{
// Definition für AndereKlasse
};
class BeispielKlasse4
{
public:
void irgendeineMethode(const AndereKlasse &objekt) const
{
// kann objekt hier verwenden, aber es nicht ändern
}
};
2023_Informatik_b/8/templates.cpp
+158
View File
@@ -0,0 +1,158 @@
#include <vector>
#include <iostream>
#include <string>
template <typename SchluesselTyp, typename WertTyp>
class schluesselWertPaar
{
private:
SchluesselTyp schluessel;
WertTyp wert;
public:
schluesselWertPaar() {}
// Konstruktor
schluesselWertPaar(SchluesselTyp schluessel, WertTyp wert) : schluessel(schluessel), wert(wert) {}
// Getter für Schlüssel und Wert
SchluesselTyp getSchluessel() const
{
return schluessel;
}
WertTyp getWert() const
{
return wert;
}
// Setter für Schlüssel und Wert
void setSchluessel(SchluesselTyp neuerSchluessel)
{
schluessel = neuerSchluessel;
}
void setWert(WertTyp neuerWert)
{
wert = neuerWert;
}
// Überladen des < Operators
bool operator<(const schluesselWertPaar &paar) const
{
return schluessel < paar.getSchluessel();
}
};
template <typename SchluesselTyp, typename WertTyp>
void merge(std::vector<schluesselWertPaar<SchluesselTyp, WertTyp>> &vec, int start, int mid, int end)
{
int i, j, k;
int n1 = mid - start + 1;
int n2 = end - mid;
std::vector<schluesselWertPaar<SchluesselTyp, WertTyp>> left(n1), right(n2);
for (i = 0; i < n1; i++)
left[i] = vec[start + i];
for (j = 0; j < n2; j++)
right[j] = vec[mid + 1 + j];
i = 0;
j = 0;
k = start;
while (i < n1 && j < n2)
{
if (left[i] < right[j])
{
vec[k] = left[i];
i++;
}
else
{
vec[k] = right[j];
j++;
}
k++;
}
while (i < n1)
{
vec[k] = left[i];
i++;
k++;
}
while (j < n2)
{
vec[k] = right[j];
j++;
k++;
}
}
template <typename SchluesselTyp, typename WertTyp>
void mergeSort(std::vector<schluesselWertPaar<SchluesselTyp, WertTyp>> &vec, int start, int end)
{
if (start < end)
{
int mid = start + (end - start) / 2;
mergeSort(vec, start, mid);
mergeSort(vec, mid + 1, end);
merge(vec, start, mid, end);
}
}
template <typename SchluesselTyp, typename WertTyp>
int binarySearch(std::vector<schluesselWertPaar<SchluesselTyp, WertTyp>> &vec, int start, int end, SchluesselTyp key)
{
if (end >= start)
{
int mid = start + (end - start) / 2;
if (vec[mid].getSchluessel() == key)
return mid;
if (vec[mid].getSchluessel() > key)
return binarySearch(vec, start, mid - 1, key);
return binarySearch(vec, mid + 1, end, key);
}
return -1;
}
int main()
{
std::vector<schluesselWertPaar<int, std::string>> vec;
vec.push_back(schluesselWertPaar<int, std::string>(3, "drei"));
vec.push_back(schluesselWertPaar<int, std::string>(1, "eins"));
vec.push_back(schluesselWertPaar<int, std::string>(2, "zwei"));
std::cout << "Vor dem sortieren:\n";
for (const auto &paar : vec)
{
std::cout << paar.getSchluessel() << " " << paar.getWert() << std::endl;
}
mergeSort(vec, 0, vec.size() - 1);
std::cout << "Nach dem sortieren:\n";
for (const auto &paar : vec)
{
std::cout << paar.getSchluessel() << " " << paar.getWert() << std::endl;
}
int index = binarySearch(vec, 0, vec.size() - 1, 3);
if (index != -1)
{
std::cout << "Gefunden an Position: " << index + 1 << std::endl;
}
else
{
std::cout << "Nicht gefunden" << std::endl;
}
}