<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="de">
	<id>https://wiki.freitagsrunde.org/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=AndyF</id>
	<title>FreitagsrundenWiki - Benutzerbeiträge [de]</title>
	<link rel="self" type="application/atom+xml" href="https://wiki.freitagsrunde.org/api.php?action=feedcontributions&amp;feedformat=atom&amp;user=AndyF"/>
	<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/Spezial:Beitr%C3%A4ge/AndyF"/>
	<updated>2026-05-08T16:33:16Z</updated>
	<subtitle>Benutzerbeiträge</subtitle>
	<generator>MediaWiki 1.31.16</generator>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/ckdu&amp;diff=14969</id>
		<title>C-Kurs/ckdu</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/ckdu&amp;diff=14969"/>
		<updated>2010-09-19T09:12:29Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* 2. Stufe */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Diese Aufgabe ist eine besondere Aufgabe. Sie wird/wurde in der 7. Vorlesung live fast komplett implementiert. Da dies sehr viel ist und damit wichtige Fragen dort geklaert werden koennen, probiert diese Aufgabe zu Hause '''übers Wochenende''' doch schon mal '''selbst zu implementieren'''.&lt;br /&gt;
&lt;br /&gt;
= Aufbau dieser Seite =&lt;br /&gt;
Es gibt mehrere Stufen. Das heißt wir haben diese große Aufgabe schon für euch in kleine Happen geteilt. Wenn ihr also ''wirklich'' nicht weiterkommt, könnt ihr euch in der Vorgabe (base1.c bis base 3.c) der nächst höheren Stufe angucken wie wir es gelöst haben. Aber bedenke: Jede Stufe wird ein bisschen anspruchsvoller!&lt;br /&gt;
&lt;br /&gt;
= Funktion =&lt;br /&gt;
ckdu soll wie das Tool ''du'' auch, eine Auflistung aller Dateien/Ordner und deren Größe. Zusätzlich soll ckdu diese Liste auch sortieren und menschlich Lesbar gestalten (in KB, MB, GB).&lt;br /&gt;
&lt;br /&gt;
= Stufen =&lt;br /&gt;
== 1. Stufe ==&lt;br /&gt;
Ordnerinhalt einlesen und ausgeben.&lt;br /&gt;
Ähnliche wie:  ls -1s&lt;br /&gt;
&lt;br /&gt;
&amp;lt;u&amp;gt;''so koennte das dann aussehen:''&amp;lt;/u&amp;gt;&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
    4 img&lt;br /&gt;
29832 HelloWorld.pdf&lt;br /&gt;
    0 HelloWorld.snm&lt;br /&gt;
   36 HelloWorld.tex&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Vorgabe ===&lt;br /&gt;
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base1.c;hb=HEAD Download (base1.c)]&lt;br /&gt;
&lt;br /&gt;
== 2. Stufe ==&lt;br /&gt;
Refactoring !&lt;br /&gt;
Eingelesene Inhalte in einer Liste speichern.&lt;br /&gt;
Diese Liste wieder ausgeben.&lt;br /&gt;
&lt;br /&gt;
=== Vorgabe ===&lt;br /&gt;
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base2.c;hb=HEAD Download (base2.c)]&lt;br /&gt;
&lt;br /&gt;
== 3. Stufe ==&lt;br /&gt;
&lt;br /&gt;
Ordnerinhalte rekursiv aufaddieren&lt;br /&gt;
&lt;br /&gt;
&amp;lt;u&amp;gt;''so koennte das dann aussehen:''&amp;lt;/u&amp;gt;&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
  0.0M HelloWorld.snm&lt;br /&gt;
 30.0M HelloWorld.pdf&lt;br /&gt;
 36.0K HelloWorld.tex&lt;br /&gt;
153.0M img/&lt;br /&gt;
 12.0M   uebung.png&lt;br /&gt;
 24.0M   vortrag.png&lt;br /&gt;
 86.0M   world2.png&lt;br /&gt;
  3.0M   world.png&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Vorgabe ===&lt;br /&gt;
* [http://git.goodpoint.de/?p=ckdu-live.git;a=blob_plain;f=base3.c;hb=HEAD Download (base3.c)]&lt;br /&gt;
&lt;br /&gt;
== 4. Stufe ==&lt;br /&gt;
sortieren nach Groesse (absteigend)&lt;br /&gt;
&lt;br /&gt;
&amp;lt;u&amp;gt;''so koennte das dann aussehen:''&amp;lt;/u&amp;gt;&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
153.0M img/&lt;br /&gt;
 12.0M   uebung.png&lt;br /&gt;
 24.0M   vortrag.png&lt;br /&gt;
 86.0M   world2.png&lt;br /&gt;
  3.0M   world.png&lt;br /&gt;
 30.0M HelloWorld.pdf&lt;br /&gt;
 36.0K HelloWorld.tex&lt;br /&gt;
  0.0M HelloWorld.snm&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;br /&gt;
&lt;br /&gt;
=== Vorgabe ===&lt;br /&gt;
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 3.''&lt;br /&gt;
&lt;br /&gt;
== 5. Stufe ==&lt;br /&gt;
In dieser Stufe folgen alle wichtigen Sachen, die man noch beachten '''muss''', wenn man auf dem Dateisystem operiert.&lt;br /&gt;
Außerdem bieten wir einige Ideen mit denen du dein ckdu erweiteren kannst :)&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* Symlinks nur einmal folgen (Parameter)&lt;br /&gt;
* Hardlinks nur einmal folgen&lt;br /&gt;
* Ordentliches Fehler-handling&lt;br /&gt;
* du-parameter-kompatible:&lt;br /&gt;
** &amp;quot;--max-depth&amp;quot;&lt;br /&gt;
** basierend auf getopt&lt;br /&gt;
** Device verlassen verbieten&lt;br /&gt;
* Wird nicht von den Betreuern betreut:&lt;br /&gt;
** Farbige Ausgabe&lt;br /&gt;
** Interaktivität&lt;br /&gt;
** Einlesen mit mehreren Threads?&lt;br /&gt;
&lt;br /&gt;
=== Vorgabe ===&lt;br /&gt;
* ''Absichtlich keine Vorgabe. Bitte erweitert eure Lösung von Stufe 4.''&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14931</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14931"/>
		<updated>2010-09-17T10:05:41Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;}&lt;br /&gt;
&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/Pythagoras-Triplet | Pythagoras-Triplet]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen &amp;lt;br&amp;gt; if-Bedingungen&lt;br /&gt;
 | Gabriel P.&lt;br /&gt;
 | seba(2010)&lt;br /&gt;
 | [[Ckurs2010/Pythagoras-Triplet/Musterloesung | Pythagoras-Triplet]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Array, Dateien lesen&lt;br /&gt;
 | Alex K.&lt;br /&gt;
 | Gabriel (2010)&lt;br /&gt;
 | vorhanden bitte reinstellen&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), Alex K. (2010)&lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | vorhanden bitte reinstellen&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | Katrin (2010)&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs/DreiD/Musterloesung | 3D]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 | Gabriel (2010)&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/Punktstrukturen| Punktstrukturen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Structs, Unions, Pointer&lt;br /&gt;
 | [[Benutzer:Mutax|Florian]] (2010)&lt;br /&gt;
 | Alex K. (2010)&lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | [[Benutzer:Mutax|Florian]]&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | Paul B. (w.i.p.)&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DTMF-Encoder | DTMF-Encoder]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Pointer, Arrays, Umgang mit Audiodaten&lt;br /&gt;
 | Alexander K.&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &amp;lt;!-- [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Bus Error/Musterlösung | Bus Error]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Code Layout/Musterlösung | Code Layout]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Refactoring/Musterlösung | Refactoring]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 | seba(2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden  --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 | martin (2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs/integral/Musterlösung | Musterloesung]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/Tron | Tron]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe&lt;br /&gt;
 | seba&lt;br /&gt;
 |&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/TicTacToe | TicTacToe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe&lt;br /&gt;
 | Martin&lt;br /&gt;
 | sdyroff (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2010/TicTacToe/Musterlösung | TicTacToe]] --&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14930</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14930"/>
		<updated>2010-09-17T10:04:21Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;}&lt;br /&gt;
&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/Pythagoras-Triplet | Pythagoras-Triplet]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen &amp;lt;br&amp;gt; if-Bedingungen&lt;br /&gt;
 | Gabriel P.&lt;br /&gt;
 | seba(2010)&lt;br /&gt;
 | [[Ckurs2010/Pythagoras-Triplet/Musterloesung | Pythagoras-Triplet]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Array, Dateien lesen&lt;br /&gt;
 | Alex K.&lt;br /&gt;
 | Gabriel (2010)&lt;br /&gt;
 | vorhanden bitte reinstellen&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), Alex K. (2010)&lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | vorhanden bitte reinstellen&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | Katrin (2010)&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/DreiD/Musterloesung | 3D]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 | Gabriel (2010)&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/Punktstrukturen| Punktstrukturen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Structs, Unions, Pointer&lt;br /&gt;
 | [[Benutzer:Mutax|Florian]] (2010)&lt;br /&gt;
 | Alex K. (2010)&lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | [[Benutzer:Mutax|Florian]]&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | Paul B. (w.i.p.)&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DTMF-Encoder | DTMF-Encoder]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Pointer, Arrays, Umgang mit Audiodaten&lt;br /&gt;
 | Alexander K.&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &amp;lt;!-- [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Bus Error/Musterlösung | Bus Error]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Code Layout/Musterlösung | Code Layout]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2009/Refactoring/Musterlösung | Refactoring]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 | seba(2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden  --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 | martin (2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs/integral/Musterlösung | Musterloesung]] --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/Tron | Tron]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe&lt;br /&gt;
 | seba&lt;br /&gt;
 |&lt;br /&gt;
 | &amp;lt;!-- vorhanden --&amp;gt;&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/TicTacToe | TicTacToe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | SDL (Simple Directmedia Layer) kennen lernen, graphische Ausgabe&lt;br /&gt;
 | Martin&lt;br /&gt;
 | sdyroff (2010)&lt;br /&gt;
 | &amp;lt;!-- [[Ckurs2010/TicTacToe/Musterlösung | TicTacToe]] --&amp;gt;&lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD/Musterl%C3%B6sung&amp;diff=14929</id>
		<title>C-Kurs/DreiD/Musterlösung</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD/Musterl%C3%B6sung&amp;diff=14929"/>
		<updated>2010-09-17T09:50:11Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Dies ist die &amp;lt;code&amp;gt;main.c&amp;lt;/code&amp;gt;. Mit FIGURE kannst du eine von drei Figuren auswählen.&lt;br /&gt;
&lt;br /&gt;
&amp;lt;pre&amp;gt;&lt;br /&gt;
#include &amp;lt;stdio.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;stdlib.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;math.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;quot;screen.h&amp;quot;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Figur: 0=Würfel,1=Kegel,2=Ellipsoid */&lt;br /&gt;
#define FIGURE 1&lt;br /&gt;
&lt;br /&gt;
/* Rotationsgeschwindigkeiten (frei wählbar) */&lt;br /&gt;
&lt;br /&gt;
#define ROT_V_ALPHA 0.1f&lt;br /&gt;
&lt;br /&gt;
#define ROT_V_BETA 0.03f&lt;br /&gt;
&lt;br /&gt;
#define LIGHT_V_ALPHA 0.0f&lt;br /&gt;
&lt;br /&gt;
#define LIGHT_V_BETA 0.0f&lt;br /&gt;
/* Drahtgitter-Modus: 1=an, 0=aus */&lt;br /&gt;
#define WIREFRAMES_MODE 0&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* 3x3-Matrix-Repräsentation als 2-dimensionales Array */&lt;br /&gt;
&lt;br /&gt;
typedef float Matrix[3][3];&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Transformation */&lt;br /&gt;
&lt;br /&gt;
Matrix transform;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Zeichenfarbe mit Werten zwischen 0 und 1 */&lt;br /&gt;
&lt;br /&gt;
float color_r;&lt;br /&gt;
&lt;br /&gt;
float color_g;&lt;br /&gt;
&lt;br /&gt;
float color_b;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktueller Lichtvektor */&lt;br /&gt;
&lt;br /&gt;
float lgt_x;&lt;br /&gt;
&lt;br /&gt;
float lgt_y;&lt;br /&gt;
&lt;br /&gt;
float lgt_z;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* --- Prototypen --- */&lt;br /&gt;
&lt;br /&gt;
/* Gibt eine 3x3-Matrix aus und beendet das Programm */&lt;br /&gt;
void print_matrix(Matrix matrix);&lt;br /&gt;
/* Gibt einen Vektor, bestehend aus 3 floats, aus und beendet das Programm */&lt;br /&gt;
&lt;br /&gt;
void print_vector(float x, float y, float z);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Bildet aus zwei Winkeln die resultierende Transformationsmatrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void refresh_transformation_matrix(float alpha, float beta)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
     /* Rotationsmatrizen */&lt;br /&gt;
&lt;br /&gt;
     Matrix rot_x = {&lt;br /&gt;
&lt;br /&gt;
                     {     1.0f    ,    0.0f    ,    0.0f    },&lt;br /&gt;
&lt;br /&gt;
                     {     0.0f    ,  cos(beta) , -sin(beta) },&lt;br /&gt;
&lt;br /&gt;
                     {     0.0f    ,  sin(beta) ,  cos(beta) }&lt;br /&gt;
&lt;br /&gt;
                    };&lt;br /&gt;
&lt;br /&gt;
     Matrix rot_y = {&lt;br /&gt;
&lt;br /&gt;
                     {  cos(alpha),    0.0f     ,  sin(alpha)},&lt;br /&gt;
&lt;br /&gt;
                     {    0.0f    ,    1.0f     ,    0.0f    },&lt;br /&gt;
&lt;br /&gt;
                     { -sin(alpha),    0.0f     ,  cos(alpha)}&lt;br /&gt;
&lt;br /&gt;
                    };&lt;br /&gt;
                    &lt;br /&gt;
     /* Matrix-Multiplikation */&lt;br /&gt;
&lt;br /&gt;
     int i,j,k;&lt;br /&gt;
&lt;br /&gt;
     for(i=0;i&amp;lt;3;i++)&lt;br /&gt;
&lt;br /&gt;
     for(j=0;j&amp;lt;3;j++)&lt;br /&gt;
&lt;br /&gt;
     {  &lt;br /&gt;
&lt;br /&gt;
     transform[i][j] = 0;&lt;br /&gt;
&lt;br /&gt;
     for(k=0;k&amp;lt;3;k++)&lt;br /&gt;
&lt;br /&gt;
         transform[i][j] += rot_x[j][k]*rot_y[k][i];            &lt;br /&gt;
&lt;br /&gt;
     }&lt;br /&gt;
     &lt;br /&gt;
     &lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Rotiert den gegebenen Vektor, bestehend aus 3 Floats, entsprechend der aktuellen transform-Matrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void apply_transform(float * x,float * y,float * z)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    float h_x = *x;&lt;br /&gt;
    float h_y = *y;&lt;br /&gt;
    float h_z = *z;&lt;br /&gt;
&lt;br /&gt;
    *x = transform[0][0] * h_x + transform[0][1] * h_y + transform[0][2] * h_z;&lt;br /&gt;
&lt;br /&gt;
    *y = transform[1][0] * h_x + transform[1][1] * h_y + transform[1][2] * h_z;&lt;br /&gt;
&lt;br /&gt;
    *z = transform[2][0] * h_x + transform[2][1] * h_y + transform[2][2] * h_z;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Zeichnet ein dreidimensionales Dreieck auf die zweidimensionale Fläche entsprechend der aktuellen transform-Matrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void render_primitive(float x1,float y1,float z1, float x2,float y2,float z2, float x3,float y3,float z3)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
    /* Koordinaten transformieren */&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x1,&amp;amp;y1,&amp;amp;z1);&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x2,&amp;amp;y2,&amp;amp;z2);&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x3,&amp;amp;y3,&amp;amp;z3);&lt;br /&gt;
    &lt;br /&gt;
    /* Kreuzprodukt bilden */&lt;br /&gt;
    float v1[3] = {x2-x1,y2-y1,z2-z1};&lt;br /&gt;
&lt;br /&gt;
    float v2[3] = {x3-x1,y3-y1,z3-z1}; &lt;br /&gt;
    float cross_x = v1[1]*v2[2] - v1[2]*v2[1];&lt;br /&gt;
&lt;br /&gt;
    float cross_y = v1[2]*v2[0] - v1[0]*v2[2];&lt;br /&gt;
&lt;br /&gt;
    float cross_z = v1[0]*v2[1] - v1[1]*v2[0];&lt;br /&gt;
    float cross = 1/sqrt(cross_x*cross_x + cross_y*cross_y + cross_z*cross_z); //Normalisieren&lt;br /&gt;
    cross_x *= cross;&lt;br /&gt;
    cross_y *= cross;&lt;br /&gt;
    cross_z *= cross;&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
    /* Culling */&lt;br /&gt;
&lt;br /&gt;
    if(cross_z&amp;lt;0)&lt;br /&gt;
&lt;br /&gt;
        return;&lt;br /&gt;
&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
    /* Licht */&lt;br /&gt;
&lt;br /&gt;
    float brightness = lgt_x*cross_x + lgt_y*cross_y + lgt_z*cross_z;&lt;br /&gt;
    brightness = (brightness + 0.5)/1.5f;&lt;br /&gt;
    if(brightness&amp;gt;1)&lt;br /&gt;
&lt;br /&gt;
        brightness = 1;&lt;br /&gt;
&lt;br /&gt;
    if(brightness&amp;lt;0.025)&lt;br /&gt;
&lt;br /&gt;
        brightness = 0.025;&lt;br /&gt;
    brightness = sqrt(brightness);&lt;br /&gt;
    &lt;br /&gt;
    /* Dreiecke zeichnen */&lt;br /&gt;
&lt;br /&gt;
    set_color(color_r*brightness,color_g*brightness,color_b*brightness);    &lt;br /&gt;
    if(WIREFRAMES_MODE)&lt;br /&gt;
    {&lt;br /&gt;
        draw_line(x1,y1,x2,y2);&lt;br /&gt;
        draw_line(x2,y2,x3,y3);&lt;br /&gt;
        draw_line(x3,y3,x1,y1);&lt;br /&gt;
    }else&lt;br /&gt;
&lt;br /&gt;
        draw_triangle(x1,y1,x2,y2,x3,y3);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* ----------------Ab hier alles Vorlage---------------- */&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Rotationen */&lt;br /&gt;
&lt;br /&gt;
float trf_alpha = 0;&lt;br /&gt;
&lt;br /&gt;
float trf_beta = 0;&lt;br /&gt;
&lt;br /&gt;
float lgt_alpha = 0;&lt;br /&gt;
&lt;br /&gt;
float lgt_beta = 0;&lt;br /&gt;
/* Anzahl der bisher gezeichneten Frames */&lt;br /&gt;
int c_time = 0;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Gibt eine 3x3-Matrix aus und beendet das Programm&lt;br /&gt;
*/&lt;br /&gt;
void print_matrix(Matrix matrix)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[0][0],matrix[0][1],matrix[0][2]);&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[1][0],matrix[1][1],matrix[1][2]);&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[2][0],matrix[2][1],matrix[2][2]);&lt;br /&gt;
&lt;br /&gt;
     system(&amp;quot;PAUSE&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
     exit(EXIT_SUCCESS);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Gibt einen Vektor, bestehend aus 3 floats, aus und beendet das Programm&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void print_vector(float x, float y, float z)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,x,y,z);&lt;br /&gt;
&lt;br /&gt;
     system(&amp;quot;PAUSE&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
     exit(EXIT_SUCCESS);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Setzt die aktuelle Farbe für nachfolgende render_* Aufrufe&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void refresh_color(float r,float g, float b)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     color_r = r;&lt;br /&gt;
&lt;br /&gt;
     color_g = g;&lt;br /&gt;
&lt;br /&gt;
     color_b = b;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Rendert dreidimensionale viereckige Fläche (bestehend aus zwei Dreiecken) &lt;br /&gt;
*/&lt;br /&gt;
void render_face(float x1,float y1,float z1, float x2,float y2,float z2, float x3,float y3,float z3, float x4,float y4,float z4)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
    render_primitive(x1,y1,z1,x2,y2,z2,x3,y3,z3);&lt;br /&gt;
&lt;br /&gt;
    render_primitive(x1,y1,z1,x3,y3,z3,x4,y4,z4);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Komplette Ausgabe&lt;br /&gt;
*/&lt;br /&gt;
void output()&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    /* Transformation aktualisieren */&lt;br /&gt;
&lt;br /&gt;
    refresh_transformation_matrix(trf_alpha,trf_beta);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Licht-Vektor setzen */&lt;br /&gt;
&lt;br /&gt;
    lgt_x = cos(lgt_beta);&lt;br /&gt;
&lt;br /&gt;
    lgt_y = sin(lgt_beta);&lt;br /&gt;
&lt;br /&gt;
    lgt_z = sin(lgt_alpha)*lgt_x;   &lt;br /&gt;
    lgt_x = cos(lgt_alpha)*lgt_x;&lt;br /&gt;
        &lt;br /&gt;
&lt;br /&gt;
    /* Szene rendern */ &lt;br /&gt;
&lt;br /&gt;
    begin_scene();&lt;br /&gt;
    if(FIGURE == 1)&lt;br /&gt;
    {&lt;br /&gt;
        /* Kegel */&lt;br /&gt;
        int acc = 32; //Genauigkeit&lt;br /&gt;
    	float rad = 1.2; //Radius&lt;br /&gt;
    	int i;&lt;br /&gt;
    	float ang = 0, lst_ang;&lt;br /&gt;
    	for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    	{&lt;br /&gt;
    	    refresh_color(0.8,0.8,1);&lt;br /&gt;
    	    lst_ang = ang;&lt;br /&gt;
    	    ang = (float)i/acc*2*M_PI;&lt;br /&gt;
            render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
            if(i%2 == 0)&lt;br /&gt;
                refresh_color(0.1,0.1,0.5);&lt;br /&gt;
            else&lt;br /&gt;
                refresh_color(0.2,0.2,0.6);&lt;br /&gt;
            render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
        }&lt;br /&gt;
    }else&lt;br /&gt;
    if(FIGURE == 2)&lt;br /&gt;
    {&lt;br /&gt;
        /* Ellipsoid */&lt;br /&gt;
        refresh_color(1,1,1);&lt;br /&gt;
        float rad_a = 1.0f, rad_b = 1.5f; //Radius a und b&lt;br /&gt;
    	int acc = 14; //Genauigkeit&lt;br /&gt;
    	int i, j;&lt;br /&gt;
    	float x = -1, lst_x;&lt;br /&gt;
    	float ang = 0, lst_ang;&lt;br /&gt;
    	float rad = 0, lst_rad, anim_rad;	 &lt;br /&gt;
    	for(j=1; j&amp;lt;acc+1; j++)&lt;br /&gt;
        {&lt;br /&gt;
            lst_x = x;&lt;br /&gt;
            lst_rad = rad;&lt;br /&gt;
            x = (((float)j/acc)-0.5)*2;&lt;br /&gt;
            if(x&amp;gt;1)&lt;br /&gt;
                x = 1;&lt;br /&gt;
            rad = sqrt(1-x*x)*(1+sin(((float)c_time+x*15)*0.4f)*0.05f);&lt;br /&gt;
            ang = 0;&lt;br /&gt;
            for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
            {&lt;br /&gt;
                lst_ang=ang;&lt;br /&gt;
                ang=(float)i/acc*2*M_PI;&lt;br /&gt;
                render_face( sin(lst_ang)*lst_rad*rad_a,lst_x,cos(lst_ang)*lst_rad*rad_b, &lt;br /&gt;
            	             sin(ang)*lst_rad*rad_a,lst_x,cos(ang)*lst_rad*rad_b, &lt;br /&gt;
                             sin(ang)*rad*rad_a,x,cos(ang)*rad*rad_b, &lt;br /&gt;
            	             sin(lst_ang)*rad*rad_a,x,cos(lst_ang)*rad*rad_b );&lt;br /&gt;
            }&lt;br /&gt;
        }&lt;br /&gt;
    }else{&lt;br /&gt;
    &lt;br /&gt;
        /* Würfel */&lt;br /&gt;
&lt;br /&gt;
    	refresh_color(1,0,0);&lt;br /&gt;
&lt;br /&gt;
    	render_face(-1,-1,1, 1,-1,1, 1,1,1, -1,1,1); //Front&lt;br /&gt;
    	render_face(1,-1,-1, -1,-1,-1, -1,1,-1, 1,1,-1); //Back&lt;br /&gt;
    	refresh_color(1,1,0);&lt;br /&gt;
&lt;br /&gt;
    	render_face(-1,-1,1, -1,1,1, -1,1,-1, -1,-1,-1); //Left&lt;br /&gt;
&lt;br /&gt;
    	render_face(1,1,1, 1,-1,1, 1,-1,-1, 1,1,-1); //Right&lt;br /&gt;
&lt;br /&gt;
    	refresh_color(1,0.5,0);&lt;br /&gt;
&lt;br /&gt;
    	render_face(1,-1,1, -1,-1,1, -1,-1,-1, 1,-1,-1); //Top&lt;br /&gt;
    	render_face(-1,1,1, 1,1,1, 1,1,-1, -1,1,-1); //Bottom &lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    end_scene();&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main(void)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    /* Fenster initialisieren */&lt;br /&gt;
&lt;br /&gt;
    if(create_window(400,400,0x220000) != 0){&lt;br /&gt;
&lt;br /&gt;
        printf(&amp;quot;Fehler beim Fenster Erstellen. Bitte wende dich an einen Tutor.\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
        return EXIT_FAILURE;&lt;br /&gt;
&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    /* Startwerte setzen */&lt;br /&gt;
    zoom = 0.5;&lt;br /&gt;
&lt;br /&gt;
    trf_alpha = M_PI/2;&lt;br /&gt;
&lt;br /&gt;
    trf_beta = M_PI/3;&lt;br /&gt;
&lt;br /&gt;
    lgt_alpha = M_PI*2/3;&lt;br /&gt;
&lt;br /&gt;
    lgt_beta = -M_PI/4;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Figur wiederholt rendern */&lt;br /&gt;
&lt;br /&gt;
    while(1)&lt;br /&gt;
&lt;br /&gt;
    {&lt;br /&gt;
        trf_alpha += ROT_V_ALPHA;&lt;br /&gt;
&lt;br /&gt;
        trf_beta += ROT_V_BETA;&lt;br /&gt;
        lgt_alpha += LIGHT_V_ALPHA;&lt;br /&gt;
&lt;br /&gt;
        lgt_beta += LIGHT_V_BETA;&lt;br /&gt;
&lt;br /&gt;
    	output();&lt;br /&gt;
    	c_time++;&lt;br /&gt;
&lt;br /&gt;
    	usleep(50000);&lt;br /&gt;
&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Programmende */    &lt;br /&gt;
&lt;br /&gt;
    close_window();&lt;br /&gt;
&lt;br /&gt;
    return EXIT_SUCCESS;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD/Musterl%C3%B6sung&amp;diff=14928</id>
		<title>C-Kurs/DreiD/Musterlösung</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD/Musterl%C3%B6sung&amp;diff=14928"/>
		<updated>2010-09-17T09:47:43Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;&amp;lt;pre&amp;gt;&lt;br /&gt;
#include &amp;lt;stdio.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;stdlib.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;lt;math.h&amp;gt;&lt;br /&gt;
&lt;br /&gt;
#include &amp;quot;screen.h&amp;quot;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Rotationsgeschwindigkeiten (frei wählbar) */&lt;br /&gt;
&lt;br /&gt;
#define ROT_V_ALPHA 0.1f&lt;br /&gt;
&lt;br /&gt;
#define ROT_V_BETA 0.03f&lt;br /&gt;
&lt;br /&gt;
#define LIGHT_V_ALPHA 0.0f&lt;br /&gt;
&lt;br /&gt;
#define LIGHT_V_BETA 0.0f&lt;br /&gt;
/* Drahtgitter-Modus: 1=an, 0=aus */&lt;br /&gt;
#define WIREFRAMES_MODE 1&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* 3x3-Matrix-Repräsentation als 2-dimensionales Array */&lt;br /&gt;
&lt;br /&gt;
typedef float Matrix[3][3];&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Transformation */&lt;br /&gt;
&lt;br /&gt;
Matrix transform;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Zeichenfarbe mit Werten zwischen 0 und 1 */&lt;br /&gt;
&lt;br /&gt;
float color_r;&lt;br /&gt;
&lt;br /&gt;
float color_g;&lt;br /&gt;
&lt;br /&gt;
float color_b;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktueller Lichtvektor */&lt;br /&gt;
&lt;br /&gt;
float lgt_x;&lt;br /&gt;
&lt;br /&gt;
float lgt_y;&lt;br /&gt;
&lt;br /&gt;
float lgt_z;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* --- Prototypen --- */&lt;br /&gt;
&lt;br /&gt;
/* Gibt eine 3x3-Matrix aus und beendet das Programm */&lt;br /&gt;
void print_matrix(Matrix matrix);&lt;br /&gt;
/* Gibt einen Vektor, bestehend aus 3 floats, aus und beendet das Programm */&lt;br /&gt;
&lt;br /&gt;
void print_vector(float x, float y, float z);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Bildet aus zwei Winkeln die resultierende Transformationsmatrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void refresh_transformation_matrix(float alpha, float beta)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
     /* Rotationsmatrizen */&lt;br /&gt;
&lt;br /&gt;
     Matrix rot_x = {&lt;br /&gt;
&lt;br /&gt;
                     {     1.0f    ,    0.0f    ,    0.0f    },&lt;br /&gt;
&lt;br /&gt;
                     {     0.0f    ,  cos(beta) , -sin(beta) },&lt;br /&gt;
&lt;br /&gt;
                     {     0.0f    ,  sin(beta) ,  cos(beta) }&lt;br /&gt;
&lt;br /&gt;
                    };&lt;br /&gt;
&lt;br /&gt;
     &lt;br /&gt;
     //... (rot_y)&lt;br /&gt;
                    &lt;br /&gt;
     /* Matrix-Multiplikation */&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
     //...&lt;br /&gt;
     &lt;br /&gt;
     &lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Rotiert den gegebenen Vektor, bestehend aus 3 Floats, entsprechend der aktuellen transform-Matrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void apply_transform(float * x,float * y,float * z)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    float h_x = *x;&lt;br /&gt;
    float h_y = *y;&lt;br /&gt;
    float h_z = *z;&lt;br /&gt;
    /* Transformation anwenden */&lt;br /&gt;
&lt;br /&gt;
    *x = h_x;&lt;br /&gt;
&lt;br /&gt;
    *y = h_y;&lt;br /&gt;
&lt;br /&gt;
    *z = h_z;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Zeichnet ein dreidimensionales Dreieck auf die zweidimensionale Fläche entsprechend der aktuellen transform-Matrix&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void render_primitive(float x1,float y1,float z1, float x2,float y2,float z2, float x3,float y3,float z3)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
    /* Koordinaten transformieren */&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x1,&amp;amp;y1,&amp;amp;z1);&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x2,&amp;amp;y2,&amp;amp;z2);&lt;br /&gt;
&lt;br /&gt;
    apply_transform(&amp;amp;x3,&amp;amp;y3,&amp;amp;z3);&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
    /* Culling */&lt;br /&gt;
    &lt;br /&gt;
&lt;br /&gt;
    //...&lt;br /&gt;
&lt;br /&gt;
    &lt;br /&gt;
    /* Dreiecke zeichnen */&lt;br /&gt;
&lt;br /&gt;
    set_color(color_r, color_g, color_b);    &lt;br /&gt;
    if(WIREFRAMES_MODE)&lt;br /&gt;
    {&lt;br /&gt;
        draw_line(x1,y1, x2,y2);&lt;br /&gt;
        draw_line(x2,y2, x3,y3);&lt;br /&gt;
        draw_line(x3,y3, x1,y1);&lt;br /&gt;
    }else&lt;br /&gt;
&lt;br /&gt;
        draw_triangle(x1,y1, x2,y2, x3,y3);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* ----------------Ab hier alles Vorlage---------------- */&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/* Aktuelle Rotationen */&lt;br /&gt;
&lt;br /&gt;
float trf_alpha = 0;&lt;br /&gt;
&lt;br /&gt;
float trf_beta = 0;&lt;br /&gt;
&lt;br /&gt;
float lgt_alpha = 0;&lt;br /&gt;
&lt;br /&gt;
float lgt_beta = 0;&lt;br /&gt;
/* Anzahl der bisher gezeichneten Frames */&lt;br /&gt;
int c_time = 0;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Gibt eine 3x3-Matrix aus und beendet das Programm&lt;br /&gt;
*/&lt;br /&gt;
void print_matrix(Matrix matrix)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[0][0],matrix[0][1],matrix[0][2]);&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[1][0],matrix[1][1],matrix[1][2]);&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,matrix[2][0],matrix[2][1],matrix[2][2]);&lt;br /&gt;
&lt;br /&gt;
     system(&amp;quot;PAUSE&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
     exit(EXIT_SUCCESS);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Gibt einen Vektor, bestehend aus 3 floats, aus und beendet das Programm&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void print_vector(float x, float y, float z)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     printf(&amp;quot;%f  %f  %f\n&amp;quot;,x,y,z);&lt;br /&gt;
&lt;br /&gt;
     system(&amp;quot;PAUSE&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
     exit(EXIT_SUCCESS);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Setzt die aktuelle Farbe für nachfolgende render_* Aufrufe&lt;br /&gt;
*/&lt;br /&gt;
&lt;br /&gt;
void refresh_color(float r,float g, float b)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
     color_r = r;&lt;br /&gt;
&lt;br /&gt;
     color_g = g;&lt;br /&gt;
&lt;br /&gt;
     color_b = b;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Rendert dreidimensionale viereckige Fläche (bestehend aus zwei Dreiecken) &lt;br /&gt;
*/&lt;br /&gt;
void render_face(float x1,float y1,float z1, float x2,float y2,float z2, float x3,float y3,float z3, float x4,float y4,float z4)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
&lt;br /&gt;
    render_primitive(x1,y1,z1,x2,y2,z2,x3,y3,z3);&lt;br /&gt;
&lt;br /&gt;
    render_primitive(x1,y1,z1,x3,y3,z3,x4,y4,z4);&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
/*&lt;br /&gt;
Komplette Ausgabe&lt;br /&gt;
*/&lt;br /&gt;
void output()&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    /* Transformation aktualisieren */&lt;br /&gt;
&lt;br /&gt;
    refresh_transformation_matrix(trf_alpha,trf_beta);&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Licht-Vektor setzen */&lt;br /&gt;
&lt;br /&gt;
    lgt_x = cos(lgt_beta);&lt;br /&gt;
&lt;br /&gt;
    lgt_y = sin(lgt_beta);&lt;br /&gt;
&lt;br /&gt;
    lgt_z = sin(lgt_alpha)*lgt_x;   &lt;br /&gt;
    lgt_x = cos(lgt_alpha)*lgt_x;&lt;br /&gt;
        &lt;br /&gt;
&lt;br /&gt;
    /* Szene rendern */ &lt;br /&gt;
&lt;br /&gt;
    begin_scene();&lt;br /&gt;
&lt;br /&gt;
    refresh_color(1,0,0);&lt;br /&gt;
&lt;br /&gt;
    render_face(-1,-1,1, 1,-1,1, 1,1,1, -1,1,1); //Front&lt;br /&gt;
    render_face(1,-1,-1, -1,-1,-1, -1,1,-1, 1,1,-1); //Back&lt;br /&gt;
    refresh_color(1,1,0);&lt;br /&gt;
&lt;br /&gt;
    render_face(-1,-1,1, -1,1,1, -1,1,-1, -1,-1,-1); //Left&lt;br /&gt;
&lt;br /&gt;
    render_face(1,1,1, 1,-1,1, 1,-1,-1, 1,1,-1); //Right&lt;br /&gt;
&lt;br /&gt;
    refresh_color(1,0.5,0);&lt;br /&gt;
&lt;br /&gt;
    render_face(1,-1,1, -1,-1,1, -1,-1,-1, 1,-1,-1); //Top&lt;br /&gt;
    render_face(-1,1,1, 1,1,1, 1,1,-1, -1,1,-1); //Bottom &lt;br /&gt;
&lt;br /&gt;
    end_scene();&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
int main(void)&lt;br /&gt;
&lt;br /&gt;
{&lt;br /&gt;
    /* Fenster initialisieren */&lt;br /&gt;
&lt;br /&gt;
    if(create_window(400,400,0x220000) != 0){&lt;br /&gt;
&lt;br /&gt;
        printf(&amp;quot;Fehler beim Fenster Erstellen. Bitte wende dich an einen Tutor.\n&amp;quot;);&lt;br /&gt;
&lt;br /&gt;
        return EXIT_FAILURE;&lt;br /&gt;
&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
    /* Startwerte setzen */&lt;br /&gt;
    zoom = 0.5;&lt;br /&gt;
&lt;br /&gt;
    trf_alpha = M_PI/2;&lt;br /&gt;
&lt;br /&gt;
    trf_beta = M_PI/3;&lt;br /&gt;
&lt;br /&gt;
    lgt_alpha = M_PI*2/3;&lt;br /&gt;
&lt;br /&gt;
    lgt_beta = -M_PI/4;&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Figur wiederholt rendern */&lt;br /&gt;
&lt;br /&gt;
    while(1)&lt;br /&gt;
&lt;br /&gt;
    {&lt;br /&gt;
        trf_alpha += ROT_V_ALPHA;&lt;br /&gt;
&lt;br /&gt;
        trf_beta += ROT_V_BETA;&lt;br /&gt;
        lgt_alpha += LIGHT_V_ALPHA;&lt;br /&gt;
&lt;br /&gt;
        lgt_beta += LIGHT_V_BETA;&lt;br /&gt;
&lt;br /&gt;
    	output();&lt;br /&gt;
    	c_time++;&lt;br /&gt;
&lt;br /&gt;
    	usleep(50000);&lt;br /&gt;
&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
    /* Programmende */    &lt;br /&gt;
&lt;br /&gt;
    close_window();&lt;br /&gt;
&lt;br /&gt;
    return EXIT_SUCCESS;&lt;br /&gt;
&lt;br /&gt;
}&lt;br /&gt;
&lt;br /&gt;
&amp;lt;/pre&amp;gt;&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Studentendatenbank&amp;diff=14829</id>
		<title>C-Kurs/Studentendatenbank</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Studentendatenbank&amp;diff=14829"/>
		<updated>2010-09-12T17:38:13Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Teil f */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe soll eine kleine Studentendatenbank erstellt werden.&lt;br /&gt;
&lt;br /&gt;
== Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
=== Teil a ===&lt;br /&gt;
Schreibe eine Struktur &amp;lt;tt&amp;gt;student&amp;lt;/tt&amp;gt;, die eine Matrikelnummer, einen Vornamen und einen Nachnamen mit jeweils passenden Datentypen enthält.&lt;br /&gt;
&lt;br /&gt;
=== Teil b ===&lt;br /&gt;
Deklariere einen Pointer auf einen solchen Student und alloziere ihn passend. Initialisiere seine Martrikelnummer, seinen Vornamen und Nachnamen mit sinnvollen Werten.&lt;br /&gt;
Schreibe nun eine Funktion &amp;lt;tt&amp;gt;print_student&amp;lt;/tt&amp;gt;, die einen Pointer auf einen Studenten übergeben bekommt und seine Details in einer Zeile ausgeben soll. Teste diese Funktion jetzt mit dem zuvor angelegten Studenten.&lt;br /&gt;
&lt;br /&gt;
=== Teil c ===&lt;br /&gt;
Lege jetzt ein Array von Pointern auf Studenten der Größe 10 an. Initialisiere zunächst alle Elemente mit &amp;lt;tt&amp;gt;NULL&amp;lt;/tt&amp;gt;, damit sich darin keine unvorhersehbaren Studenten befinden. Weise nun dem ersten Element den aus Teil b angelegten Studenten zu.&lt;br /&gt;
Schreibe nun einen Funktion &amp;lt;tt&amp;gt;print_students_db&amp;lt;/tt&amp;gt;, die ein Pointer auf ein Array aus Studenten-Pointern übergeben bekommt, und alle Studenten ausgeben soll. Prüfe dabei, ob das jeweilige Element nicht &amp;lt;tt&amp;gt;NULL&amp;lt;/tt&amp;gt; ist und benutzte dann die vorher geschriebene Funktion &amp;lt;tt&amp;gt;print_student&amp;lt;/tt&amp;gt;. Wende nun die Funktion auf die Studentendatenbank an.&lt;br /&gt;
&lt;br /&gt;
=== Teil d ===&lt;br /&gt;
Lege nun mindestens zwei weitere Studenten in der Datenbank an und lösche den ersten (dabei nicht vergessen, den Speicher wieder freizugeben). Gebe erneut die Studentendatenbank aus und überprüfe das Ergebnis.&lt;br /&gt;
&lt;br /&gt;
=== Teil e ===&lt;br /&gt;
Am Ende wollen wir wieder aufräumen. Schreibe dazu eine Funktion &amp;lt;tt&amp;gt;clear_db&amp;lt;/tt&amp;gt;, die die Studentendatenbank (wieder ein Pointer auf das Studenten-Pointer-Array) übergeben bekommt, und darin alle Einträge, die nicht &amp;lt;tt&amp;gt;NULL&amp;lt;/tt&amp;gt; sind, löscht (also deren Speicher freigibt).&lt;br /&gt;
&lt;br /&gt;
=== Teil f ===&lt;br /&gt;
Schreibe eine Funktion &amp;lt;tt&amp;gt;get_student_index&amp;lt;/tt&amp;gt;, die eine Matrikelnummer und die Studentendatenbank übergeben bekommt. Sie soll die Indexposition im Array zurückgeben, an der der gesuchte Student zu finden ist. Falls es keinen Student gibt, der die Matrikelnummer hat, soll ''-1'' zurückgegeben werden.&lt;br /&gt;
&lt;br /&gt;
Schreibe anschließend eine Funktion &amp;lt;tt&amp;gt;add_student&amp;lt;/tt&amp;gt;, die Matrikelnummer, Vor- und Nachname des hinzuzufügenden Studenten und die Studentendatenbank übergeben bekommt. Benutzte darin die Funktion &amp;lt;tt&amp;gt;get_student_index&amp;lt;/tt&amp;gt;, um sicherzustellen, dass du nicht mehrere Studenten mit derselben Matrikelnummer in der Datenbank hast. Füge den neuen Studenten im Array an der ersten Position, die &amp;lt;tt&amp;gt;NULL&amp;lt;/tt&amp;gt; enthält, ein. Überlege dir auch einen passenden Rückgabewert, der angibt, ob der Student erfolgreich eingefügt wurde.&lt;br /&gt;
&lt;br /&gt;
Teste die Funktion, indem du mindestens drei Studenten einfügst, von denen zwei die gleiche Matrikelnummer haben.&lt;br /&gt;
&lt;br /&gt;
=== Teil g ===&lt;br /&gt;
Schreibe eine Funktion &amp;lt;tt&amp;gt;del_student&amp;lt;/tt&amp;gt;, die eine Matrikelnummer und die Studentendatenbank übergeben bekommt. Sie soll den entsprechenden Studenten löschen. Verwende den Rückgabewert ebenfalls, um erfolgreichen Löschen anzuzeigen.&lt;br /&gt;
&lt;br /&gt;
Teste die Funktion, indem du einen vorher eingefügten Studenten wieder löscht.&lt;br /&gt;
&lt;br /&gt;
=== Zusatzaufgabe ===&lt;br /&gt;
Schreibe jetzt eine menügesteuerte Benutzerschnittstelle, die Hinzufügen und Löschen eines Studenten, und Ausgeben der kompletten Datenbank, ermöglicht.&lt;br /&gt;
&lt;br /&gt;
== Kommentare ==&lt;br /&gt;
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf &amp;quot;bearbeiten&amp;quot; und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit &amp;quot;Vorschau zeigen&amp;quot; kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.&lt;br /&gt;
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)&lt;br /&gt;
--&amp;gt;&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14828</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14828"/>
		<updated>2010-09-12T17:27:28Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 | Eugen R. (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/Buchstaben_zählen | Buchstaben zählen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Array, Dateien lesen&lt;br /&gt;
 | Alex K.&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | Katrin (2010, wird nochmal überarbeitet bzw. mit mehr erklärendem Text versehen)&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | Florian S.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 |  [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | Paul B. (w.i.p.)&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs/integral/Musterlösung | Musterloesung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Taschenrechner2.0&amp;diff=14827</id>
		<title>C-Kurs/Taschenrechner2.0</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Taschenrechner2.0&amp;diff=14827"/>
		<updated>2010-09-12T16:26:21Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Aufgabenstellung */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;=== Aufgabenstellung ===&lt;br /&gt;
Dies ist eine Knobelaufgabe. Falls du dir die erste Taschenrechneraufgabe noch nicht angesehen hast, dann hole dies bitte [[Ckurs2009/Taschenrechner|hier]] nach.&lt;br /&gt;
&lt;br /&gt;
Deine Aufgabe ist es, den Taschenrechner aus der vorherigen Aufgabe zu überarbeiten. Wie du sicherlich bereits festgestellt hast, kann der Taschenrechner nicht sehr viel: Nur die Grundrechenarten sind möglich und mehrere Berechnungen hintereinander funktionieren nicht. Auch schön wäre es, wenn es eine Möglichkeit gäbe das Assoziativgesetz umzusetzen. Nimm dir einige Momente dafür Zeit und überlege dir, wie du diese Aufgabe lösen würdest. &lt;br /&gt;
&lt;br /&gt;
Wenn du einen Ansatz hast, dann empfiehlt es sich, diese mit einem Tutor zu besprechen; gemeinsam könnt ihr dann überlegen, ob dies eine sinnvolle Lösung des Problems ist. (Sinn dieser Aufgabe ist es nicht unbedingt dich im Programmieren zu schulen, sondern eher dein Gefühl für das ''richtige'' Lösen von Aufgaben zu schärfen.)&lt;br /&gt;
&lt;br /&gt;
=== Hinweise ===&lt;br /&gt;
&lt;br /&gt;
Wenn das scanf mal die Eingabe ignoriert einfach im formatstring ein Leerzeichen an den Anfang stellen, das wirft aus dem Tastaturpuffer alle Zeichen weg die nicht zum Format passen...&lt;br /&gt;
&lt;br /&gt;
== Kommentare ==&lt;br /&gt;
Wenn du Anmerkungen zur Aufgabe hast oder Lob und Kritik loswerden möchtest, ist hier die richtige Stelle dafür. Klicke einfach ganz rechts auf &amp;quot;bearbeiten&amp;quot; und schreibe deinen Kommentar direkt ins Wiki. Keine Scheu, es geht nichts kaputt ;)&lt;br /&gt;
&lt;br /&gt;
&amp;lt;!--&lt;br /&gt;
Als kleine Starthilfe folgt ein Beispiel, wie so ein Kommentar formatiert sein könnte. Mit &amp;quot;Vorschau zeigen&amp;quot; kannst du dir ansehen, was deine Änderung bewirken würde, ohne wirklich etwas zu ändern.&lt;br /&gt;
Du musst übrigens außerhalb dieses auskommentieren Bereichs schreiben ;)&lt;br /&gt;
&lt;br /&gt;
==== Robert ====&lt;br /&gt;
Na mal schauen, ob irgendjemand diese Funktion wirklich benutzt. Ich fände es jedenfalls toll.&lt;br /&gt;
--&amp;gt;&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs_Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14794</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14794"/>
		<updated>2010-09-08T15:05:29Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | Eugen R (2010) - bin dabei&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 | Eugen (2010) bin dabei&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | Katrin (2010, wird nochmal überarbeitet bzw. mit mehr erklärendem Text versehen)&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | Florian S.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 |  [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs/integral/Musterlösung | Musterloesung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14793</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14793"/>
		<updated>2010-09-08T15:04:45Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | Eugen R (2010) - bin dabei&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 | Eugen (2010) bin dabei&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | Katrin (2010, wird nochmal überarbeitet bzw. mit mehr erklärendem Text versehen)&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | Florian S.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 |  [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (2010i)&lt;br /&gt;
 | [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs/integral/Musterlösung | Musterloesung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Compiler,_Pr%C3%A4prozessor,_Header_Files&amp;diff=14777</id>
		<title>C-Kurs/Compiler, Präprozessor, Header Files</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/Compiler,_Pr%C3%A4prozessor,_Header_Files&amp;diff=14777"/>
		<updated>2010-09-07T19:14:19Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;#Schreibe ein Hello-World-Programm. Kompiliere und teste es.&lt;br /&gt;
#Sieh dir den Präprozessor-Output an.&lt;br /&gt;
#Unterteile das Programm in 3 Dateien main.c, hello.c und bye.c. In hello.c und bye.c, definiere eine Funktion die einen Namen als char-Pointer übergeben bekommt, und jweils &amp;quot;Hello, &amp;lt;name&amp;gt;!&amp;quot; bzw &amp;quot;Bye, &amp;lt;name&amp;gt;!&amp;quot; auf dem Bildschirm ausgibt. In der main-Funktion der Datei main.c, rufe diese Funktionen hintereinander auf. Kompiliere und teste das Programm.&lt;br /&gt;
#Kompiliere die 3 Programme separat, einmal mit und ohne die -c Option. Was passiert? Wie kannst du es dir erklären?&lt;br /&gt;
#Linke die entstandenen Objektdateien aus 3. und führe das Programm aus.&lt;br /&gt;
#Schreibe die externen Deklarationen aus main.c in zwei Header Files. Achte darauf, Mehrfachinklusion zu vermeiden. Inkludiere diese Header Files.&lt;br /&gt;
#Kompiliere und teste das Programm.&lt;br /&gt;
#Sieh dir den Präprozessor-Output an.&lt;br /&gt;
#Schreibe in einer Header-Datei ein Makro LOG wie in der Vorlesung beschrieben. Inkludiere diese Datei in dein Hello-World-Programm aus 1. und ersetze printf durch LOG. Schalte Debugging im Code ein und aus, teste jeweils das Programm und sieh dir den Präprozessor-Output an.&lt;br /&gt;
#Schalte Debugging nun beim Kompilieren des Programms ein und aus.&lt;br /&gt;
#Füge Debug Levels hinzu. Benutze dein Programm aus 3. und gib bei Debug Level 0 nichts, bei Level 1 &amp;quot;Hello, World!&amp;quot;, und bei Level 2 zusätzlich &amp;quot;Bye, World!&amp;quot; aus.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14768</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14768"/>
		<updated>2010-09-06T17:13:54Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Funktionen &amp;lt;br&amp;gt; Rekursion&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken|digitales Schloesser knacken]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Kontrollstrukturen &amp;lt;br&amp;gt;Bitweise Operatoren&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/digitalesSchloesserKnacken/Musterlösung | digitales Schloesser knacken]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul B.(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | Florian S.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 |  [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (grad_dabei)&lt;br /&gt;
 | [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Bus Error/Musterlösung | Bus Error]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (2010)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs/integral/Musterlösung | Musterloesung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14746</id>
		<title>C-Kurs/Übungsaufgaben</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/%C3%9Cbungsaufgaben&amp;diff=14746"/>
		<updated>2010-09-04T09:55:23Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Die Aufgaben */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;Wir haben jeder Aufgabe eine Einschätzung ihrer Schwierigkeit auf einer Skala von 1 bis 10 vorangestellt. Bei dieser Einschätzung sind wir von einem Gehirn ausgegangen, für welches das jeweilige Themengebiet völlig neu ist, das jedoch schon ein ganz gutes Verständnis dafür hat wie eine Programmiersprache denn so funktioniert. &lt;br /&gt;
Entsprechend kann eine schwer bewertete Aufgabe aus einem frühen Themengebiet für manch einen sehr einfach oder eine leicht bewertete aus einem späten Themengebiet für einen anderen sehr schwer sein. Es ist nur ein Wert, der euch helfen soll eure nächste Aufgabe zu wählen. &lt;br /&gt;
&lt;br /&gt;
Falls ihr Anmerkungen zu den Aufgaben habt, könnt ihr die Diskussionsseiten der jeweiligen Aufgaben nutzen.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Schwierigkeitsgrade ==&lt;br /&gt;
&lt;br /&gt;
#  Reines Tutorial. Man muss nicht viel selbst denken&lt;br /&gt;
#  ...&lt;br /&gt;
#  Leichte Übungsaufgabe. Studies, die noch eher unsicher sind werden hier gut begleitet.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Typische Aufgabe. Man muss den Kopf benutzen, bekommt an schwierigen Stellen aber Hilfestellungen.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Herausfordernd, eher etwas für Studies die etwas fitter sind.&lt;br /&gt;
#  ...&lt;br /&gt;
#  Auch erfahrene Programmierer werden hier ein bis zwei Übungen beschäftigt sein&amp;lt;br&amp;gt;&amp;lt;br&amp;gt;&lt;br /&gt;
#  Tja, die Idee war da. Wir finden sie auch gut, aber es könnte wirklich anstrengend werden.&lt;br /&gt;
&lt;br /&gt;
== Die Aufgaben ==&lt;br /&gt;
&lt;br /&gt;
{| class=&amp;quot;wikitable sortable&amp;quot; border=&amp;quot;0&amp;quot; cellpadding=&amp;quot;4&amp;quot; cellspacing=&amp;quot;2&amp;quot;&lt;br /&gt;
 |- bgcolor=&amp;quot;#D8D8D8&amp;quot;&lt;br /&gt;
 !Aufgabe&lt;br /&gt;
 !Schwierigkeit&lt;br /&gt;
 !Vorwissen&lt;br /&gt;
 !Lerneffekte&lt;br /&gt;
 !Bearbeiter&lt;br /&gt;
 !Korrektur gelesen&lt;br /&gt;
 !Musterlösung&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Von der Konsole zum HelloWorld | Von der Konsole zum HelloWorld]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Konsole benutzen, Hello World&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fakultät | Fakultät]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Schleifen&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Daniel (2009), &lt;br /&gt;
 |  &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge|Fibonacci-Folge]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Folgenglieder der Fibonacci-Folge berechnen&lt;br /&gt;
 | Paul B.&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Fibonacci-Folge/Musterlösung | Fibonacci-Folge]]&lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten|Rekursives Arbeiten]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Bekannte Operatoren wie + durch Funktionen succ und neg nachbilden&lt;br /&gt;
 | Eugen R.&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Rekursives_arbeiten/Musterlösung | Rekursives Arbeiten]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Base64 | Base64]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1. VL&lt;br /&gt;
 | Operatoren&lt;br /&gt;
 | Sebastian D.&lt;br /&gt;
 | Paul(2010)&lt;br /&gt;
 | [[Ckurs2009/Base64/Musterlösung | Base64]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe | Ein- und Ausgabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Ausgabe derselben&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/EingabeAusgabe/Musterlösung | Ein- und Ausgabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner | Taschenrechner]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Eingabe+Ausgabe&amp;lt;br&amp;gt;Mathematische Operatoren&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner/Musterlösung | Taschenrechner]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/VerschachtelteSchleifen | Verschachtelte Schleifen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Umgang mit mehreren verschachtelten Schleifen&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 |&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Glückspiel | Glücksspiel]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Anwenden von Fallunterscheidungen und Einlesen von Werten aus der Konsole&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | AlexanderK (2009), &lt;br /&gt;
 | [[Ckurs2009/Glückspiel/Musterlösung | Glückspiel]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Wochentag | Wochentagsrechnung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Mathematikverständniss&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | nion (Musterlösung noch nicht vorhanden)  (2009), &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0 | Taschenrechner ''2.0'']]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Knobeln&amp;lt;br&amp;gt;Komplexes Aufgaben lösen&lt;br /&gt;
 | [[Benutzer:Mario|Mario]]&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Taschenrechner2.0/Musterlösung | Taschenrechner ''2.0'']]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Call by reference | Call by reference]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Einfache Anwendung von &amp;amp;/*&lt;br /&gt;
 | sping&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Call by reference/Musterlösung | Call by reference]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2010/String to Double | String to Double]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Original-Dokumentation anwenden (Opengroup, man pages)&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Const correctness&amp;lt;br&amp;gt;Strings&lt;br /&gt;
 | sping&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Text processing | Text processing]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4, 6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Strings&amp;lt;br&amp;gt;Pointer-Arithmetik&amp;lt;br&amp;gt;Pointer auf Pointer&amp;lt;br&amp;gt;Refactoring&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Text processing/Musterlösung | Text processing]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Palindrome | Palindrome]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Strings&lt;br /&gt;
 | [[Benutzer:Dank|Daniel K.]]&lt;br /&gt;
 | nion (2009), &lt;br /&gt;
 | [[Ckurs2009/Palindrome/Musterlösung | Palindrome ]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping | (Pointer) Swapping]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Pointer und Arrays benutzen, generisches swap&lt;br /&gt;
 | Katrin&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/(Pointer) Swapping/Musterlösung | (Pointer) Swapping]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation | Matrizenmultiplikation]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mehrdimensionale Arrays&amp;lt;br&amp;gt;const correctness&lt;br /&gt;
 | sping&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 | [[Ckurs2009/Matrizenmultiplikation/Musterlösung | Matrizenmultiplikation]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/DreiD | 3D mit C]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Mathematische Rechenoperationen, Algorithmik&lt;br /&gt;
 | AndreasF&lt;br /&gt;
 | &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe | Arrayuebergabe]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4/5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Einlesen von Benutzereingaben&amp;lt;br&amp;gt;Pointer und Pointerarithmetik&lt;br /&gt;
 | nion&lt;br /&gt;
 | Martin K. (2009), &lt;br /&gt;
 | [[Ckurs2009/Arrayuebergabe/Musterlösung | Arrayuebergabe]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank | Studentendatenbank]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | struct, Pointer, Arrays&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/Studentendatenbank/Musterlösung | Studentendatenbank]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Sammelbestellung | Sammelbestellung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2-5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Listen, Pointer, Speicherverwaltung&lt;br /&gt;
 | Florian S.&lt;br /&gt;
 | [[Benutzer:Mario|Mario]] (2009), &lt;br /&gt;
 |  [[Ckurs2009/Sammelbestellung/Musterlösung | Sammelbestellung]] &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen | Zahlen sagen]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |4. VL&lt;br /&gt;
 | Umgang mit Zeichenketten&lt;br /&gt;
 | Martin K.&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Zahlen_sagen/Musterlösung | Zahlen sagen]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Compiler, Präprozessor, Header Files | Compiler, Präprozessor, Header Files]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Arbeiten mit mehreren Quellcode-Dateien, Kompilieren und Linken, Header-Dateien und #include, debugging-Makro verwenden&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | AndyF (grad_dabei)&lt;br /&gt;
 | [https://wiki.freitagsrunde.org/Ckurs2009/Vortrag05 siehe Folien]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Bus Error | Bus Error]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5. VL&lt;br /&gt;
 | Pointer, wie entsteht ein bus error&lt;br /&gt;
 | Katrin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug | BubbleSort Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen eines Programmes mit gdb&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | [[Ckurs2009/BubbleSortDebug/Musterlösung | BubbleSort Debugging]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Debug | Debugging]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |1-8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Debuggen einer Anwendung nach Wahl&lt;br /&gt;
 | aeichner&lt;br /&gt;
 |&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Code Layout | Code Layout]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Kleinere Codeschipsel mit kleinen Unsauberkeiten&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs2009/Code Layout/Musterlösung | Code Layout]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Refactoring | Refactoring]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-9&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7. VL&lt;br /&gt;
 | Wie verbessere ich den Quellcode eines Programmes.&lt;br /&gt;
 | Daniel&lt;br /&gt;
 | &lt;br /&gt;
 | [[Ckurs2009/Refactoring/Musterlösung | Refactoring]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Cat | Cat]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2. VL&lt;br /&gt;
 | Arbeiten mit Dateien&amp;lt;br&amp;gt;Kommandozeilenparameter&lt;br /&gt;
 | nion&lt;br /&gt;
 | sping (2009), &lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Pong | Pong]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9.VL (eigentlich 2.VL)&lt;br /&gt;
 | allgemeiner Programmablauf, fortgeschrittene Konsolenausgaben/eingaben&lt;br /&gt;
 | AlexanderK&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden &lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/Buchhaltung | Buchhaltung]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5.VL&lt;br /&gt;
 | Lesen aus Dateien&lt;br /&gt;
 | reiner&lt;br /&gt;
 | AndyF (grad_dabei)&lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StringArraySortieren | StringArraySortieren]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |8&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Konsolparameter, Funktionspointer, stdlib&lt;br /&gt;
 | reiner&lt;br /&gt;
 |&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/integral | integral]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |2&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3. VL&lt;br /&gt;
 | Funktionspointer&lt;br /&gt;
 | reiner&lt;br /&gt;
 | [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | [[Ckurs/integral/Musterlösung | Musterloesung]]&lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs/forschleife | forschleife]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |6. VL&lt;br /&gt;
 | Bug (zum Knobeln)&lt;br /&gt;
 | reiner&lt;br /&gt;
 | nion (2009), [[Benutzer:Tkroenert|TKroenert]] (2010)&lt;br /&gt;
 | vorhanden&lt;br /&gt;
 |- bgcolor=&amp;quot;#E8E8E8&amp;quot;&lt;br /&gt;
 | [[Ckurs/libgdsl | GDSL]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |5-7&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Anwendung der Generic Data Structures Library&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
 |- bgcolor=&amp;quot;#F5F5F5&amp;quot;&lt;br /&gt;
 | [[Ckurs2009/StdLib | Standard C Library]]&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |3&lt;br /&gt;
 | align=&amp;quot;center&amp;quot; |9. VL&lt;br /&gt;
 | Recherche in der Standard C Bibliothek&lt;br /&gt;
 | martin&lt;br /&gt;
 | &lt;br /&gt;
 | &lt;br /&gt;
|}&lt;br /&gt;
&lt;br /&gt;
== Kleine und große Probleme ==&lt;br /&gt;
&lt;br /&gt;
* Die Tubit-Accounts haben nicht /bin/bash als shell, so dass die &amp;lt;strong&amp;gt;Cursortasten&amp;lt;/strong&amp;gt; nicht funktionieren. Workaround: als erstes Kommando 'bash' eingeben, man sieht dann auch in welchem Verzeichnis man gerade ist.&lt;br /&gt;
* wenn man nur den Promt 'bash-0.12' oder so erhält, also ohne das Verzeichnis in dem man ist, folgendes Kommando eingeben: &amp;lt;tt&amp;gt;export PS1='\u@\h:\w$ '&amp;lt;/tt&amp;gt; oder zum dauerhaften Speichern: &amp;lt;tt&amp;gt; echo &amp;quot;export PS1='\u@\h:\w$ '&amp;quot; &amp;gt;&amp;gt; ~/.bashrc &amp;lt;/tt&amp;gt;&lt;br /&gt;
&lt;br /&gt;
== Musterlösungen ==&lt;br /&gt;
Die Lösungen zu den Aufgaben werden nach den jeweiligen Übungen hier veröffentlicht. Falls dies nicht geschieht, bitte den zuständigen Tutor fragen.&lt;br /&gt;
&lt;br /&gt;
== Links ==&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
* [[Ckurs2009/Feedback|Feedback zum Kurs 2009]]&lt;br /&gt;
&lt;br /&gt;
[[Kategorie:CKurs]]&lt;br /&gt;
[[Kategorie:CKurs Aufgaben]]&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14745</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14745"/>
		<updated>2010-09-04T09:49:51Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die [http://docs.freitagsrunde.org/Veranstaltungen/ckurs_2010/aufgaben/C-3D_V1.0_Vorlagen.zip Vorgaben] herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter den bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main.c zwischen begin_scene und end_scene einfach durch deinen Algorithmus. Denke aber daran, dass, sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14727</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14727"/>
		<updated>2010-09-01T17:51:24Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter den bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main.c zwischen begin_scene und end_scene einfach durch deinen Algorithmus. Denke aber daran, dass, sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14726</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14726"/>
		<updated>2010-09-01T17:43:11Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Andere Figuren */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter den bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main.c zwischen begin_scene und end_scene einfach durch deinen Algorithmus. Denke aber daran, dass, sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14725</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14725"/>
		<updated>2010-09-01T17:42:05Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Andere Figuren */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter den bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass, sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14724</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14724"/>
		<updated>2010-09-01T17:41:20Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Culling */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter den bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14723</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14723"/>
		<updated>2010-09-01T17:40:49Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Vorgabe */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel. Für die Rotationen fehlen die zu ergänzenen Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14722</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14722"/>
		<updated>2010-09-01T17:37:26Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Andere Figuren */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    /* Kegel */&lt;br /&gt;
    refresh_color(1,1,1);&lt;br /&gt;
    int acc = 32; //Genauigkeit&lt;br /&gt;
    float rad = 1.2; //Radius&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang = 0, lst_ang;&lt;br /&gt;
    for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    {&lt;br /&gt;
        refresh_color(0.8,0.8,1);&lt;br /&gt;
        lst_ang = ang;&lt;br /&gt;
        ang = (float)i/acc*2*M_PI;&lt;br /&gt;
        render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
        if(i%2 == 0)&lt;br /&gt;
            refresh_color(0.1,0.1,0.5);&lt;br /&gt;
        else&lt;br /&gt;
            refresh_color(0.2,0.2,0.6);&lt;br /&gt;
        render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14721</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14721"/>
		<updated>2010-09-01T17:35:18Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran, in der Konsole die Pfeiltaste Hoch zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrat mit Linien zu sehen. Dies ist ein frontal betrachteter Drahtgitter-Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen. Beende das Programm mit Ctrl+C in der Konsole.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir [http://de.wikipedia.org/wiki/Drehmatrix Rotationsmatrizen], welche wir als 3x3-Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Bisher sind in den Methoden nur Zuweisungen ohne Effekt. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4-Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3-Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bis dahin gezeichneten Flächen ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob wir von innen auf die Fläche schauen. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher von der Vorgabe bereits gesetzt wird und normalisiert ist. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da die Länge des Vektors das Ergebnis verfälscht.&lt;br /&gt;
&lt;br /&gt;
Das Ergebnis deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis jeweils mit den Farb-Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um die Lichtausbreitung etc. anzupassen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du Lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte und die Koordinaten der Dreiecke/Vierecke jeweils im Uhrzeigersinn angegeben werden müssen.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
        /* Kegel */&lt;br /&gt;
        refresh_color(1,1,1);&lt;br /&gt;
        int acc = 32; //Genauigkeit&lt;br /&gt;
    	float rad = 1.2; //Radius&lt;br /&gt;
    	int i;&lt;br /&gt;
    	float ang = 0, lst_ang;&lt;br /&gt;
    	for(i=1; i&amp;lt;acc+1; i++)&lt;br /&gt;
    	{&lt;br /&gt;
    	    refresh_color(0.8,0.8,1);&lt;br /&gt;
    	    lst_ang = ang;&lt;br /&gt;
    	    ang = (float)i/acc*2*M_PI;&lt;br /&gt;
            render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
            if(i%2 == 0)&lt;br /&gt;
                refresh_color(0.1,0.1,0.5);&lt;br /&gt;
            else&lt;br /&gt;
                refresh_color(0.2,0.2,0.6);&lt;br /&gt;
            render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
        }&lt;br /&gt;
&lt;br /&gt;
Theoretisch können auch animierte Figuren gezeichnet werden. Benutze dazu den Zähler &amp;quot;c_time&amp;quot;.&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14719</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14719"/>
		<updated>2010-09-01T10:20:19Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrad zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Beachte: Matrix-Multiplikation ist nicht kommutativ.&lt;br /&gt;
&lt;br /&gt;
Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
=== Licht ===&lt;br /&gt;
Wir wollen nun die einfachste Art von Licht implementieren: Direktionales Licht. &lt;br /&gt;
Wir haben lediglich einen Licht-Vektor (lgt_x,lgt_y,lgt_z), welcher in der Vorgabe bereits gesetzt wird. Zeigt dieser nun in die gleiche Richtung, wie unser Kreuzprodukt von eben, gehen wir davon aus, dass das Dreieck frontal beleuchtet wird. Wie könnte man prüfen, inwiefern die Richtungen der Vektoren übereinstimmen? Als wichtiger Hinweis: Das Kreuzprodukt muss noch normalisiert werden, da große Rechtecke sonst unkontrolliert aufleuchten.&lt;br /&gt;
&lt;br /&gt;
Das Ergebniss deiner Berechnung soll ein Float zwischen 0 (nicht angeleuchtet) und 1 (voll angeleuchtet) sein. Multipliziere dein Ergebnis mit den Parametern in &amp;quot;set_color&amp;quot;-Aufruf.&lt;br /&gt;
Wenn alles stimmt, sollte schon ein (wenn auch etwas zu kontrastreiches) Licht zu sehen sein. Experimentiere mit dem Helligkeitswert um Lichtausbreitung etc. zu erreichen. Setze beispielsweise eine Untergrenze größer 0, bilde Wurzeln oder/und gleiche den Wert mit Addition und Multiplikation an.&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;br /&gt;
&lt;br /&gt;
    int acc=32; //Genauigkeit&lt;br /&gt;
    int i;&lt;br /&gt;
    float ang=0;&lt;br /&gt;
    float lst_ang;&lt;br /&gt;
    float rad=1.2;&lt;br /&gt;
    for(i=1;i&amp;lt;acc+1;i++)&lt;br /&gt;
    {&lt;br /&gt;
    	 refresh_color(0.8,0.8,1);&lt;br /&gt;
    	 lst_ang=ang;&lt;br /&gt;
    	 ang=(float)i/acc*2*M_PI;&lt;br /&gt;
         render_primitive(0,-1.2,0, sin(ang)*rad,1.2,cos(ang)*rad, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad);&lt;br /&gt;
         if(i%2 == 0)&lt;br /&gt;
             refresh_color(0.1,0.1,0.5);&lt;br /&gt;
         else&lt;br /&gt;
             refresh_color(0.2,0.2,0.6);&lt;br /&gt;
         render_primitive(0,1.2,0, sin(lst_ang)*rad,1.2,cos(lst_ang)*rad, sin(ang)*rad,1.2,cos(ang)*rad);&lt;br /&gt;
    }&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14718</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14718"/>
		<updated>2010-09-01T09:04:11Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Quadrad zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;apply_transform&amp;quot; geschehen.&lt;br /&gt;
apply_transform nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, dass der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass es bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. &lt;br /&gt;
&lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte (x1,y1, ... ,z3) transformiert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14691</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14691"/>
		<updated>2010-08-28T15:57:09Z</updated>

		<summary type="html">&lt;p&gt;AndyF: &lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Rechteck zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
== Rechenoperationen ==&lt;br /&gt;
&lt;br /&gt;
Für die Aufgabe könnte es hilfreich sein, einen Schmierzettel bereitzulegen.&lt;br /&gt;
&lt;br /&gt;
LinA-Grundkenntnisse sind von Vorteil.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;projection&amp;quot; geschehen.&lt;br /&gt;
Projection nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, das der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass wir bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte projeziert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14690</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14690"/>
		<updated>2010-08-28T15:49:54Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Culling */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Rechteck zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;projection&amp;quot; geschehen.&lt;br /&gt;
Projection nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, das der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
&lt;br /&gt;
Die Überlegung ist, dass wir bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte projeziert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14689</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14689"/>
		<updated>2010-08-28T15:48:04Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Transformation und Projektion */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Rechteck zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;projection&amp;quot; geschehen.&lt;br /&gt;
Projection nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, das der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
Die Überlegung ist, dass wir bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte projeziert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (Somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14688</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14688"/>
		<updated>2010-08-28T15:47:38Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Transformation und Projektion */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Rechteck zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;projection&amp;quot; geschehen.&lt;br /&gt;
Projection nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, das der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der Würfel beim Rotieren verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
Die Überlegung ist, dass wir bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte projeziert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (Somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
	<entry>
		<id>https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14687</id>
		<title>C-Kurs/DreiD</title>
		<link rel="alternate" type="text/html" href="https://wiki.freitagsrunde.org/index.php?title=C-Kurs/DreiD&amp;diff=14687"/>
		<updated>2010-08-28T15:45:23Z</updated>

		<summary type="html">&lt;p&gt;AndyF: /* Culling */&lt;/p&gt;
&lt;hr /&gt;
&lt;div&gt;In dieser Aufgabe wollen wir eine stark vereinfachte 3D-Anwendung schreiben, welche einen 3D-Körper rotieren lässt.&lt;br /&gt;
Du kannst selbst entscheiden, bis zu welchem Zwischenergebnis du die Aufgabe lösen willst.&lt;br /&gt;
&lt;br /&gt;
== Vorgabe ==&lt;br /&gt;
Lade dir zunächst die Vorgaben herunter. Die &amp;quot;screen&amp;quot;-Dateien brauchen nicht verändert werden, sie sorgen für die grafische Ausgabe. Deine Aufgabe ist es, die Rechenoperationen der main.c zu ergänzen.&lt;br /&gt;
&lt;br /&gt;
Kompiliert wird das Programm mit:&lt;br /&gt;
 gcc main.c screen.c -lX11 -lm -o 3D.out&lt;br /&gt;
Denke daran die Pfeiltaste Hoch in der Shell zu verwenden, statt es jedesmal neu einzugeben.&lt;br /&gt;
&lt;br /&gt;
Werden die Vorgaben direkt kompiliert und ausgeführt, ist ein Rechteck zu sehen. Dies ist ein frontal betrachteter Würfel, welcher eigentlich schon gedreht wird, jedoch fehlen die Transformationsoperationen.&lt;br /&gt;
&lt;br /&gt;
=== Transformation und Projektion === &lt;br /&gt;
Wir befinden uns in der Methode &amp;quot;transformation&amp;quot; und wollen den Würfel nun erst um die X-Achse und dann um die Y-Achse drehen. Dazu verwenden wir Rotationsmatrizen, welche wir als 3x3 Array umsetzen, wobei wir uns einigen, dass der erste Array-Index die Zeile und der zweite die Spalte der Matrix ist. Die rot_x ist bereits vorgegeben. Initialisiere auf gleiche Weise darunter die rot_y, unter Verwendung des Winkels &amp;quot;alpha&amp;quot;.&lt;br /&gt;
Schreibe direkt darunter einen Algorithmus, der die Matrizen rot_x und rot_y miteinander multipliziert und das Ergebnis auf der globalen Matrix &amp;quot;transform&amp;quot; speichert. Versuche dabei Schleifen, statt konstanter Indizes zu verwenden. Die resultierende Matrix auf einen Vektor angewandt, rotiert diesen nun entsprechend um die X- und Y-Achse. Dies soll in der Methode &amp;quot;projection&amp;quot; geschehen.&lt;br /&gt;
Projection nimmt einen Punkt der Figur im Raum und soll diesen entsprechend der aktuellen Rotation verändern. Die Parameter sind Call-by-Reference. Ändere mit Hilfe der globalen &amp;quot;transform&amp;quot;-Matrix die Inhalte der Parameter so, das der x-y-z-Vektor am Ende rotiert ist (Matrix-Vektor-Multiplikation).&lt;br /&gt;
&lt;br /&gt;
Teste deine Implementierung. Zu diesem Zeitpunkt sollte schon ein rotierender Würfel zu sehen sein. Falls der beim rotieren Würfel verzerrt wird, sind möglicherweise Indizes bei der Matrix Multiplikation verdreht.&lt;br /&gt;
Nebenbei: echte 3D-Anwendungen verwenden 4x4 Matrizen, damit auch Translationen möglich sind. Da wir aber nur rotieren wollen, reichen 3x3 Matrizen.&lt;br /&gt;
&lt;br /&gt;
=== Culling ===&lt;br /&gt;
Schalte den &amp;quot;WIREFRAMES_MODE&amp;quot; auf 0, wodurch der Würfel ausgefüllte Flächen bekommt und sieh dir zunächst das Ergebnis an. Zu sehen ist das Problem, dass wir jede Fläche einfach zeichnen, egal ob sie vor oder hinter dem bisher gezeichneten Würfel ist. Die allgemeine und standardmäßige Lösung wäre ein Z-Buffer, wodurch Pixel, die verdeckt werden würden, einfach nicht gezeichnet werden. Dies ist für unsere Zwecke zu aufwendig, daher nehmen wir eine speziellere Lösung: Culling.&lt;br /&gt;
Die Überlegung ist, dass wir bei einem soliden Würfel nicht sein kann, dass wir irgendeine fläche von innen sehen, da diese immer von einer Außenfläche verdeckt wird. Außerdem verdeckt nie eine Außenfläche eine andere (sichtbare) Außenfläche, da der Würfel konvex ist. Wir brauchen also nur die Außenflächen zu zeichnen. Wir befinden uns in der Methode &amp;quot;draw_primitive&amp;quot;, welche ein einzelnes Dreieck zeichnet. Nachdem die Punkte projeziert wurden, muss geprüft werden, ob die drei Punkte im Uhrzeigersinn angeordnet sind. Bilde dazu aus den Koordinaten die beiden Richtungsvektoren des Dreiecks (der Ortsvektor ist egal) und bilde aus ihnen das Kreuzprodukt. Nun kann man sich überlegen, dass das Dreieck genau dann von außen zu sehen ist, wenn die Z-Koordinate des Kreuzprodukts kleiner als 0 ist (Somit brauch man streng genommen die X- und Y-Koordinaten des Kreuzprodukts gar nicht). Ist die Z-Koordinate also größer-gleich 0, verlasse die Methode vorzeitig (vor dem Zeichnen des Dreiecks).&lt;br /&gt;
&lt;br /&gt;
Nun sollte ein rotierender, ausgefüllter, fehlerfreier Würfel zu sehen sein.&lt;br /&gt;
&lt;br /&gt;
== Andere Figuren ==&lt;br /&gt;
Wenn du lust hast, kannst du mit Hilfe von draw_primitive und draw_face eigene 3D-Figuren erstellen. Ersetze dazu den Würfel in der main einfach durch deinen Algorithmus. Denke aber daran, dass sofern Wireframes aus sind, die Figur konvex sein sollte.&lt;br /&gt;
Eine mögliche Figur ist der Kegel:&lt;/div&gt;</summary>
		<author><name>AndyF</name></author>
		
	</entry>
</feed>