Morpheu5
/
af


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110
							<!DOCTYPE html>

<html>

<head>
    <title>Programming in C and C++ -- 2018/19 -- Supervision 2</title>
</head>

<body>
    <h1>Programming in C and C++ (2018/19)<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 might the class constructor be called?</p>

    <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>

    <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>

    <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>

    <h2>5</h2>
    <p>How can you be sure that your implementation of class <code>Prime</code> has been evaluated at compile time?</p>

    <h2>6</h2>
    <p>Write an implementation of a class <code>LinkList</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>7</h2>
    <p>Why should destructors in an abstract class almost always be declared <code>virtual</code>?</p>

    <h2>8</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 7.</p>

    <h2>9</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 7.</p>

    <h2>10</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>