CS253 HW4: Library

Description

Management is delighted with your HW3 work, but is unsatisfied:

They want a library, not a stand-alone program.
They don’t like the inefficiency of using hexadecimal, and want the output to be binary, instead.

Functions

void serialize(bool, ostream &)
void serialize(short, ostream &)
void serialize(int, ostream &)
void serialize(long, ostream &)
void serialize(char, ostream &)
void serialize(const string &, ostream &)
Serialize the datum to a tagged binary value; write it to the ostream.
void unserialize(istream &, bool &)
void unserialize(istream &, short &)
void unserialize(istream &, int &)
void unserialize(istream &, long &)
void unserialize(istream &, char &)
void unserialize(istream &, string &)
Unserialize a tagged binary value from the istream to the variable.

unserialize throws (in the sense of throw/try/catch) a descriptive std::string if the requested type isn’t the next thing in the input stream. No conversions—short doesn’t match int, and int doesn’t match short.

Don’t confuse the base classes ostream and istream with ofstream and ifstream or ostringstream and istringstream.

Binary Serialized Format

In HW3, the tagged short 300 was represented as these eight bytes of hexadecimal digits and spaces:

    73 11 2c

Now, the same value will be represented by three bytes. The first byte has the value 0x73, the second byte has the value 0x11, and the third byte has the value 0x2c. No extra spaces, no extra newlines:

    output_stream << char(0x73) << char(0x11) << char(0x2c);

These bytes don’t always correspond to printable ASCII values, so you can’t just dump them out to the screen. You have to view them as hex, if you want to understand them. To analyze a file containing such binary values, use the command xxd.

Debugging

If you encounter “STACK FRAME LINK OVERFLOW”, then try this:

    export STACK_FRAME_LINK_OVERRIDE=ffff-ad921d60486366258809553a3db49a4a

Library

Your Makefile must, by default, produce the library hw4.a, like this:

    ar rcs hw4.a obj1.o obj2.o

Do not include main() in your library.

Testing

You will have to write a main() function to test your code. Put it in a separate file, and do not make it part of hw4.a. You will also have to create a header file (the name is up to you) that declares the functions, and #include it in your test program that contains main().

We will test your program like this:

    tar -x <hw4.tar
    make
    g++ -Wall -o testprog our-test-program.cc hw4.a
    ./testprog

We will supply a main program to do the testing that we want. You should do something similar.

Sample Run

Here is a sample run of a test program, where % is my prompt:

    % cat functions.h 
    #ifndef FUNCTIONS_H_INCLUDED
    #define FUNCTIONS_H_INCLUDED

    #include <string>
    #include <iostream>

    void serialize(bool, std::ostream &);
    void serialize(short, std::ostream &);
    void serialize(int, std::ostream &);
    void serialize(long, std::ostream &);
    void serialize(char, std::ostream &);
    void serialize(const std::string &, std::ostream &);

    void unserialize(std::istream &, bool &);
    void unserialize(std::istream &, short &);
    void unserialize(std::istream &, int &);
    void unserialize(std::istream &, long &);
    void unserialize(std::istream &, char &);
    void unserialize(std::istream &, std::string &);

    #endif

    % cat coolidge.cc 
    #include "functions.h"
    #include <iostream>
    #include <sstream>
    #include <fstream>
    #include <cassert>

    using namespace std;

    int main() {

        cout << "Test begins\n";

        ostringstream oss;
        serialize(short(8), oss);		  // ctor “cast”
        assert(oss.str() == "s" "\x10\x08");  // beware: \x00 ≡ \0 ≡ end of string

        oss.str("");
        serialize(0x123456789abcdef0L, oss);
        assert(oss.str() == "l\x80\x12\x34\x56\x78\x9a\xbc\xde\xf0"s); 

        try {
            bool b1, b2;
            istringstream iss("tf");
            unserialize(iss, b1); unserialize(iss, b2); assert(b1 && !b2);

            int i;
            iss.str({'i', '\x2e', '\x1d', '\xc0'});
            unserialize(iss, i); assert(i == -123456);

            string str;
            iss.str("S\x10\x0c"s "kakistocracy");
            unserialize(iss, str); assert(str == "kakistocracy");
        }
        catch (string msg) {
            cerr << "Unserialize error: " << msg << '\n';
        }

        // Ensure that fstreams also work
        ofstream ofs;
        serialize("!@#$%^&*()", ofs);   // expected to quietly fail
        assert(!ofs);

        cout << "Test ends\n";
        return 0;
    }

    % g++ -Wall -Wextra -Wpedantic coolidge.cc hw4.a
    % ./a.out
    Test begins
    Test ends
    %

Requirements

The requirements are the same as those for HW3, plus:

Do not put main() in hw4.a.
No global variables.
Do not put main() in hw4.a.
After a failing call to unserialize, the state of the istream is unspecified.
Do not put main() in hw4.a.
Your functions must not write anything to cout or cerr.
Do not put main() in hw4.a.
Your functions must not call exit().
Do not put main() in hw4.a.

Tar file

The tar file for this assignment must be called: hw4.tar
It must contain:
- source files (*.cc)
- header files (*.h) (if any)
- Makefile (Makefile, with a capital M)
The Makefile’s default target must create the library file hw4.a.
Your Makefile must use at least -Wall when compiling.

How to submit your homework:

Use web checkin, or Linux checkin:

    ~cs253/bin/checkin HW4 hw4.tar

How to receive negative points:

Turn in someone else’s work.

CS253: Software Development with C++

Spring 2018

HW 4