\documentclass[11pt,a4paper]{article}

\usepackage{ngerman,a4}
\usepackage{amstext}
\usepackage{amssymb}
\usepackage{amsmath}
%\usepackage{stmaryrd}
\usepackage{enumerate}
%\usepackage{alltt}
\usepackage[latin1]{inputenc}
%\usepackage{graphicx}
\usepackage{cancel}
\usepackage{arcs}
%\usepackage{fuzz}

\thispagestyle{empty}

\title{Softwaretechnik (WS 2005/2006) - Übungsblatt 10}
\author{Jan Hendrik Dithmar - Matrikelnummer 2031259 \\
		Übungsgruppe Mi, 8-10 Uhr \\
		Dirk Heine - Matrikelnummer 2030941 \\
		Übungsgruppe Di, 14-16 Uhr \\\\
		Rückgabe: Übungsgruppe Di, 14-16 Uhr
	}
\date{}

\begin{document}

\newcommand{\AND}{\ensuremath{\wedge}}
\newcommand{\OR}{\ensuremath{\vee}}
\newcommand{\SetR}{\ensuremath{\mathbb{R}}}
\newcommand{\SetN}{\ensuremath{\mathbb{N}}}
\newcommand{\SetC}{\ensuremath{\mathbb{C}}}
\newcommand{\SetZ}{\ensuremath{\mathbb{Z}}}
\newcommand{\SetQ}{\ensuremath{\mathbb{Q}}}
\newcommand{\SetB}{\ensuremath{\mathbb{B}}}
\newcommand{\R}{\ensuremath{\mathbb{R}}}
\newcommand{\N}{\ensuremath{\mathbb{N}}}
\newcommand{\C}{\ensuremath{\mathbb{C}}}
\newcommand{\Z}{\ensuremath{\mathbb{Z}}}
\newcommand{\Q}{\ensuremath{\mathbb{Q}}}
\newcommand{\B}{\ensuremath{\mathbb{B}}}
\newcommand{\QED}{\ensuremath{\hspace*{\fill}\square}}
\newcommand{\FLASH}{\ensuremath{\hspace*{\fill}\lightning}}
\newcommand{\OnotO}{\ensuremath{\mathcal{O}}}
\newcommand{\bild}[4]{
	\begin{figure}[htpb]
		\centering
			\includegraphics[width=#1cm]{#2}\\[0.2cm]
			\caption{#3}
			\label{#4}
	\end{figure}
	}

\maketitle

\newpage
\section*{Aufgabe 1}
\subsubsection*{(a)}
\begin{verbatim}
a1.cpp: In function `void increment_set(std::set<int, std::less<int>,
std::allocator<int> >&)':
a1.cpp:6: error: increment of read-only location
\end{verbatim}

\subsubsection*{(b)}
In Zeile 6 wird die Adresse des Iterators erhöht. Da dies in der Form nicht erlaubt ist (man würde die Einzigartigkeit von \verb!set! gefährden), steigt der Compiler dort aus. Eine mögliche Fehlermeldung wäre z.B.: \glqq read-only location in set\grqq

\subsubsection*{(c)}
Es ist möglich, \verb!increment_set! zu implementieren, ohne seine Signatur zu verändern, da man eine temporäre Variable des Typs \verb!std::set<int>! und einen temporären Iterator einführen und mit diesen arbeiten kann (siehe Teil d). Somit ist die Eindeutigkeit der ursprünglichen Menge (\verb!set!) garantiert.

\subsubsection*{(d)}
\begin{verbatim}
static void increment_set(std::set<int>&s) {
  std::set<int> s_temp;
  for (std::set<int>::iterator i = s.begin(); i != s.end(); i++) {
    int i_temp = *i + 1;
    s_temp.insert(i_temp);
  }
  s = s_temp;
}
\end{verbatim}

\section*{Aufgabe 2}
\begin{verbatim}
#include <iostream>
#include <stdexcept>

template <typename T,unsigned int size>
class Buffer {
    private:
        T* buffer; // Zeiger auf T (1.)
    public:
        Buffer();
        ~Buffer();
        const T operator[] (unsigned int) throw (std::out_of_range);
};

template <typename T,unsigned int size>
Buffer<T,size>::Buffer() {
    buffer = new T(size); // neues Array vom Typ T der Länge size (2.)
}

// Arrays wird bei Destruktion wieder freigegeben (3.)
template <typename T,unsigned int size>
Buffer<T,size>::~Buffer() {
    free(buffer);
}

// Falls das Element nicht im Array ist,
// wird eine out_of_range-Exception geworfen (4.)
template <typename T,unsigned int size>
const T Buffer<T,size>::operator[] (unsigned int n) throw (std::out_of_range) {
    if(n < size) {
        buffer = buffer + (n*sizeof(T)); // das n-te Element wird zurückgegeben (5.)
    } else {
        throw std::out_of_range();
    }
    return *buffer;
}

// Für <bool,16> soll es ein spezialisiertes Template geben (6.)
template<> class Buffer<bool,16> {
    private:
        unsigned short buffer;
    public:
        Buffer();
        ~Buffer();
        const bool operator[] (unsigned int) throw (std::out_of_range);
};

Buffer<bool,16>::Buffer() {
    // Test, ob sizeof(short) >= 2 ist.
    assert(sizeof(short)>=2);
    
    buffer = 0;
}

Buffer<bool,16>::~Buffer() {
    // hier muss nichts getan werden, da in der speziellen Implementierung
    // kein Pointer verwendet wird
}

const bool Buffer<bool,16>::operator[] (unsigned int n) throw (std::out_of_range) {
    if (n < 16) {
        short temp = buffer;
        short temp2 = buffer;
        for (int i = 0; i < n; i++) {
            temp = temp2 % 2;
            temp2 = temp2 / 2;
        }
        return temp;
    } else {
        throw std::out_of_range(false);
    }
}

// Programm (7.)
int main() {
    Buffer<bool,15> b1;
    Buffer<bool,16> b2;
    
    std::cout << "Size 1 = " << sizeof(b1) << std::endl;
    std::cout << "Size 2 = " << sizeof(b2) << std::endl;
       
    return 0;
}
\end{verbatim}
Das Programm gibt folgendes aus:
\begin{verbatim}
Size 1 = 4
Size 2 = 2
\end{verbatim}

\end{document}