Morpheu5
/
af


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123
							<!DOCTYPE html>

<html>

<head>
    <title>Programming in C and C++ -- 2020/21 -- Supervision 2</title>
</head>

<style>
code, pre {
    font-size: 1.2em;
    color: darkslateblue;
}
</style>    

<body>
    <h1>Programming in C and C++ (2020/21)<br/>Supervision 2</h1>

    <h2>1</h2>
    <p>If a function <code>f</code> has a static instance of a class as a local variable, when is the class constructor called?</p>
 
    <hr />

    <h2>2</h2>
    <p>Write a class <code>Matrix</code> which allows a programmer to define 2 &times; 2 matrices. Overload the common operators (e.g. <code>+</code>, <code>-</code>, <code>*</code>, and <code>/</code>). Can you easily extend your design to matrices of arbitrary size?</p>

    <hr />

    <h2>3</h2>
    <p>Write a class <code>Vector</code> which allows a programmer to define a vector of length two. Modify your <code>Matrix</code> and <code>Vector</code> classes so that they interoperate correctly (e.g. <code>v2 = m*v1</code> should work as expected).</p>

    <hr />

    <h2>4</h2>
    <p>Using meta programming, write a templated class <code>Prime</code>, which evaluates whether a literal integer constant (e.g. <code>7</code>) is prime or not at compile time.</p>
    <p>How can you be sure that your implementation of class <code>Prime</code> has been evaluated at compile time?</p>

    <hr />

    <h2>5</h2>
    <p>Write a class <code>LinkedList</code> which stores zero or more positive integers internally as a linked list on the heap. The class should provide appropriate constructors and destructors and a method <code>pop()</code> to remove items from the head of the list. The method <code>pop()</code> should return <code>-1</code> if there are no remaining items. Your implementation should override the copy constructor and assignment operator to copy the linked list structure between class instances. You might like to test your implementation with the following:</p>
<pre>int main() {
    int test[] = {1,2,3,4,5};
    LinkList l1(test+1,4), l2(test,5);
    LinkList l3 = l2, l4;
    l4 = l1;
    printf("%d %d %d\n", l1.pop(), l3.pop(), l4.pop());
    return 0;
}
</pre>
    <p>Hint: heap allocation and deallocation should occur exactly once!</p>

    <h2>6</h2>
    <p>Why should destructors in an abstract class almost always be declared <code>virtual</code>?</p>

    <h2>7</h2>
    <p>Provide an implementation for:</p>
    <pre>
    Stack(const Stack&amp; s);
    Stack&amp; operator=(const Stack&amp; s);</pre>
    <p>as declared in the slides for lecture 12.</p>

    <h2>8</h2>
    <p>Provide an implementation for:</p>
    <pre>
    template&lt;class T&gt; T Stack&lt;T&gt;::pop();
    template&lt;class T&gt; Stack&lt;T&gt;::~Stack();</pre>
    <p>as declared in the slides for lecture 12.</p>

    <h2>9</h2>
    <p>A hardware engineer stores a FIFO queue of bits in an <code>int</code> on a platform with<br>
        32-bit ints and 8-bit <code>char</code>s using the following C++ class:</p>
    <pre><code>class BitQueue {
    int valid_bits; // the number of valid bits held in queue
    int queue;      // least significant bit is most recent bit added
public:
    BitQueue(): valid_bits(0), queue(0) {}
    void push(int val, int bsize);
    int pop(int bsize);
    int size();
};
</code></pre>
        <ol>
        <li>
        <p>Write an implementation of <code>BitQueue::size</code> which should return the number<br>
        of bits currently held in <code>queue</code>.</p>
        </li>
        <li>
        <p>Write an implementation of <code>BitQueue::push</code> which places the <code>bsize</code> least<br>
        significant bits from <code>val</code> onto <code>queue</code> and updates <code>valid_bits</code>. An<br>
        exception should be thrown in cases where data would otherwise be lost.</p>
        </li>
        <li>
        <p>Write an implementation of <code>BitQueue::pop</code>, which takes <code>bsize</code> bits from<br>
        queue, provides them as the <code>bsize</code> least significant bits in the return<br>
        value, and updates <code>valid_bits</code>. An exception should be thrown when any<br>
        requested data is unavailable.</p>
        </li>
        <li>
        <p>The hardware engineer has built a communication device together with a C++<br>
        library function <code>send</code> to transmit data with the following declaration:<br>
        void send(char);<br>
        Use the <code>BitQueue</code> class to write a C++ definition for:</p>
        <pre><code> void sendmsg(const char* msg);
        </code></pre>
        <p>Each of the characters in <code>msg</code> should be encoded, in index order, using the<br>
        following binary codes: <code>'a'=0</code>, <code>'b'=10</code>, <code>'c'=1100</code>, and <code>'d'=1101</code>. All<br>
        other characters should be ignored. Successive binary codes should be<br>
        bit-packed together and the code <code>111</code> should be used to denote the end of<br>
        the message. Chunks of 8-bits should be sent using the send function and any<br>
        remaining bits at the end of a message should be padded with zeros. For<br>
        example, executing</p>
        <pre><code> sendmsg("abcd");
        </code></pre>
        <p>should call the send function twice, with the binary values <code>01011001</code><br>
        followed by <code>10111100</code>.<br>
        </p>
        </li>
        </ol>

</body>

</html>