diff --git a/02-1 OpUeberladungBrueche/01Overloadable Operators.txt b/02-1 OpUeberladungBrueche/01Overloadable Operators.txt
new file mode 100644
index 0000000000000000000000000000000000000000..f053e22bb077c27854f980d756d09edf4856b982
--- /dev/null
+++ b/02-1 OpUeberladungBrueche/01Overloadable Operators.txt
@@ -0,0 +1,50 @@
+Overloadable and Non-Overloadable Operators
+https://docs.microsoft.com/de-de/dotnet/csharp/language-reference/operators/operator-overloading#overloadable-operators
+
+
++x, -x, !x, ~x, ++, --, true, false
+Diese un�ren Operatoren k�nnen �berladen werden.
+
+
+x + y, x - y, x * y, x / y, x % y, x & y, x | y, x ^ y, x << y, x >> y,
+x == y, x != y, x < y, x > y, x <= y, x >= y
+Diese bin�ren Operatoren k�nnen �berladen werden.
+
+Die Vergleichsoperatoren m�ssen paarweise �berladen werden.
+Das bedeutet: Wenn ein Operator �berladen wird, der einem Paar angeh�rt,
+muss der andere Operator ebenfalls �berladen werden. Dies kann f�r die
+folgenden Paare zutreffen:
+Die Operatoren == und !=
+Die Operatoren < und >
+Die Operatoren <= und >=
+
+
+x && y, x || y
+Bedingte logische Operatoren k�nnen nicht �berladen werden.
+Wenn jedoch ein Typ mit den �berladenen Operatoren true und false
+ebenfalls den Operator& oder | auf eine bestimmte Weise �berl�dt,
+kann jeweils entweder der Operator && oder der Operator || f�r die
+Operanden dieses Typs ausgewertet werden.
+
+
+a[i] Der Elementzugriff wird nicht als �berladbarer Operator betrachtet.
+Sie k�nnen aber einen Indexer definieren.
+
+
+(T)x Der Cast-Operator kann nicht �berladen werden,
+jedoch k�nnen Sie benutzerdefinierte Typkonvertierungen definieren,
+die von einem Cast-Ausdruck durchgef�hrt werden k�nnen. Weitere
+Informationen finden Sie unter Benutzerdefinierte Konvertierungsoperatoren.
+
+
++=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
+Zusammengesetzte Zuweisungsoperatoren k�nnen nicht explizit �berladen werden.
+Wenn Sie einen bin�ren Operator �berladen, wird der zugeh�rige zusammengesetzte
+Zuweisungsoperator jedoch, sofern er vorhanden ist, auch implizit �berladen.
+Wenn += beispielsweise mit + ausgewertet wird. Selbiger kann �berladen werden.
+
+
+^x, x = y, x.y, c ? t : f, x ?? y, x ??= y, x..y, x->y, =>, f(x), as,
+await, checked, unchecked, default, delegate, is, nameof, new, sizeof,
+stackalloc, typeof
+Diese Operatoren k�nnen nicht �berladen werden.
diff --git a/02-1 OpUeberladungBrueche/Bruch.cs b/02-1 OpUeberladungBrueche/Bruch.cs
index cd69308aacc4bfa76b17f5ece1bf9abaead4f4e6..ec525800db42fca28e2f9a5b64fc2e21dab515f5 100644
--- a/02-1 OpUeberladungBrueche/Bruch.cs
+++ b/02-1 OpUeberladungBrueche/Bruch.cs
@@ -7,12 +7,13 @@ namespace _02_1_OpUeberladungBrueche
class Bruch
{
int z, n;
- public Bruch (int Z,int N=1)
+ public Bruch(int Z, int N = 1)
{
z = Z;
n = N;
}
+ #region Binäre Operatoren
//public void Mult_V1(Bruch b)
//{
// // Ergebnisse müssten in z,n gespeichert werden
@@ -27,7 +28,7 @@ namespace _02_1_OpUeberladungBrueche
}
public Bruch Mult_V3(Bruch b)
{
- return new Bruch(z * b.z, n * b.n);
+ return new Bruch(z * b.z, n * b.n);
}
public Bruch Mult_V4(Bruch b)
=> new Bruch(this.z * b.z, this.n * b.n);
@@ -37,18 +38,45 @@ namespace _02_1_OpUeberladungBrueche
public static Bruch Mult_V5(Bruch b1, Bruch b2)
=> new Bruch(b1.z * b2.z, b1.n * b2.n);
+ public static Bruch operator *(Bruch b1, Bruch b2)
+ => new Bruch(b1.z * b2.z, b1.n * b2.n);
//public static Bruch Mult_V5(Bruch b1, int k)
// => new Bruch(b1.z * k, b1.n );
//public static Bruch Mult_V5(int k, Bruch b2)
// => new Bruch(k * b2.z, b2.n);
- public static Bruch operator *(Bruch b1, Bruch b2)
- => new Bruch(b1.z * b2.z, b1.n * b2.n);
+ public static Bruch operator <<(Bruch b, int x) => new Bruch(b.z * x, b.n * x);
+ public static Bruch operator >>(Bruch b, int x) => new Bruch(b.z / x, b.n / x);
+ #endregion
- // Konvertierungsoperatoren
- public static implicit operator Bruch (int k) => new Bruch (k);
+ #region Konvertierungsoperatoren
+ public static implicit operator Bruch(int k) => new Bruch(k);
+ // Macht aus einem int einen Bruch
+ public static explicit operator Bruch(double d) => new Bruch((int) d);
// Macht aus einem int einen Bruch
- public static explicit operator int (Bruch b) => b.z/b.n;
+
+ public static explicit operator int(Bruch b) => b.z / b.n;
// Macht aus einem Bruch einen int
// Da etwas verloren gehen kann, explizite Konvertierung
+ public static explicit operator double(Bruch b) => ((double) b.z / (double) b.n);
+ #endregion
+
+ #region Unäre Operatoren
+ public static Bruch operator +(Bruch b) => b;
+ public static Bruch operator -(Bruch b) => new Bruch(-b.z, b.n);
+
+ // x = 5; cw(x++)--> cw(x); x=x+1 , cw(++x) --> x=x+1;cw(x)
+ // b1++ 3/2++ --> 5/2
+ // Compiler generiert selbstätig die entsprechende Codeanordnung
+ public static Bruch operator ++(Bruch b) => new Bruch(b.z + b.n, b.n);
+ public static Bruch operator --(Bruch b) => new Bruch(b.z - b.n, b.n);
+ #endregion
+
+ #region Vergleichsoperatoren
+ public static bool operator ==(Bruch b1, Bruch b2) => b1.z == b2.z && b1.n == b2.n;
+ public static bool operator !=(Bruch b1, Bruch b2) => !(b1 == b2);
+ public static bool operator true(Bruch b) => b.n != 1;
+ public static bool operator false(Bruch b) => b.n == 1;
+ #endregion
+ public override string ToString() => $"{z}/{n}";
}
}
diff --git a/02-1 OpUeberladungBrueche/Program.cs b/02-1 OpUeberladungBrueche/Program.cs
index 14102ad144fabaaf90e72a138b756e390dd355b8..f622754672b4775bd69002414343a05c295e35c5 100644
--- a/02-1 OpUeberladungBrueche/Program.cs
+++ b/02-1 OpUeberladungBrueche/Program.cs
@@ -3,18 +3,18 @@
namespace _02_1_OpUeberladungBrueche
{
class Program
- {
+ {
static void Main(string[] args)
{
Bruch b1 = new Bruch(2, 3);
Bruch b2 = new Bruch(3, 4);
Bruch b3 = new Bruch(2);
- //int k1 = 3;
- //int k2 = 4;
- //k1 * k2;
+ int k1 = 3;
+ int k2 = 4;
+ int k3 = k1 * k2 * 3;
- // b1.Mult_V1(b2); -- NEIN! b1 wird zerstört
+ // b1.Mult_V1(b2); -- GANZ SCHLECHT! b1 wird zerstört
Bruch e1 = b1.Mult_V2(b2);
Bruch e2 = b1.Mult_V3(b2);
@@ -26,11 +26,35 @@ namespace _02_1_OpUeberladungBrueche
Bruch e5 = Bruch.Mult_V5(b1, b2);
Bruch e6 = Bruch.Mult_V5(b1, 2);
Bruch e7 = Bruch.Mult_V5(2, b2);
- int k3 = (int)b1;
+ int k7 = (int) b1;
+ double d = (double) b1;
Bruch e8 = b1 * b2;
Bruch e9 = b1 * 2;
- Bruch e10 = 2 * b2 * 3;
+ Bruch e10 = ((Bruch) (2 * 3.5) * b1) * b2;
+
+ int k4 = +k1;
+ k4 = -k1;
+
+ Bruch e11 = +b1;
+ Bruch e12 = -b1;
+
+ k1=5;
+ int k5 = k1++; // k5 = 5; k1 = 6
+ k1 = 5;
+ int k6 = ++k1; // k6 = 6; k1 = 6
+
+ Bruch b4 = new Bruch(1, 2);
+ Bruch b5 = new Bruch(1, 2);
+ if (b4 == b5)
+ Console.WriteLine("Brüche sind gleich");
+ else
+ Console.WriteLine("Brüche sind NICHT gleich!");
+ if (b4)
+ Console.WriteLine("b4 ist ein echter Bruch");
+ else
+ Console.WriteLine("b4 ist eine ganze Zahl");
+ Console.WriteLine(b4);
}
}
}
diff --git a/02-4 VerketteteStrukturenIntro/02-4 VerketteteStrukturenIntro.csproj b/02-4 VerketteteStrukturenIntro/02-4 VerketteteStrukturenIntro.csproj
new file mode 100644
index 0000000000000000000000000000000000000000..d110a28ea9c7b30943203c1e5bd8a1bc7968fd89
--- /dev/null
+++ b/02-4 VerketteteStrukturenIntro/02-4 VerketteteStrukturenIntro.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>netcoreapp3.1</TargetFramework>
+ <RootNamespace>_02_4_VerketteteStrukturenIntro</RootNamespace>
+ </PropertyGroup>
+
+</Project>
diff --git a/02-4 VerketteteStrukturenIntro/Liste.cs b/02-4 VerketteteStrukturenIntro/Liste.cs
new file mode 100644
index 0000000000000000000000000000000000000000..4a108ba500973c9e36862efd9964740bd1b0a8ca
--- /dev/null
+++ b/02-4 VerketteteStrukturenIntro/Liste.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace _02_4_VerketteteStrukturenIntro
+{
+ class LItem
+ {
+ public int zahl;
+ public LItem next;
+ }
+}
diff --git a/02-4 VerketteteStrukturenIntro/Program.cs b/02-4 VerketteteStrukturenIntro/Program.cs
new file mode 100644
index 0000000000000000000000000000000000000000..cd608a268224e34a3f0f4d23dfcb273a574dbe94
--- /dev/null
+++ b/02-4 VerketteteStrukturenIntro/Program.cs
@@ -0,0 +1,19 @@
+using System;
+
+namespace _02_4_VerketteteStrukturenIntro
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ // int[] f = new int[500];
+ LItem e1 = new LItem();
+ e1.zahl = 10;
+
+ LItem e2 = new LItem();
+ e2.zahl = 20;
+
+ e1.next = e2;
+ }
+ }
+}
diff --git a/02-UbgKlasseTime/02-UbgKlasseTime.csproj b/02-UbgKlasseTime/02-UbgKlasseTime.csproj
new file mode 100644
index 0000000000000000000000000000000000000000..62b9a3973341bd78df4507916f4e83adf0b76b37
--- /dev/null
+++ b/02-UbgKlasseTime/02-UbgKlasseTime.csproj
@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <OutputType>Exe</OutputType>
+ <TargetFramework>netcoreapp3.1</TargetFramework>
+ <RootNamespace>_02_UbgKlasseTime</RootNamespace>
+ </PropertyGroup>
+
+</Project>
diff --git a/02-UbgKlasseTime/Program.cs b/02-UbgKlasseTime/Program.cs
new file mode 100644
index 0000000000000000000000000000000000000000..87929b61250ddfc0cc33e5e019266eb2d29387e3
--- /dev/null
+++ b/02-UbgKlasseTime/Program.cs
@@ -0,0 +1,26 @@
+using System;
+
+namespace _02_UbgKlasseTime
+{
+ class Program
+ {
+ static void Main(string[] args)
+ {
+ Time t1 = new Time(9, 45);
+ Time t3 = "11:30";
+ Time t2 = t1 + "1:30" + 15;
+ TimeSpan ts1 = t3 - t1;
+ Console.WriteLine(t2);
+ Console.WriteLine(ts1.TotalMins);
+ Console.WriteLine(ts1);
+ //if (t2)
+ // Console.WriteLine("Guten Morgen");
+ //else
+ // Console.WriteLine("Guten Tag");
+ if (t2 == t3)
+ Console.WriteLine("Die Uhrzeiten sind gleich!");
+ else
+ Console.WriteLine("Die Uhrzeiten stimmen nicht überein");
+ }
+ }
+}
diff --git a/02-UbgKlasseTime/Time.cs b/02-UbgKlasseTime/Time.cs
new file mode 100644
index 0000000000000000000000000000000000000000..64cde4a7ba4f917a3e37074d37ba799879681e5e
--- /dev/null
+++ b/02-UbgKlasseTime/Time.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace _02_UbgKlasseTime
+{
+ // ToDo: Schreiben Sie die zwei Klassen Time und TimeSpan, sodass nachfolgendes Programm ausführbar ist
+ // Sie können die Uhrzeit und die Zeitspanne intern gerne durch einen int realisieren und
+ // nur für die Ausgaben in tatsächliche Std:Min-Ausgaben umwandeln.
+
+ // Klasse Time, Konstruktor(int,int)
+ // Time.op+(Time,TimeSpan),
+
+ // Time:string->Time, evtl. Time.Time(string)
+ // Time.op true&false
+ // Time.op== & Time.op!=
+ // override Time.ToString()
+
+ // TimeSpan:string->TimeSpan (impl),
+ // TimeSpan:int->TimeSpan (impl.)
+ // TimeSpan.op-(Time, Time) ->TimeSpan
+
+
+
+ // TimeSpan.TotalMins-get-Property
+ // override TimeSpan.ToString()
+
+
+ // 11:30
+ // 105
+ // 1:45
+ // Guten Morgen
+ // Die Uhrzeiten sind gleich!
+ class Time
+ {
+ int minuten;
+ public Time(int std, int min)
+ {
+ minuten = std * 60 + min;
+ }
+ private Time (int mins) { minuten = mins; }
+
+ // Konvertierungskonstruktoren:
+ public static implicit operator Time(string s)
+ {
+ string[] t = s.Split(':');
+ return new Time (Convert.ToInt32(t[0]),Convert.ToInt32(t[1]));
+ }
+ public static implicit operator Time(int k) => new Time(k);
+
+ public static TimeSpan operator -(Time t1, Time t2) => new TimeSpan(t2.minuten - t1.minuten);
+ public static Time operator +(Time t1, Time t2) => new Time(t1.minuten + t2.minuten);
+ public static bool operator ==(Time t1, Time t2) => t1.minuten == t2.minuten;
+ public static bool operator !=(Time t1, Time t2) => !(t1==t2);
+ }
+
+ class TimeSpan
+ {
+ int minuten;
+ public TimeSpan(int mins) { minuten = mins; }
+ public int TotalMins { get => minuten; }
+
+ }
+}
diff --git a/Prog2WienkopSS2021.sln b/Prog2WienkopSS2021.sln
index baea8f105cde88aff8d8aa67d5da3acc5afb792a..433149b196138c2d69a4bdb00bec1fc011bce08d 100644
--- a/Prog2WienkopSS2021.sln
+++ b/Prog2WienkopSS2021.sln
@@ -13,7 +13,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "01-3 Personalausweis", "01-
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "01-3 TestPersonalausweis", "01-3 TestPersonalausweis\01-3 TestPersonalausweis.csproj", "{03421B8B-5B64-4997-9BA7-F558D50799EB}"
EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "02-1 OpUeberladungBrueche", "02-1 OpUeberladungBrueche\02-1 OpUeberladungBrueche.csproj", "{0CEC8CDB-1B65-4A3D-B6BD-5DE722BEE96D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "02-1 OpUeberladungBrueche", "02-1 OpUeberladungBrueche\02-1 OpUeberladungBrueche.csproj", "{0CEC8CDB-1B65-4A3D-B6BD-5DE722BEE96D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "02-UbgKlasseTime", "02-UbgKlasseTime\02-UbgKlasseTime.csproj", "{A0A79CA1-F22A-4890-9A24-136FBAFBD0B4}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "02-4 VerketteteStrukturenIntro", "02-4 VerketteteStrukturenIntro\02-4 VerketteteStrukturenIntro.csproj", "{1FC21BA1-47A7-4466-BA80-A29C0AFD5FB6}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -45,6 +49,14 @@ Global
{0CEC8CDB-1B65-4A3D-B6BD-5DE722BEE96D}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0CEC8CDB-1B65-4A3D-B6BD-5DE722BEE96D}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0CEC8CDB-1B65-4A3D-B6BD-5DE722BEE96D}.Release|Any CPU.Build.0 = Release|Any CPU
+ {A0A79CA1-F22A-4890-9A24-136FBAFBD0B4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {A0A79CA1-F22A-4890-9A24-136FBAFBD0B4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {A0A79CA1-F22A-4890-9A24-136FBAFBD0B4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {A0A79CA1-F22A-4890-9A24-136FBAFBD0B4}.Release|Any CPU.Build.0 = Release|Any CPU
+ {1FC21BA1-47A7-4466-BA80-A29C0AFD5FB6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {1FC21BA1-47A7-4466-BA80-A29C0AFD5FB6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {1FC21BA1-47A7-4466-BA80-A29C0AFD5FB6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {1FC21BA1-47A7-4466-BA80-A29C0AFD5FB6}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE