Roman_Schenk
/
snp-lab-code
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Jenkins published newest html+pdf version

This commit is contained in:
Jenkins 2022-03-07 09:22:35 +01:00
parent 79e0889268
commit fa1975d692
5 changed files with 165 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
build/html/P03_Bit_Operation_struct_typedef/README.html
View File

@ -84,21 +84,33 @@
<h3>1.1 Übungen<a class="headerlink" href="#ubungen" title="Permalink to this headline"></a></h3> <h3>1.1 Übungen<a class="headerlink" href="#ubungen" title="Permalink to this headline"></a></h3>
<section id="basis-operationen"> <section id="basis-operationen">
<h4>1. Basis Operationen<a class="headerlink" href="#basis-operationen" title="Permalink to this headline"></a></h4> <h4>1. Basis Operationen<a class="headerlink" href="#basis-operationen" title="Permalink to this headline"></a></h4>
<p>Manipulationen von einzelnen Bits gehören zu den Basis Operationen und dienen als Grundlagen um weitere komplexere Konstrukte zu schaffen. Verfollständigen sie folgendes Beispiel mit den drei Basis Operationen:</p> <p>Manipulationen von einzelnen Bits gehören zu den Basis Operationen und dienen als Grundlagen um weitere komplexere Konstrukte zu schaffen.</p>
<p>Verfollständigen sie folgendes Beispiel mit den drei Basis Operationen. Dabei gibt die Variable <code class="docutils literal notranslate"><span class="pre">bit</span></code> an, welches Bit manipuliert werden soll (Denken sie daran, dass die Bit-Positionen bei 0 beginnen. Bit 3 ist also das vierte Bit von rechts). Bei den gefragten Manipulationen, soll nur das angegebene <code class="docutils literal notranslate"><span class="pre">bit</span></code> geändert werden und der Rest soll unverändert bleiben:</p>
<ul class="simple">
<li><p>Bit 3 setzen: <code class="docutils literal notranslate"><span class="pre">0011</span> <span class="pre">=&gt;</span> <span class="pre">1011</span></code></p></li>
<li><p>Bit 1 löschen: <code class="docutils literal notranslate"><span class="pre">1011</span> <span class="pre">=&gt;</span> <span class="pre">1001</span></code></p></li>
<li><p>Bit 0 flippen: <code class="docutils literal notranslate"><span class="pre">1001</span> <span class="pre">=&gt;</span> <span class="pre">1000</span></code></p></li>
</ul>
<p>Versuchen sie die Operationen in C umzusetzen:</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span> <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span>
<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span> <span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"></span>
<span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mh">0x75</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">bit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span><span class="p">;</span><span class="w"> </span><span class="c1">// bit at position 3</span> <span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">bit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">3</span><span class="p">;</span><span class="w"> </span><span class="c1">// bit at position 3</span>
<span class="w"> </span><span class="c1">// Setting a bit</span> <span class="w"> </span><span class="c1">// Setting a bit</span>
<span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"> </span><span class="c1">// solution: number |= 1 &lt;&lt; bit;</span> <span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"></span>
<span class="w"> </span> <span class="w"> </span>
<span class="w"> </span><span class="c1">// Clearing a bit</span> <span class="w"> </span><span class="c1">// Clearing a bit</span>
<span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"> </span><span class="c1">// solution: number &amp;= ~(1 &lt;&lt; bit);</span> <span class="w"> </span><span class="n">bit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"></span>
<span class="w"> </span> <span class="w"> </span>
<span class="w"> </span><span class="c1">// Toggling a bit</span> <span class="w"> </span><span class="c1">// Toggling a bit</span>
<span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"> </span><span class="c1">// solution; number ^= 1 &lt;&lt; bit;</span> <span class="w"> </span><span class="n">bit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">...;</span><span class="w"></span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;number = 0x%02X</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w"></span>
<span class="w"> </span> <span class="w"> </span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span> <span class="p">}</span><span class="w"></span>
@ -126,9 +138,9 @@
</pre></div> </pre></div>
</div> </div>
<p>Es gibt aber auch eine Variante, die ohne zusätzliche Variable auskommt. Dabei wird die Tatsache, dass eine zweite XOR Operation eine erste XOR Operation rückgängig macht:</p> <p>Es gibt aber auch eine Variante, die ohne zusätzliche Variable auskommt. Dabei wird die Tatsache, dass eine zweite XOR Operation eine erste XOR Operation rückgängig macht:</p>
<p><em>0011 XOR 0100 = 0111</em></p> <p><code class="docutils literal notranslate"><span class="pre">0011</span> <span class="pre">XOR</span> <span class="pre">0100</span> <span class="pre">=</span> <span class="pre">0111</span></code></p>
<p><em>0111 XOR 0100 = 0011</em></p> <p><code class="docutils literal notranslate"><span class="pre">0111</span> <span class="pre">XOR</span> <span class="pre">0100</span> <span class="pre">=</span> <span class="pre">0011</span></code></p>
<p>Somit kommt man von einem XOR Resultat (<em>0111</em>) wieder auf beide Anfangs Operanden zurück indem man einfach ein zweites Mal mit einem Operanden eine XOR Verknüpfung macht. Damit kann ein Operand als Zwischenspeicher dienen und man muss nicht extra eine Zusatzvariable verwenden.</p> <p>Somit kommt man von einem XOR Resultat (<code class="docutils literal notranslate"><span class="pre">0111</span></code>) wieder auf beide Anfangs Operanden zurück indem man einfach ein zweites Mal mit einem Operanden eine XOR Verknüpfung macht. Damit kann ein Operand als Zwischenspeicher dienen und man muss nicht extra eine Zusatzvariable verwenden.</p>
<p>Überlegen sie sich wie sie damit zwei Variablen vertauschen können ohne Zusatzvariable:</p> <p>Überlegen sie sich wie sie damit zwei Variablen vertauschen können ohne Zusatzvariable:</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span> <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span> <span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span>
@ -138,15 +150,7 @@
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">4</span><span class="p">;</span><span class="w"></span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;a: %d; b: %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">);</span><span class="w"></span> <span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;a: %d; b: %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">);</span><span class="w"></span>
<span class="w"> </span> <span class="w"> </span>
<span class="w"> </span><span class="p">...</span><span class="w"></span> <span class="w"> </span><span class="p">...</span><span class="w"></span>
<span class="w"> </span><span class="cm">/* Solutions: </span>
<span class="cm"> // a == 0011; b == 0100</span>
<span class="cm"> a ^= b; // a == 0111; b == 0100</span>
<span class="cm"> b ^= a; // a == 0111; b == 0011</span>
<span class="cm"> a ^= b; // a == 0100; b == 0011</span>
<span class="cm"> */</span><span class="w"></span>
<span class="w"> </span> <span class="w"> </span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;a: %d; b: %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">);</span><span class="w"></span> <span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;a: %d; b: %d</span><span class="se">\n</span><span class="s">&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">);</span><span class="w"></span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span>
@ -156,6 +160,7 @@
</section> </section>
<section id="lower-uppercase"> <section id="lower-uppercase">
<h4>3. Lower- / Uppercase<a class="headerlink" href="#lower-uppercase" title="Permalink to this headline"></a></h4> <h4>3. Lower- / Uppercase<a class="headerlink" href="#lower-uppercase" title="Permalink to this headline"></a></h4>
<p>Folgendes Code Beispiel kann Buchstaben in Gross- oder Kleinbuchstaben wandeln mit nur einer einzigen Bit-Operation. Überlegen sie sich warum das funktioniert, damit sie es jemand anderem in ihren Worten erklären könnten. Machen sie Notizen falls nötig.</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span> <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span> <span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span>
@ -176,14 +181,19 @@
</section> </section>
<section id="prufen-auf-2-er-potenz"> <section id="prufen-auf-2-er-potenz">
<h4>4. Prüfen auf 2-er Potenz<a class="headerlink" href="#prufen-auf-2-er-potenz" title="Permalink to this headline"></a></h4> <h4>4. Prüfen auf 2-er Potenz<a class="headerlink" href="#prufen-auf-2-er-potenz" title="Permalink to this headline"></a></h4>
<p>Um eine gegebene Zahl zu prüfen ob sie eine 2er Potenz ist, können wir folgende Bit-Muster vergleichen:</p>
<p>Beispiel mit der Zahl 8: <code class="docutils literal notranslate"><span class="pre">1000</span> <span class="pre">&amp;</span> <span class="pre">0111</span> <span class="pre">==</span> <span class="pre">0</span></code>. Wir prüfen also, ob die gegebene Zahl 8 (<code class="docutils literal notranslate"><span class="pre">1000</span></code>) nur ein Bit auf <code class="docutils literal notranslate"><span class="pre">1</span></code> hat und den Rest auf <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p>
<p>Überlegen Sie sich einen Algorithmus um dies für beliebige positive Zahlen zu prüfen. Das Bitmuster, dass für die <code class="docutils literal notranslate"><span class="pre">&amp;</span></code> Operation gebraucht wird, kann mittel Subtraktion von 1 berechnet werden (<code class="docutils literal notranslate"><span class="pre">1000</span> <span class="pre">-</span> <span class="pre">1</span> <span class="pre">=</span> <span class="pre">0111</span></code>):</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span> <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span><span class="cp"></span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span> <span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdlib.h&gt;</span><span class="cp"></span>
<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">(){</span><span class="w"></span> <span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">(){</span><span class="w"></span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">a</span><span class="o">=</span><span class="mi">32</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">32</span><span class="p">;</span><span class="w"> </span><span class="c1">// any positive number</span>
<span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">&amp;</span><span class="w"> </span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="p">))</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span><span class="p">){</span><span class="w"></span>
<span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">a</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="p">...){</span><span class="w"></span>
<span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;%d is a power of 2&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">);</span><span class="w"></span> <span class="w"> </span><span class="n">printf</span><span class="p">(</span><span class="s">&quot;%d is a power of 2&quot;</span><span class="p">,</span><span class="w"> </span><span class="n">a</span><span class="p">);</span><span class="w"></span>
<span class="w"> </span><span class="p">}</span><span class="w"></span> <span class="w"> </span><span class="p">}</span><span class="w"></span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span> <span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">EXIT_SUCCESS</span><span class="p">;</span><span class="w"></span>
<span class="p">}</span><span class="w"></span> <span class="p">}</span><span class="w"></span>
</pre></div> </pre></div>
@ -194,42 +204,51 @@
<hr class="docutils" /> <hr class="docutils" />
<section id="struct-typedef"> <section id="struct-typedef">
<h2>2. Struct &amp; typedef<a class="headerlink" href="#struct-typedef" title="Permalink to this headline"></a></h2> <h2>2. Struct &amp; typedef<a class="headerlink" href="#struct-typedef" title="Permalink to this headline"></a></h2>
<section id="id1">
<h3>2.1 Übungen<a class="headerlink" href="#id1" title="Permalink to this headline"></a></h3>
<section id="bit-operationen-rechner"> <section id="bit-operationen-rechner">
<h4>1. Bit Operationen Rechner<a class="headerlink" href="#bit-operationen-rechner" title="Permalink to this headline"></a></h4> <h3>2.1 Bit Operationen Rechner<a class="headerlink" href="#bit-operationen-rechner" title="Permalink to this headline"></a></h3>
<ul> <p>Vervollständigen sie das beiliegende Programm <code class="docutils literal notranslate"><span class="pre">bin_calculator.c</span></code>. Es soll einfache Bit-Operationen mit zwei Operanden lösen können. Die unterstützten Operationen sind:</p>
<li><p>Bitweise Operationen mit 2 Operanden</p></li> <ul class="simple">
<li><p>Rechnung wird als ein String über scanf dem Programm übergeben</p> <li><p>&amp; (AND)</p></li>
<ul> <li><p>| (OR)</p></li>
<li><p>String wird in Token zerstückelt und in struct gespeichert:</p> <li><p>^ (XOR)</p></li>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">typedef</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="p">{</span><span class="w"></span> <li><p>&lt; (left shift)</p></li>
<span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">operand_1</span><span class="p">;</span><span class="w"></span> <li><p>&gt; (right shift)</p></li>
<span class="w"> </span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">operand_2</span><span class="p">;</span><span class="w"></span> </ul>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">operation</span><span class="p">;</span><span class="w"></span> <p>Eine Rechnung kann direkt als einen String eingeben werden (z.B: <code class="docutils literal notranslate"><span class="pre">0x0c</span> <span class="pre">^</span> <span class="pre">0x0f</span></code>). Dabei werden Hexadezimal, Oktal und Dezimal als Eingabeformate akzeptiert. Die Rechnung wird in 3 Teile aufgeteilt (Operand 1, Operand 2, Operation) und in einer Datenstruktur gespeichert (<code class="docutils literal notranslate"><span class="pre">struct</span></code>).</p>
<span class="p">}</span><span class="w"> </span><span class="n">Expression</span><span class="p">;</span><span class="w"></span> <p>Als Ausgabe soll die Rechnung wie folgt dargestellt werden:</p>
</pre></div>
</div>
</li>
<li><p>Ausgabe in 3 verschiedenen Formaten:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Bin</span><span class="p">:</span> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Bin</span><span class="p">:</span>
<span class="mi">0000</span><span class="s1">&#39;0000&#39;</span><span class="mi">0000</span><span class="s1">&#39;0001</span> <span class="mi">00000000</span><span class="s1">&#39;00000000&#39;</span><span class="mi">00000000</span><span class="s1">&#39;00001100</span>
<span class="o">&amp;</span> <span class="mi">0000</span><span class="s1">&#39;0000&#39;</span><span class="mi">0000</span><span class="s1">&#39;0011</span> <span class="mi">00000000</span><span class="s1">&#39;00000000&#39;</span><span class="mi">00000000</span><span class="s1">&#39;00001111 ^</span>
<span class="o">-------------------</span> <span class="o">-----------------------------------</span>
<span class="mi">0000</span><span class="s1">&#39;0000&#39;</span><span class="mi">0000</span><span class="s1">&#39;0001</span> <span class="mi">00000000</span><span class="s1">&#39;00000000&#39;</span><span class="mi">00000000</span><span class="s1">&#39;00000011</span>
<span class="n">Hex</span>
<span class="mh">0x01</span> <span class="o">&amp;</span> <span class="mh">0x03</span> <span class="o">=</span> <span class="mh">0x01</span>
<span class="n">Dec</span> <span class="n">Hex</span><span class="p">:</span>
<span class="mi">1</span> <span class="o">&amp;</span> <span class="mi">3</span> <span class="o">=</span> <span class="mi">1</span> <span class="mh">0x0c</span> <span class="o">^</span> <span class="mh">0x0f</span> <span class="o">=</span> <span class="mh">0x03</span>
<span class="n">Dec</span><span class="p">:</span>
<span class="mi">12</span> <span class="o">^</span> <span class="mi">15</span> <span class="o">=</span> <span class="mi">3</span>
</pre></div> </pre></div>
</div> </div>
</li>
</ul>
</li>
</ul>
</section> </section>
<section id="einfache-formen">
<h3>2.2 Einfache Formen<a class="headerlink" href="#einfache-formen" title="Permalink to this headline"></a></h3>
<p>Der Code in <code class="docutils literal notranslate"><span class="pre">simple_shape.c</span></code> kompiliert nicht. Überlegen sie sich, wie der neue Datentype <code class="docutils literal notranslate"><span class="pre">Graphic</span></code> aussehen soll, damit alle nötigen Informationen dazu gespeichert werden können.</p>
<p>Eine Form (<code class="docutils literal notranslate"><span class="pre">Graphic</span></code>) wird aus folgenden Attributen zusammengesetzt:</p>
<ul class="simple">
<li><p><strong>Shape</strong>: <em>OVAL</em> oder <em>RECTANGLE</em> (verwenden sie dazu einen separaten <code class="docutils literal notranslate"><span class="pre">enum</span></code> Typ)</p></li>
<li><p><strong>Size</strong>: Ein positiver Integer</p>
<ul>
<li><p>Für <em>RECTANGLE</em> bestimmt er die Seitengrösse</p></li>
<li><p>Für <em>OVAL</em> bestimmt er den Radius</p></li>
</ul>
</li>
<li><p><strong>Color</strong>: char Pointer zu dem vordefinierten char array mit Farbinformationen. Verwenden sie: <code class="docutils literal notranslate"><span class="pre">char</span> <span class="pre">*color;</span></code></p></li>
</ul>
<p>Erweitern sie den Code an den markierten Stellen, damit er kompiliert. Per Terminal sollte es möglich sein die Attribute für die Form zu bestimmen, um sie danach angezeigt zu bekommen.</p>
<p><strong>Bemerkung</strong>: Das Programm verwendet die Math Bibliothek <code class="docutils literal notranslate"><span class="pre">math.h</span></code>. Um das Programm kompilieren zu können, müssen sie das Flag <code class="docutils literal notranslate"><span class="pre">-lm</span></code> verwenden:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>gcc -o main -lm main.c
</pre></div>
</div>
</section> </section>
</section> </section>
<hr class="docutils" /> <hr class="docutils" />
@ -245,22 +264,30 @@
</thead> </thead>
<tbody> <tbody>
<tr class="row-even"><td class="text-left"><p>alle</p></td> <tr class="row-even"><td class="text-left"><p>alle</p></td>
<td class="text-left"><p>Sie können das funktionierende Programm inklusive funktionierende Tests demonstrieren und erklären.</p></td> <td class="text-left"><p>Sie können das funktionierende Programm demonstrieren und erklären.</p></td>
<td class="text-left"><p></p></td> <td class="text-left"><p></p></td>
</tr> </tr>
<tr class="row-odd"><td class="text-left"><p>gibIntWert</p></td> <tr class="row-odd"><td class="text-left"><p>Basis Operationen</p></td>
<td class="text-left"><p>Eingabe, Bereichsüberprüfung korrekt</p></td>
<td class="text-left"><p>1</p></td>
</tr>
<tr class="row-even"><td class="text-left"><p>istSchaltjahr</p></td>
<td class="text-left"><p>Funktion korrekt</p></td> <td class="text-left"><p>Funktion korrekt</p></td>
<td class="text-left"><p>1</p></td> <td class="text-left"><p>0.5</p></td>
</tr> </tr>
<tr class="row-odd"><td class="text-left"><p>TageProMonat</p></td> <tr class="row-even"><td class="text-left"><p>Variablen tauschen</p></td>
<td class="text-left"><p>Funktion korrekt</p></td> <td class="text-left"><p>Funktion korrekt</p></td>
<td class="text-left"><p>0.5</p></td>
</tr>
<tr class="row-odd"><td class="text-left"><p>Lower- / Uppercase</p></td>
<td class="text-left"><p>Funktion korrekt</p></td>
<td class="text-left"><p>0.5</p></td>
</tr>
<tr class="row-even"><td class="text-left"><p>Prüfen auf 2-er Potenz</p></td>
<td class="text-left"><p>Funktion korrekt</p></td>
<td class="text-left"><p>0.5</p></td>
</tr>
<tr class="row-odd"><td class="text-left"><p>Bit Operationen Rechner</p></td>
<td class="text-left"><p>Fehlenden Teile ergänzt und lauffähig</p></td>
<td class="text-left"><p>1</p></td> <td class="text-left"><p>1</p></td>
</tr> </tr>
<tr class="row-even"><td class="text-left"><p>Aufgabe 2</p></td> <tr class="row-even"><td class="text-left"><p>Einfache Formen</p></td>
<td class="text-left"><p>Fehlenden Teile ergänzt und lauffähig</p></td> <td class="text-left"><p>Fehlenden Teile ergänzt und lauffähig</p></td>
<td class="text-left"><p>1</p></td> <td class="text-left"><p>1</p></td>
</tr> </tr>
@ -308,10 +335,8 @@
</ul> </ul>
</li> </li>
<li class="toctree-l2"><a class="reference internal" href="#struct-typedef">2. Struct &amp; typedef</a><ul> <li class="toctree-l2"><a class="reference internal" href="#struct-typedef">2. Struct &amp; typedef</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#id1">2.1 Übungen</a><ul> <li class="toctree-l3"><a class="reference internal" href="#bit-operationen-rechner">2.1 Bit Operationen Rechner</a></li>
<li class="toctree-l4"><a class="reference internal" href="#bit-operationen-rechner">1. Bit Operationen Rechner</a></li> <li class="toctree-l3"><a class="reference internal" href="#einfache-formen">2.2 Einfache Formen</a></li>
</ul>
</li>
</ul> </ul>
</li> </li>
<li class="toctree-l2"><a class="reference internal" href="#bewertung">4. Bewertung</a></li> <li class="toctree-l2"><a class="reference internal" href="#bewertung">4. Bewertung</a></li>

124
build/html/_sources/P03_Bit_Operation_struct_typedef/README.md.txt
View File

@ -43,22 +43,35 @@ Bit Operationen sind allgegenwärtig in den Computer-Wissenschaften und finden i
### 1.1 Übungen ### 1.1 Übungen
#### 1. Basis Operationen #### 1. Basis Operationen
Manipulationen von einzelnen Bits gehören zu den Basis Operationen und dienen als Grundlagen um weitere komplexere Konstrukte zu schaffen. Verfollständigen sie folgendes Beispiel mit den drei Basis Operationen: Manipulationen von einzelnen Bits gehören zu den Basis Operationen und dienen als Grundlagen um weitere komplexere Konstrukte zu schaffen.
Verfollständigen sie folgendes Beispiel mit den drei Basis Operationen. Dabei gibt die Variable `bit` an, welches Bit manipuliert werden soll (Denken sie daran, dass die Bit-Positionen bei 0 beginnen. Bit 3 ist also das vierte Bit von rechts). Bei den gefragten Manipulationen, soll nur das angegebene `bit` geändert werden und der Rest soll unverändert bleiben:
- Bit 3 setzen: `0011 => 1011`
- Bit 1 löschen: `1011 => 1001`
- Bit 0 flippen: `1001 => 1000`
Versuchen sie die Operationen in C umzusetzen:
```c ```c
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h>
int main() { int main() {
unsigned int number; unsigned int number = 0x75;
unsigned int bit = 3; // bit at position 3 unsigned int bit = 3; // bit at position 3
// Setting a bit // Setting a bit
number = ...; // solution: number |= 1 << bit; number = ...;
// Clearing a bit // Clearing a bit
number = ...; // solution: number &= ~(1 << bit); bit = 1;
number = ...;
// Toggling a bit // Toggling a bit
number = ...; // solution; number ^= 1 << bit; bit = 0;
number = ...;
printf("number = 0x%02X\n", number);
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
@ -86,11 +99,11 @@ int main(){
Es gibt aber auch eine Variante, die ohne zusätzliche Variable auskommt. Dabei wird die Tatsache, dass eine zweite XOR Operation eine erste XOR Operation rückgängig macht: Es gibt aber auch eine Variante, die ohne zusätzliche Variable auskommt. Dabei wird die Tatsache, dass eine zweite XOR Operation eine erste XOR Operation rückgängig macht:
*0011 XOR 0100 = 0111* `0011 XOR 0100 = 0111`
*0111 XOR 0100 = 0011* `0111 XOR 0100 = 0011`
Somit kommt man von einem XOR Resultat (*0111*) wieder auf beide Anfangs Operanden zurück indem man einfach ein zweites Mal mit einem Operanden eine XOR Verknüpfung macht. Damit kann ein Operand als Zwischenspeicher dienen und man muss nicht extra eine Zusatzvariable verwenden. Somit kommt man von einem XOR Resultat (`0111`) wieder auf beide Anfangs Operanden zurück indem man einfach ein zweites Mal mit einem Operanden eine XOR Verknüpfung macht. Damit kann ein Operand als Zwischenspeicher dienen und man muss nicht extra eine Zusatzvariable verwenden.
Überlegen sie sich wie sie damit zwei Variablen vertauschen können ohne Zusatzvariable: Überlegen sie sich wie sie damit zwei Variablen vertauschen können ohne Zusatzvariable:
```c ```c
@ -102,15 +115,7 @@ int main(){
int b = 4; int b = 4;
printf("a: %d; b: %d\n", a, b); printf("a: %d; b: %d\n", a, b);
... ...
/* Solutions:
// a == 0011; b == 0100
a ^= b; // a == 0111; b == 0100
b ^= a; // a == 0111; b == 0011
a ^= b; // a == 0100; b == 0011
*/
printf("a: %d; b: %d\n", a, b); printf("a: %d; b: %d\n", a, b);
return EXIT_SUCCESS; return EXIT_SUCCESS;
@ -118,6 +123,7 @@ int main(){
``` ```
#### 3. Lower- / Uppercase #### 3. Lower- / Uppercase
Folgendes Code Beispiel kann Buchstaben in Gross- oder Kleinbuchstaben wandeln mit nur einer einzigen Bit-Operation. Überlegen sie sich warum das funktioniert, damit sie es jemand anderem in ihren Worten erklären könnten. Machen sie Notizen falls nötig.
```c ```c
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
@ -137,48 +143,68 @@ int main(){
``` ```
#### 4. Prüfen auf 2-er Potenz #### 4. Prüfen auf 2-er Potenz
Um eine gegebene Zahl zu prüfen ob sie eine 2er Potenz ist, können wir folgende Bit-Muster vergleichen:
Beispiel mit der Zahl 8: `1000 & 0111 == 0`. Wir prüfen also, ob die gegebene Zahl 8 (`1000`) nur ein Bit auf `1` hat und den Rest auf `0`.
Überlegen Sie sich einen Algorithmus um dies für beliebige positive Zahlen zu prüfen. Das Bitmuster, dass für die `&` Operation gebraucht wird, kann mittel Subtraktion von 1 berechnet werden (`1000 - 1 = 0111`):
```c ```c
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(){ int main(){
int a=32; int a = 32; // any positive number
if(a > 0 && (a & (a - 1)) == 0){
if(a > 0 && ...){
printf("%d is a power of 2", a); printf("%d is a power of 2", a);
} }
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
``` ```
___ ___
## 2. Struct & typedef ## 2. Struct & typedef
### 2.1 Übungen ### 2.1 Bit Operationen Rechner
Vervollständigen sie das beiliegende Programm `bin_calculator.c`. Es soll einfache Bit-Operationen mit zwei Operanden lösen können. Die unterstützten Operationen sind:
- & (AND)
- | (OR)
- ^ (XOR)
- < (left shift)
- \> (right shift)
Eine Rechnung kann direkt als einen String eingeben werden (z.B: `0x0c ^ 0x0f`). Dabei werden Hexadezimal, Oktal und Dezimal als Eingabeformate akzeptiert. Die Rechnung wird in 3 Teile aufgeteilt (Operand 1, Operand 2, Operation) und in einer Datenstruktur gespeichert (`struct`).
#### 1. Bit Operationen Rechner Als Ausgabe soll die Rechnung wie folgt dargestellt werden:
- Bitweise Operationen mit 2 Operanden ```
- Rechnung wird als ein String über scanf dem Programm übergeben Bin:
- String wird in Token zerstückelt und in struct gespeichert: 00000000'00000000'00000000'00001100
```c 00000000'00000000'00000000'00001111 ^
typedef struct { -----------------------------------
unsigned int operand_1; 00000000'00000000'00000000'00000011
unsigned int operand_2;
char operation;
} Expression;
```
- Ausgabe in 3 verschiedenen Formaten:
```
Bin:
0000'0000'0000'0001
& 0000'0000'0000'0011
-------------------
0000'0000'0000'0001
Hex
0x01 & 0x03 = 0x01
Dec Hex:
1 & 3 = 1 0x0c ^ 0x0f = 0x03
```
Dec:
12 ^ 15 = 3
```
### 2.2 Einfache Formen
Der Code in `simple_shape.c` kompiliert nicht. Überlegen sie sich, wie der neue Datentype `Graphic` aussehen soll, damit alle nötigen Informationen dazu gespeichert werden können.
Eine Form (`Graphic`) wird aus folgenden Attributen zusammengesetzt:
- **Shape**: *OVAL* oder *RECTANGLE* (verwenden sie dazu einen separaten `enum` Typ)
- **Size**: Ein positiver Integer
- Für *RECTANGLE* bestimmt er die Seitengrösse
- Für *OVAL* bestimmt er den Radius
- **Color**: char Pointer zu dem vordefinierten char array mit Farbinformationen. Verwenden sie: `char *color;`
Erweitern sie den Code an den markierten Stellen, damit er kompiliert. Per Terminal sollte es möglich sein die Attribute für die Form zu bestimmen, um sie danach angezeigt zu bekommen.
**Bemerkung**: Das Programm verwendet die Math Bibliothek `math.h`. Um das Programm kompilieren zu können, müssen sie das Flag `-lm` verwenden:
gcc -o main -lm main.c
___ ___
## 4. Bewertung ## 4. Bewertung
@ -186,8 +212,10 @@ ___
Die gegebenenfalls gestellten Theorieaufgaben und der funktionierende Programmcode müssen der Praktikumsbetreuung gezeigt werden. Die Lösungen müssen mündlich erklärt werden können. Die gegebenenfalls gestellten Theorieaufgaben und der funktionierende Programmcode müssen der Praktikumsbetreuung gezeigt werden. Die Lösungen müssen mündlich erklärt werden können.
| Aufgabe | Kriterium | Gewicht | | Aufgabe | Kriterium | Gewicht |
| :-- | :-- | :-- | | :-- | :-- | :-- |
| alle | Sie können das funktionierende Programm inklusive funktionierende Tests demonstrieren und erklären. | | | alle | Sie können das funktionierende Programm demonstrieren und erklären. | |
| gibIntWert | Eingabe, Bereichsüberprüfung korrekt | 1 | | Basis Operationen | Funktion korrekt | 0.5 |
| istSchaltjahr | Funktion korrekt | 1 | | Variablen tauschen | Funktion korrekt | 0.5 |
| TageProMonat | Funktion korrekt | 1 | | Lower- / Uppercase | Funktion korrekt | 0.5 |
| Aufgabe 2 | Fehlenden Teile ergänzt und lauffähig | 1 | | Prüfen auf 2-er Potenz | Funktion korrekt | 0.5 |
| Bit Operationen Rechner | Fehlenden Teile ergänzt und lauffähig | 1 |
| Einfache Formen | Fehlenden Teile ergänzt und lauffähig | 1 |

6
build/html/index.html
View File

@ -86,10 +86,8 @@
</ul> </ul>
</li> </li>
<li class="toctree-l2"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#struct-typedef">2. Struct &amp; typedef</a><ul> <li class="toctree-l2"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#struct-typedef">2. Struct &amp; typedef</a><ul>
<li class="toctree-l3"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#id1">2.1 Übungen</a><ul> <li class="toctree-l3"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#bit-operationen-rechner">2.1 Bit Operationen Rechner</a></li>
<li class="toctree-l4"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#bit-operationen-rechner">1. Bit Operationen Rechner</a></li> <li class="toctree-l3"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#einfache-formen">2.2 Einfache Formen</a></li>
</ul>
</li>
</ul> </ul>
</li> </li>
<li class="toctree-l2"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#bewertung">4. Bewertung</a></li> <li class="toctree-l2"><a class="reference internal" href="P03_Bit_Operation_struct_typedef/README.html#bewertung">4. Bewertung</a></li>

2
build/html/searchindex.js
View File

File diff suppressed because one or more lines are too long

BIN
build/latex/main.pdf
View File

Binary file not shown.