Legen Sie ein Arbeitsverzeichnis Name_Vorname.Matrikelnumer an. Legen Sie darin ein neues C++ Projekt LiwanzenVZ an.

Aufgabe 1

a) Deklarieren Sie zunächst Folgendes, und definieren Sie es danach.  Region ist ein Enumerator (ndef, amer, apac, emea ), der auch Klassenmember ist. Der Einfachheit halber muss jedes Mitglied des sozialen Netzwerks LiwanzenVZ einen eindeutigen Namen habe. b) Auf der Grundlage von 1a) – aber für die Implementierung nicht unbedingt darauf beschränkt – entwickeln Sie nun die folgenden Funktionalitäten aus main :

i. Legen Sie ein geeignetes Objekt namens vL für die Speicherung von beliebig vielen LiwanzenVZ-Mitgliedern an und füllen Sie es im Quellcode über eine Supportfunktion namens populate mit sechs Mitgliedern:

Joey (amer), Johnny (amer), DeeDee (amer), Tommy (emea), Suzy (apac) und Sheena (amer).

Geben Sie mittels einer weiteren Supportfunktion namens print_LVZMembers eine komplette Liste mit allen gespeicherten Mitgliedern und ihren Details möglichst benutzerfreundlich zeilenweise aus (d.h. beispielsweise auch, dass Region nicht als Zahl erscheint).

ii. Lassen Sie den Benutzer mittels einer Supportfunktion namens add_Liwanze beliebig viele weitere Mitglieder hinzufügen, wobei jeder Name in der Liste eindeutig sein muss. Lassen Sie zur Vereinfachung keine Eingaben für die Region zu, die Sie hier immer auf ndef setzen. Die Eingabe eines bereits vorhandenen Namens wird abgelehnt, eine sinnvolle Meldung wird ausgegeben und das Programm fordert den Benutzer erneut zur Eingabe auf. Bei sonstigen Eingabefehlern werfen Sie eine Ausnahme, die zum Programmabbruch mit Fehlermeldung führt.

Nach jeder geglückten Registrierung einer neuen „Liwanze“ wird eine komplette Liste mit allen Mitgliedern und deren Details im LiwanzenVZ möglichst benutzerfreundlich ausgegeben. Durch Eingabe von q wird die Registrierung weiterer Mitglieder beendet.

Aufgabe 2

a) Erweitern Sie nun die Lösung aus Aufgabe 1 wie folgt:  Die Methode connects überprüft, ob es zu der Liwanze im Zeigerargument eine direkte Verbindung (im sog. „tier one“) gibt. Die Methode connected überprüft, ob es von der Liwanze (im Zeigerargument) eine direkte Verbindung (im sog. „tier one“) gibt. Vergessen Sie nicht, ggf. auch Ihre bisherigen Programmteile anzupassen. b) Auf der Grundlage von 2a) – aber für die Implementierung nicht darauf beschränkt – entwickeln Sie Ihr Programm nun wie folgt weiter:

i. Vernetzen Sie im Quellcode die sechs ursprünglich registrierten Mitglieder über eine Supportfunktion namens init_connections wie folgt:

Lösen Sie dies mit einer Methode namens make_connection, die aus init_connections aufgerufen wird; setzen Sie make_connection auch im nächsten Aufgabenteil 2 b) ii. ein. Geben Sie durch geeignete Supportfunktionen / Methoden das Netzwerk komplett und so übersichtlich und benutzerfreundlich wie möglich aus.

ii. Lassen Sie den Benutzer das Netzwerk beliebig durch Eingabe von zwei unterschiedlichen Mitgliedernamen erweitern – es wird dann vom zuerst eingegebenen Name zu dem zweiten eingegebenen Namen eine Verbindung gewünscht. Ist mindestens einer der beiden Namen nicht registriert, wird dies mit einer sinnvollen Meldung abgefangen und erneut zur Eingabe zweier Namen aufgefordert (bei sonstigen Eingabefehlern wird eine Ausnahme geworfen, die zu einer Fehlermeldung und zum Programmabbruch führt).

Ist die Verbindung bereits vorhanden, wird eine informative Meldung angezeigt und es wird erneut zur Eingabe zweier Namen aufgefordert. Ist die Verbindung noch nicht vorhanden, wird sie erstellt, es wird eine Erfolgsmeldung ausgegeben und wiederum zur Eingabe zweier Namen aufgefordert.

Stellen Sie sicher, dass jede Verbindung konsistent unter beiden Namen entsprechend abgespeichert wird, werfen Sie bei Verletzung dieser Konsistenz unbedingt eine Ausnahme, die zu einer Fehlermeldung mit Programmabbruch führt.

Nach jeder geglückten Erweiterung wird das vollständige Tier-One-Netzwerk (d.h. alle direkten Beziehungen) des ersten Namens und des zweiten Namens, mit allen Details (einschließlich der Anzahlen der jeweils ein- und ausgehenden Beziehungen) möglichst benutzerfreundlich angezeigt.

Durch Eingabe von q wird die Erweiterung des Netzwerks (und damit das Programm) schließlich beendet.

Error.h

#ifndef ERROR_H
#define	ERROR_H

#include
#include

using std::string;
using std::runtime_error;

void error (string s)
{throw runtime_error(s);}

void error (string s1, string s2)
{error(s1+s2);}
#endif	/* ERROR_H */

LiwanzenVZ.cpp

#include "LiwanzenVZ.h"
using namespace std;

Liwanze::Liwanze() :
name(""), loc(ndef)
{}

Liwanze::Liwanze(string sname, Region location) :
name(sname), loc(location)
{}

string Liwanze::get_name() const
{return name;}

Liwanze::Region Liwanze::get_loc()const
{return loc;}

void Liwanze::print() const
{
    cout << "Name:\t" << name << endl;
    if (loc==ndef) cout << "Region:\t\t" << "Nicht definiert" << endl;
    if (loc==amer) cout << "Region:\t\t" << "Americas" << endl;
    if (loc==apac) cout << "Region:\t\t" << "Asia-Pacific" << endl;
    if (loc==emea) cout << "Region:\t\t" << "Europe, Middle East, Africa" << endl;
}

void populate(vector& vL) {
    vL.push_back(Liwanze("Joey", Liwanze::amer));
    vL.push_back(Liwanze("Johnny", Liwanze::amer));
    vL.push_back(Liwanze("DeeDee", Liwanze::amer));
    vL.push_back(Liwanze("Tommy", Liwanze::emea));
    vL.push_back(Liwanze("Suzy", Liwanze::apac));
    vL.push_back(Liwanze("Sheena", Liwanze::amer));
}

void print_LVZMembers(const vector& vL)
{
    for (int i = 0; i < vL.size(); i++) {
        cout << i+1 << ". ";
        vL[i].print();
        vL[i].print_tierone();
        cout << "\n";
    }

}

void add_Liwanze(vector& vL, string sname)
{
    if (b_check_ok(vL, sname)==true)
    {vL.push_back(Liwanze(sname, Liwanze::ndef));}
    else
    {
        while (b_check_ok(vL, sname)==false)
        {
            cout << "Benutzer bereits vorhanden.";
            cout << "Bitte geben Sie einen gültigen Namen ein:";             cin >> sname;
        }
        vL.push_back(Liwanze(sname, Liwanze::ndef));
    }
}

bool b_check_ok(const vector& vL, string sname)
{
    for (int i=0; i    {
        if (vL[i].get_name()==sname){return false;}
    }
    return true;
}

bool Liwanze::connects(Liwanze* a) const
{
    for (int i=0; iget_name()==connectsTo[i]) return true;
    }
    return false;
}

bool Liwanze::connected(Liwanze* a) const
{
    for (int i=0; iget_name()==connectedFrom[i]) return true;
    }
    return false;
}

void Liwanze::print_tierone() const
{
    int i=0;
    int j=0;
    cout << "Connects to:\t";
    for (i=0; i    {
        if (i        {cout << connectsTo[i] << ", ";}
        else
        {
            cout << connectsTo[i];
        }

    }
    cout <<  "\n";

    cout << "Connected from:\t";
    for (j=0; i    {
        if (i        {cout <        else
        {
            cout << connectedFrom[i];
        }
    }
    cout << "\nAusgehend:" << i << endl;
    cout << "Eingehend:" << j << endl;
    cout <<  "\n"; } void Liwanze::add_connTo(Liwanze* a) {     if (this->connects(a))
    {
        cerr << "Verbindung besteht bereits" << endl;     }     else     {         connectsTo.push_back(a->get_name());
    }

}

void Liwanze::add_connFrom(Liwanze* a)
{
    if (this->connected(a))
    {
        cerr << "Verbindung besteht bereits" << endl;     }     else     {         connectedFrom.push_back(a->get_name());
    }
}

void Liwanze::make_connection(string sTo, vector& vL)
{
    Liwanze* To=0;
    for (int i=0; iconnects(To)==false && To->connected(this)==false)
            {
                this->add_connTo(To);
                To->add_connFrom(this);

                if (this->connects(To)==true && To->connected(this)==true)
                {
                    cout << "Verbindung erfolgreich hergestellt.\n";
                    cout << "\n" << this->get_name() << " \n";                     this->print_tierone();
                    cout << "\n" << To->get_name() << " \n";                     To->print_tierone();
                    return;

                }
                else
                {

                   error("Inkonsitente Daten");
                }
            }
            else
            {
                cerr << "Verbindung besteht bereits." << endl;
                return;
            }

        }
        if (i==vL.size()-1)
        {
            cout << "2. Benutzer " << sTo << " konnte nicht gefunden werden. Bitte Namen erneut eingeben: \n";             cin >> sTo;
            i=-1;
        }

    }

}

void connect_2(vector& vL)
{
    string sa="<>";
    string sb="<>";

    cout << "\nVon Mitglied 1:";     cin >> sa;
    cout << "Zu Mitglied 2:";     cin >> sb;

    for (int i=0; i    {
        if (vL[i].get_name()==sa)
        {
             vL[i].make_connection(sb, vL);
             return;
        }
        if (i==vL.size()-1)
        {
            cout << "1. Benutzer " << sa << " konnte nicht gefunden werden. Bitte Namen erneut eingeben: \n";             cin >> sa;
            i=-1;
        }
    }

}

void init_connections(vector& vL)
{
    for (int i=0; i    {
        if (vL[i].get_name()=="Joey")
        {
            vL[i].make_connection("Johnny", vL);
            vL[i].make_connection("DeeDee", vL);
            vL[i].make_connection("Suzy", vL);
            vL[i].make_connection("Sheena", vL);
        }

        if (vL[i].get_name()=="Johnny")
        {
            vL[i].make_connection("Joey", vL);
            vL[i].make_connection("Suzy", vL);
        }

        if (vL[i].get_name()=="DeeDee")
        {vL[i].make_connection("Suzy", vL);}

        if (vL[i].get_name()=="Tommy")
        {vL[i].make_connection("Suzy", vL);}

        if (vL[i].get_name()=="Sheena")
        {vL[i].make_connection("Joey", vL);
        }
    }
}

Main.cpp

#include "error.h"
#include "LiwanzenVZ.h"
using namespace std;

int main() {
    try{

    string sname = "";
    char cend = 'a';
    vector  vL;

    populate(vL);
    init_connections(vL);
    print_LVZMembers(vL);
    cout << "\n";

    while (cend != 'q' && cend!='Q')
    {
        cout << "Möchten Sie ein neues Mitglied hinzufügen? (C) Continue, (Q) Quit." << endl;         cin >> cend;
        if (cend=='c' || cend=='C')
        {
                cout << "Name des neuen Mitglieds:";                 if (cin >> sname)
                {
                        add_Liwanze(vL, sname);
                        print_LVZMembers(vL);
                        cout << "\n";
                }
        }
        else
        {
            if (cend=='q' || cend=='Q'){}
            else{error("Ungültige Eingabe");}
        }
    }
    while (1!=0)
    {
        cout << "\nZwei Mitglieder miteinander verbinden:";
        connect_2(vL);
    }
    print_LVZMembers(vL);
    return 0;
    }
    catch (exception &e)
    {cerr << e.what();}
    catch (...)
    {cerr << "Unbekannter Fehler";}
}

LiwanzenVZ.h

#include
#include
using namespace std;

#ifndef LIWANZENVZ_H
#define	LIWANZENVZ_H

class Liwanze;

void populate(vector&);
void print_LVZMembers(const vector&);
void add_Liwanze(vector&, string);
bool b_check_ok(const vector&, string);
void init_connections(vector&);
void add_2(vector&);
void connect_2(vector&);
void error (string);
void error (string, string);

class Liwanze{
public:
    enum Region{ndef, amer, apac, emea};
    Liwanze();
    Liwanze( string, Region );
    string get_name() const;
    Region get_loc() const;
    void print() const;
    bool connects(Liwanze*) const;
    bool connected(Liwanze*) const;
    void print_tierone() const;
    void add_connTo(Liwanze*);
    void add_connFrom(Liwanze*);
    void make_connection(string, vector&);

private:
    string name;
    Region loc;
    vector connectsTo;
    vector connectedFrom;
};
#endif	/* LIWANZENVZ_H */

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 1 (Probeklausur) erschien zuerst auf Maximilian Krieg.

a) Kehren Sie zum ggT Programm (aus Grundlagen, Teil 2) zurück. Überarbeiten Sie das Programm so, dass es mittels C++ Ausnahmen mögliche Fehler abfängt. Nach dem Abfangen eines Fehlers soll das Programm eine vernünftige Fehlermeldung ausgeben und sich beenden.

#include "MEIN_EIGENER_HEADER.h"
// Einbinden der eigenen Header-Datei
using namespace std;

int main() {
try {
	bool bend = false;
	int i1 = 0, i2 = 0, tmp = 0, n = 1;

	while (bend == false)
	{
		cout << "Zwei positive ganze Zahlen eingeben: "; 		if (cin >> i1) // Wenn der eingelesene Wert in i1 gespeichert werden kann,
		{
			if (cin >> i2) // Wenn der eingelesene Wert in i2 gespeichert  werden kann,
			{
				if (i1 > 0 && i2 > 0) // Wenn i1 größer als 0 und i2 größer als 0
				{
					while (i1 != i2) // Solange i1 ungleich i2
					{
						cout << "\t(" << i1 << "," << i2 << ")" << endl;
						if (i1 < i2) // Wenn i1 kleiner als i2
						{
							i2 = i2 - i1;
						}
						else
						{
							tmp = i1;
							i1 = i2;
							i2 = tmp - i1;
						}
						++n;
					} // Ende von while

					cout << "\t(" << i1 << "," << i2 << ")" << endl;
					cout << n << " Schritte zum ggT\n" << endl;

				}
				else
				{
					error("i1 und i2 muessen positiv sein.");
				}
			}
			else // Wenn der eingelesene Wert nicht in i2 gespeichert werden kann
			{
			error("i2 ist keine ganze Zahl.");
			}
		}
		else // Wenn der eingelesene Wert nicht in i1 gespeichert werden kann
		{
			error("i1 ist keine ganze Zahl.");
		}
	} // Ende von while
}

catch (exception &e)
{
	cerr << e.what();
}

catch (...) // Fängt alle anderen Ausnahmefehler ab
{
	cerr << "Fehler unbekannt.";
}
}

b) Kehren Sie zum Ziffer/Zeichenketten Programm – Aufgabe 6 aus dem 2. Praktikumsblatt – zurück. Überarbeiten Sie auch dieses Programm entsprechend der obigen Aufgabenstellung a).

#include
#include "MEIN_EIGENER_HEADER.h"
using namespace std;

int main() {
try {
	string stmp = "<>";
	int itmp = 0;
	vector vNames;
	vector vScores;

	while (cin >> stmp >> itmp && (stmp != "noname" || itmp != 0)) // Solange die Eingabe in stmp, itmp gespeichert werden kann und stmp ungleich noname und itmp ungleich 0 ist
	{
		for (int i = 0; i < vNames.size(); i++) // Prüfen, ob ein Name bereits eingegeben wurde
		{
			if (vNames[i] == stmp)
			{
				error("Achtung, es wurde ein Name doppelt eingegeben.\n\"" + stmp + "\" ist schon einmal vorhanden.\nProgramm wird nun beendet.\n");
				return 1;
			}
		}

		vScores.push_back(itmp); // Speichern des eingelesenen Wertes itmp im  Vektor vScores
		vNames.push_back(stmp);	// Speichern des eingelesenen Wertes stmp im  Vektor vNames
	}
	if (cin.fail()) // Wenn die Eingabe fehlschlägt
	{
		error("Fehlerhafte Eingabe. Der erste Begriff muss ein Name, der zweite Begriff eine Zahl, sein.");
	}
	else // Ansonsten Ausgabe der Daten
	{
		cout << "Folgende Daten wurden einegegeben:\n" << endl;

		for (int i = 0; i < vNames.size(); i++)
		{
			cout << vNames[i] << ", " << vScores[i] << endl;
		}
	}

	return 0;

	}

catch (exception &e)
{
	cerr << e.what();
}

catch (...)
{
	cerr << "Fehler nicht bedacht." << endl;
}
}

c) (Optional) Überarbeiten Sie entsprechend alle bisher durchgenommenen Programmbeispiele, die keine Fehlerbehandlung mit C++ Exceptions enthalten.

Aufgabe 2

a) Schreiben Sie ein Programm, das eine Reihe von Zahlen einliest und in einem vector<int> Container speichert. Nachdem der Benutzer eine beliebige Anzahl von Zahlen eingegeben hat, fragt das Programm, wie viele Zahlen davon aufaddiert werden sollen. Lautet die Antwort n, werden die ersten n Elemente des vector Containers sowie deren Summe ausgegeben.

Beispielsweise: Geben Sie einige Zahlen ein (mit ‚q‘ beenden Sie die Eingabe): 12 23 13 24 15 q Wie viele Zahlen sollen aufaddiert werden: 3 Die Summe der erste 3 Elemente 12, 23 und 13 ist 48.

Verwenden Sie Ausnahmen, um möglichst alle Fehler zu behandeln. Behandeln Sie v.a. alle möglichen Eingaben. Stellen Sie auch sicher, dass eine vernünftige Fehlermeldung ausgegeben wird, wenn mehr Zahlen addiert werden sollen als im vector vorhanden sind.

#include
#include "MEIN_EIGENER_HEADER.h"
#include
using namespace std;

int main() {
try {
	vector vzahlen;
	int itemp = 0, iausgabe = 0, isumme = 0;
	char cend = 'a';

	cout << "Geben Sie einige Zahlen ein (mit 'q' beenden Sie die Eingabe):" << endl; 	while (cend != 'q') // Solange nicht q eingegeben wurde 	{ 		if (cin >> itemp) // Wenn die Eingabe itemp gespeichert werden kann
		{
			vzahlen.push_back(itemp);
		}
		else // Schreibe Wert in Vektor
		{
			cin.clear();
			if (cin >> cend && cend != 'q')  // Wenn die Eingabe erfolgreich und nicht q eingegeben wurde
			{
				error("Es duerfen nur 'q' oder ganze Zahlen als Operatoren eingegeben werden. Programm wird nun beendet.");
			}
		}
	}

	cout << "Wie viele Zahlen sollen aufaddiert werden:" << endl; 	if (cin >> iausgabe) // Wenn Eingabe in iausgabe gespeichert werden kann
	{}
	else
	{
		error("Eingegebener Wert ungueltig. Programm wird nun beendet.");
	}

	if (vzahlen.size() >= iausgabe) // Wenn weniger Zahlen aufaddiert werden sollen, als im Vektor gespeichert sind
	{
		cout << "Die Summe der ersten " << iausgabe << " Elemente ";
		for (int i = 0; i < iausgabe; i++) // Aufaddieren der Werte
		{
			cout << vzahlen[i];
			isumme = isumm e + vzahlen[i];
			if (i < iausgabe - 2) // Formatierung der Ausgabe,
			{
				cout << ", ";
			}
			else
			{
				if (i < iausgabe - 1)
				{
					cout << " und ";
				}
			}
		}
		cout << " ist " << isumme << endl;
	}
	else
	{
		error("Zu wenig Stellen");
	}

	return 0;
}

catch (exception &e)
{	// Fangen des Fehlers error
	cerr << e.what();
	return 1;
}
catch (...)
{ // Fangen von allen anderen Ausnahmefehlern
	cerr << "Unbekannter Fehler. Programm wird beendet.";
	return 1;
}
}

b) Erweitern Sie das Programm so, dass double-Werte statt int-Werte verwendet werden. Erstellen Sie einen zusätzlichen vector Container mit double-Werten für die (n-1) Differenzen zwischen den jeweils nacheinander eingegebenen Werten. Geben Sie auch die Differenzen aus.

#include
#include "MEIN_EIGENER_HEADER.h"
using namespace std;

void dsumme(const vector& vzahlen, const int& iausgabe) // Anlegen einer Funktion dsumme ohne Rückgabewert, die die Summe der ersten X Werte berechnet
{
	double dsum = 0.0;
	cout << "Die Summe der ersten " << iausgabe << " Elemente ";
	for (int i = 0; i < iausgabe; i++)
	{
		cout << vzahlen[i];
		dsum = dsum + vzahlen[i];
		if (i < iausgabe - 2) // Formatierung der Ausgabe
		{
			cout << ", ";
		}
		else
		{
			if (i < iausgabe - 1)
			{
				cout << " und ";
			}
		}
	}

	cout << " ist " << dsum << endl;
}

void ddifferenzen(const vector& vdifferenzen) // Funktion zur Ausgabe der n-1 Differenz
{
	cout << "Die Differenz der Zahlen lautet: ";
	for (int i = 0; i < vdifferenzen.size(); i++)
	{
		cout << vdifferenzen[i];
		if (i < vdifferenzen.size() - 2) // Formatierung der Ausgabe
		{
			cout << ", ";
		}
		else
		{
			if (i < vdifferenzen.size() - 1)
			{
				cout << " und ";
			}
		}
	}

	cout << endl;
	return 0;

}

int main() {
try {
	vector vzahlen;
	vector vdifferenzen;
	double itemp = 0;
	int iausgabe = 0;
	char cend = 'a';

	cout << "Geben Sie einige Zahlen ein (mit 'q' beenden Sie die Eingabe):" << endl; 	while (cend != 'q') {	// Solange nicht q eingegeben wurde 		if (cin >> itemp) // Wenn die Eingabe in itemp gespeichert werden kann
		{
			vzahlen.push_back(itemp); // Schreibe itemp in den Vektor
			if (vzahlen.size() > 1) // Berechnung der Differenzen nur möglich, wenn mehr als ein Wert eingegeben wurde
 			{
				if (vzahlen[vzahlen.size() - 2] >= vzahlen[vzahlen.size() - 1]) // Dieses if-else Konstrukt ermittelt den Betrag zwischen zwei Zahlen, immer größere Zahl - kleinere und schreibt die Differenz in einen eigenen Vektor
				{
					vdifferenzen.push_back(vzahlen[vzahlen.size() - 2] - vzahlen[vzahlen.size() - 1]);
				}
				else
				{
					vdifferenzen.push_back(vzahlen[vzahlen.size() - 1] - vzahlen[vzahlen.size() - 2]);
				}
			}
		}
		else
		{
			cin.clear();
			if (cin >> cend && cend != 'q')
			{
				error("Es duerfen nur 'q' oder ganze Zahlen als Operatoren eingegeben werden.");
			}
		}
	} // Ende von while

	cout << "Wie viele Zahlen sollen aufaddiert werden?" << endl; 	if (cin >> iausgabe) // Wenn die Eingabe in iausgabe gespeichert werden kann, tue nichts
	{}
	else
	{
		error("Eingegebener Wert ist ungueltig.");
	}

	if (vzahlen.size() >= iausgabe) // Wenn Vektorgröße größer gleich der eingegebenen Zahl
	{
		dsumme(vzahlen, iausgabe); // Funktionsaufruf dsumme und Übergabe der Parameter
		ddifferenzen(vdifferenzen); // Funktionsaufruf ddifferenzen und Übergabe der Parameter
	}
	else
	{
		error("Es wurden weniger Zahlen eingegeben, als ausgegeben werden sollen.");
	}

	return 0;
}

catch (exception &e) // Abfangen von error
{
	cerr << e.what();
	return 1;
}
}

Aufgabe 3

a) Zeichnen Sie einen Parserbaum nach den vorgestellten formalen Grammatikregeln für den Rechenausdruck (17-4)/(5-1).

b) Erweitern Sie das Mini-Rechner Programm aus der Vorlesung so, dass auch negative Zahlen direkt eingegeben werden können. Ein Rechenausdruck wie -7*3 soll auch so eingegeben werden können, und nicht wie bislang nur als (0-7)*3 akzeptiert werden. Hinweise: Sie müssen dafür die wie folgt erweiterte Grammatik implementieren:

Primary : Number ‚(‚ Expression ‚)‘ ‚-‚ Primary ‚+‘ Primary

Faktor (Punktoperand) : Zahl ‚(‚ Rechenausdruck ‚)‘ ‚-‚ Faktor ‚+‘ Faktor

Implementieren Sie unäres Minus und unäres Plus.

#ifndef TOKEN_H
#define	TOKEN_H

class Token
{

	public:
		char kind; // Kategorien
		double value; // Bei Zahlenkategorie: ein Wert

		Token(char ch) //  Memberfunktion: erstelle ein Token aus einem char
		: kind(ch), value(0)
		{} /* mache nichts sonst */

		Token(char ch, double val) //Memberfunktion: erstelle ein Token aus einem char und einem double
		: kind(ch), value(val)
		{}/* mache nichts sonst */
 };

class Token_stream
{
	public:
		Token_stream() : full(false), buffer(' ')
		{} // Konstruktor

		void putback(Token t) // Token "zurückstellen"
		{
			if (full) error("Token_stream::putback(), Puffer voll!\n");
			buffer = t;
			full = true;
		};

		Token get(); // Token aus cin erzeugen

	private:
		bool full; // ist buffer voll?
		Token buffer;
};

Token Token_stream::get()
{
	if (full)
	{
		full = false;
		return buffer;
	}

	char ch;
	cin >> ch;

	switch (ch)
	{
		case 'h': case 'H':
		{
			return Token('h');
		}

		case ';': // Ende eines Rechenausdrucks

		case 'q': // Programmende

		case '(': case ')': case '+': case '-': case '*': case '/':
		{
			return Token(ch); // jedes Zeichen ist sein eigenes Token
		}

		case '.': case '0': case '1': case '2': case '3': case '4':// Zahl als Token
		case '5': case '6': case '7': case '8': case '9':
		{
			cin.putback(ch); // der cin Stream kennt auch ein putback()
			double val;
			cin >> val;
			return Token('9', val);
		}

		default: error("Token Token_stream::get(), unbekanntes Token!\n");
	}
}
#endif	/* TOKEN_H */

#ifndef FUNCTIONS_H
#define	FUNCTIONS_H
double rechenausdruck(Token_stream &Ts);
double faktor(Token_stream &Ts);
double summand(Token_stream &Ts);

double rechenausdruck(Token_stream &Ts) // "plus" und "minus" behandeln
{
	double li = summand(Ts);
	Token t = Ts.get();
	while (true)
	{
		switch (t.kind)
		{
			case '+':
			{
				li += summand(Ts);
				t = Ts.get();
				break;
			}
			case '-':
			{
				li -= summand(Ts);
				t = Ts.get();
				break;
			}
			default:
			{
				Ts.putback(t);
				return li;
			}
		}
	}
}

double summand(Token_stream &Ts) // "mal" und "geteilt durch" behandeln
{
	double li = faktor(Ts);
	Token t = Ts.get();
	while (true)
	{
		switch (t.kind)
		{
			case '*':
			{
				li *= faktor(Ts);
				t = Ts.get();
				break;
			}
			case '/':
			{
				double d = faktor(Ts);
				if (d == 0) error("Div. durch 0!\n");
				li /= d;
				t = Ts.get();
				break;
			}
			default:
			{
				Ts.putback(t);
				return li;
			}
		}
	}
}

double faktor(Token_stream &Ts) // Zahlen und Klammern behandeln
{
	Token t = Ts.get();
	switch (t.kind)
	{
		case '(':
		{
			double d = rechenausdruck(Ts);
			t = Ts.get();
			if (t.kind != ')') error(") erwartet!\n");
			return d;
		}
		case '9':
		{
			return t.value;
		}
		case '+':
		{
			return faktor(Ts);
		}
		case '-':
		{
			return faktor(Ts) * -1;
		}
		default:
		{
			error("Faktor erwartet!\n");
		}
	}
}

#endif	/* FUNCTIONS_H */

using namespace std;
#include "MEIN_EIGENER_HEADER.h"
#include "token.h"
#include "functions.h"

int main() {
try {
	Token_stream T;
	while (cin)
	{

		Token t = T.get();

		while (t.kind == ';')
		{
			t = T.get();
		}

		if (t.kind == 'q')
		{
			return 0;
		}

		T.putback(t);
		cout << "=" << rechenausdruck(T) << endl;

	}
	return 0;
}

catch (exception &e)
{
	cerr << e.what();
	return 1;
}
}

c) Erstellen Sie einen Satz von Eingabedaten und die dazu gehörenden, von Ihnen erwarteten Ausgaben zum Testen des Mini-Rechner Programms. Wonach sollten Sie Ausschau halten? Ist Ihre Liste mit Testdaten vollständig? Denken Sie auch an extreme Werte und „unsinnige“ Eingaben. Additon

• 1+1;
• 1++1;
• +1+1;
• ++1++1;
• 0+1;
• 1+0;

Subtraktion

• 1-1;
• 1–1;
• -1-1;
• –1–1;
• 1-0;
• 0-1;

Mixed

• +1-1;
• -1+1;
• +-1+-1;

Multiplikation Plus

• 1*1;
• +1*+1;
• ++1*++1;
• 0*(+1);

Multiplikation Minus

• 1*-1;
• -1*-1;
• –1*–1;
• 0*(-1);

Mixed

• -(+1)*-(+1);
• +(-1)*+(-1);
• -+1*-+1;
• +-1*+-1;

Division

• 1/1;
• +1/+1;
• -1/-1;
• +1/-1;
• -1/+1;
• +(1/1);
• -(1/1);

d) Jedes Programm sollte dem Benutzer irgendeine Form von Hilfe anbieten. Ändern Sie das Mini-Rechner Programm so, dass bei der Eingabe von h oder H einige Anweisungen zur Bedienung ausgegeben werden.

using namespace std;
#include "MEIN_EIGENER_HEADER.h"
#include "token.h"
#include "functions.h"

int main()
{
try{
	cout << "Taschenrechner:" << endl;
 	cout << "Bitte geben Sie die zu berechnenden Terme ein."<< endl;

	Token_stream T;
	while (cin)
	{
 	 	Token t = T.get();

 	 	while (t.kind == ';')
		{
			t = T.get();
		}

 	 	if (t.kind == 'q')
		{
 	 	 	return 0;
 	 	}
		else
		{
 	 		if (t.kind == 'h')
			{
				cout << "Hilfe" << endl;
                		cout << "Rechenoperatoren: '+', '-', '*', '/'" << endl;
                		cout << "Rechenoperanden: Zahlen, '(', ')'" << endl;
 	 	 	}
			else
			{
 	 	 	 	T.putback(t);
 	 	 	 	cout << "=" << rechenausdruck(T) << endl;
	 	 	}
	 	}
	}
 	return 0;
}
catch (exception &e)
{
	cerr << e.what();
	return 1;
}
}

Token Token_stream::get()
{
	if (full)
	{
		full = false;
		return buffer;
	}

	char ch;
	cin >> ch;
	switch (ch)
	{
		case 'h': case 'H':
		{
			return Token('h');
		}

		case ';': // Ende eines Rechenausdrucks

		case 'q': // Programmende

		case '(': case ')': case '+': case '-': case '*': case '/':
		{
			return Token(ch); // jedes Zeichen ist sein eigenes Token
		}

		case '.': case '0': case '1': case '2': case '3': case '4':
		case '5': case '6': case '7': case '8': case '9': // Zahl als Token
		{
			cin.putback(ch); // der cin Stream kennt auch ein putback()
			double val;
			cin >> val;
			return Token('9', val);
		}

		default:
		{
			error("Token Token_stream::get(), unbekanntes Token!\n");
		}
	}
}

e) (Optional) Sie werden feststellen, dass Ein- und Ausgabeprompt

> _ bzw. = 42

des Mini-Rechner Programms sich unter bestimmten Umständen seltsam verhalten. Verbessern Sie das Programm so, dass immer eine korrekte Ein- bzw. Ausgabeaufforderung angezeigt wird. Hinweis: Sie könnten die formatierte Eingabe mit cin >> durch die unformatierte Eingabe mit cin.get() ersetzen und unerwünschte Zeichen selbst filtern.Plus.

Aufgabe 4

a) Lesen Sie über die Standardeingabe Wochentag/Wert-Paare ein,

Beispielsweise: Donnerstag 23 Freitag 56 Donnerstag -3 Dienstag 99

Sammeln Sie für jeden Wochentag die eingegebenen Werte in einem eigenen vector<int> Container. Beenden Sie die Eingabe durch q als Wochentag. Geben Sie die Werte in den sieben Wochentage-Containern aus. Geben Sie die Summe der Werte in jedem Container aus. Ignorieren Sie unzulässige Wochentage wie „Freutag“, aber lassen Sie geläufige Abkürzungen (wie „Fr“) zu. Geben Sie die Anzahl der wegen unzulässigem Tag abgelehnten Werte aus.

#include "MEIN_EIGENER_HEADER.h"
#include <iostream>
#include <vector>
using namespace std;

int isumme (vector<int> &vtage)
{
	int result =0;
	for (int i=0; i<vtage.size();i++)
	{
		result = result + vtage[i];
	}
	return result;
}

int main() {
try {
	string stemp = "";
	int itemp = 0;
	int iilegaldays = 0;

	vector<int> vmontag;
	vector<int> vdienstag;
	vector<int> vmittwoch;
	vector<int> vdonnerstag;
	vector<int> vfreitag;
	vector<int> vsamstag;
	vector<int> vsonntag;

	while (stemp != "q")
	{

		cin >> stemp;

		if (cin >> itemp)
		{
			if (stemp == "Montag" || stemp == "Mo")
			{
				vmontag.push_back(itemp);
			}
			else
			{
				if (stemp == "Dienstag" || stemp == "Di")
				{
					vdienstag.push_back(itemp);
				}
				else
				{
					if (stemp == "Mittwoch" || stemp == "Mi")
					{
						vmittwoch.push_back(itemp);
					}
					else
					{
						if (stemp == "Donnerstag" || stemp == "Do")
						{
							vdonnerstag.push_back(itemp);
						}
						else
						{
							if (stemp == "Freitag" || stemp == "Fr")
							{
								vfreitag.push_back(itemp);
							}
								else
								{
								if (stemp == "Samstag" || stemp == "Sa")
								{
									vsamstag.push_back(itemp);
								}
								else
								{
									if (stemp == "Sonntag" || stemp == "So") {
										vsonntag.push_back(itemp);
									}
									else
									{
										iilegaldays++;
									}
								}
							}
						}
					}
				}
			}

		}
		else
		{
			cin.clear();
			if (cin >> stemp && stemp != "q")
			{
				error("Ungueltige Eingabe fuer Wochentag oder Wert.");
			}
			else
			{
				cout << "'q' wurde als Zahl eingegeben." << endl;
				cout << "Fuehre automatische Korrektur durch." << endl;
			}
		}
	}

	cout << "Anzahl der falsch eingegebenen Tage: "<<iilegaldays <<endl;
	cout << "Montage: "<<isumme(vmontag) <<endl;
	cout << "Dienstage: "<<isumme(vdienstag) <<endl;
	cout << "Mittwoche: "<<isumme(vmittwoch) <<endl;
	cout << "Donnerstage: "<<isumme(vdonnerstag) <<endl;
	cout << "Freitage: " <<isumme(vfreitag) <<endl;
	cout << "Samstage: " <<isumme(vsamstag) <<endl;
	cout << "Sonntage: " <<isumme(vsonntag) <<endl;

	return 0;

}

catch (exception &e)
{
	cerr << e.what();
	return 1;
}
}

b) Definieren Sie nun eine Klasse Name_values, die einen string und ein vector<int> enthält. Statten Sie die Klasse mit einem Konstruktor und mit den erforderlichen Memberfunktionen zur Speicherung von Werten und zur Ausgabe aus. Überarbeiten Sie das Programm aus a) so, dass statt sieben vector Container nur noch ein vector<Name_values> Container verwendet wird.

#include "class.h"
#include "methods.h"
#include "MEIN_EIGENER_HEADER.h"
#include <vector>

using namespace std;

int main() {
try {
	vector<name_value> vnamevalues(7);
	string strDay;
	int ivalue = 0, iilegal = 0;

	vnamevalues[0] = name_value("Montag");
	vnamevalues[1] = name_value("Dienstag");
	vnamevalues[2] = name_value("Mittwoch");
	vnamevalues[3] = name_value("Donnerstag");
	vnamevalues[4] = name_value("Freitag");
	vnamevalues[5] = name_value("Samstag");
	vnamevalues[6] = name_value("Sonntag");

	while (strDay != "q")
	{
		cin >> strDay;
		if (cin >> ivalue)
		{
			if (strDay == "Montag" || strDay == "Mo")
			{vnamevalues[0].set(ivalue);}
			else
			{
				if (strDay == "Dienstag" || strDay == "Di")
				{vnamevalues[1].set(ivalue);}
				else
				{
					if (strDay == "Mittwoch" || strDay == "Mi")
					{vnamevalues[2].set(ivalue);}
					else
					{
						if (strDay == "Donnerstag" || strDay == "Do")
						{vnamevalues[3].set(ivalue);}
						else
						{
							if (strDay == "Freitag" || strDay == "Fr")
							{vnamevalues[4].set(ivalue);}
							else
							{
								if (strDay == "Samstag" || strDay == "Sa")
								{vnamevalues[5].set(ivalue);}
								else
								{
									if (strDay == "Sonntag" || strDay == "So")
									{vnamevalues[6].set(ivalue);}
									else
									{iilegal++;}
								}
							}
						}
					}
				}
			}
		}
		else
		{
			cin.clear();
			if (cin >> strDay && strDay == "q")
			{
				cout << "Bitte \"q\" nur fuer den ersten Wert eingeben." << endl;
				cout << "Fuehre Korrektur durch." << endl;
			}
			else
			{
				error("Ungueltige Eingabe fuer den Wert.");
			}
		}
	}

	cout << "Sie haben folgende Werte eingegeben: " << endl;

	for (int i = 0; i < vnamevalues.size(); i++) //Alle Tage durchlaufen
	{cout << vnamevalues[i].get() << ": " << vnamevalues[i].isumme() << endl;}

	cout << "Anzahl der falsch eingegebenen Tage: " << iilegal << endl;

	return 0; //reguläres Programmende
}
catch (runtime_error &e)
{
	cerr << e.what(); //Fehlerausgabe
	return 1; //Programmende nach Fehler
}
}

#ifndef METHODS_H
#define	METHODS_H

name_value::name_value() : //Standardkonstruktor
sname("Montag"),vvalue() {}

name_value::name_value(string strDay) :
sname(strDay), vvalue() { }

void name_value::set(int ivalue)
{
	vvalue.push_back(ivalue);
}

int name_value::size()
{
	return vvalue.size();
}

int name_value::isumme()
{
	int iergebnis = 0;
	for (int i = 0; i < vvalue.size(); i++)
	{
		iergebnis = iergebnis + vvalue[i];
	}
	return iergebnis;
}

string name_value::get()
{
	return sname;
}
#endif	/* METHODS_H */

#ifndef NAME_VALUES_H
#define	NAME_VALUES_H

#include <iostream>
#include <vector>
#include <stdexcept>

using namespace std;

class name_value
{
	public:
		name_value();
		name_value(string strDay);

		void set(int);
		int size();
		int isumme();
		string get();

	private:
		string sname;
		vector<int> vvalue;
};
#endif	/* NAME_VALUES_H */

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 1 (Praktikum 3) erschien zuerst auf Maximilian Krieg.

a) Schreiben Sie ein Programm, das eine Gleitkommazahl als Benutzereingabe einliest und die Quadratwurzel dieser Zahl ausgibt. Eingabeaufforderung: Geben Sie eine Gleitkommazahl >= 0 ein: Antwort des Programms (z.B. bei Eingabe von 9.7): Die Quadratwurzel von 9.7 ist 3.1145 Hinweis: Die C++ StdLib stellt über den Header cmath eine Schnittstelle zur Funktion double sqrt( double ) zur Verfügung, die Sie in Ihrem Programm verwenden sollten. Wählen Sie alle Ihre Namen nach der „Ungarischen Notation“.

#include <iostream>
#include <cmath>
using namespace std;

int main()
{
	double dwurzel=0.0;
	cout << "Geben Sie eine Gleitkommazahl >= 0 ein:";
	cin >> dwurzel;
	cout << "Die Quadratwurzel von " << dwurzel << " ist " << sqrt( dwurzel );
}

b) Schreiben Sie das Quadratwurzel Programm jetzt so, dass die Wurzelberechnung ohne den Einsatz von Bibliotheksfunktionen und nur mit dem Kontrollprimitiv Sequenz, ohne Selektions- und Iterationsprimitiv (d.h. ohne Schleifen und Verzweigungen) erfolgt. Hinweis: Die Quadratwurzel einer Zahl x0 lässt sich berechnen, indem sie als Grenzwert einer Folge gesehen wird: xn+1 = ( xn + a(xn)-1 ) 2-1 mit beliebigem Anfangswert a (z.B. a = x0). Für n= 0, 1, … konvergiert xn schnell gegen die Quadratwurzel von x0. In Ihrem Programm können Sie bei n = 8 abbrechen das Ergebnis ausgeben. Was bemerken Sie, wenn Sie die Quadratwurzel auf diese Art berechnen und weder Bibliotheksfunktion noch Selektions- und Iterationsprimitiv einsetzen?

#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;

double wurzelberechnung (double dwurzel)
{
	double danfangswert=dwurzel;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	dwurzel=(dwurzel+(danfangswert/dwurzel))/2;
	return dwurzel;
}

int main()
{
	double dwurzel=0.0;
	cout << "Geben Sie eine Gleitkommazahl >= 0 ein:";
	cin >> dwurzel;
	cout << "Die Quadratwurzel von " << dwurzel << " ist " << wurzelberechnung(dwurzel);
	return 0;
}

c) Schreiben Sie das Quadratwurzel Programm nochmals ohne Bibliotheksfunktionen (Sie dürfen nur iostream für Ein- und Ausgabe verwenden), aber mit Selektions- und Iterationsprimitiven. Brechen Sie die Schleife ab, sobald eine frei wählbare Genauigkeit der Berechnung erreicht ist. Geben Sie die erzeilte Genauigkeit und einen Prüfwert aus.

#include <iostream>
using namespace std;

double wurzelberechnung(double dwurzel, int igenauigkeit)
{
	double danfangswert = dwurzel;
	for (int i = 0; i < igenauigkeit; i++)
	{
		 dwurzel = (dwurzel + (danfangswert / dwurzel)) / 2;
	}
	return dwurzel;
}

int main() {
	double dzahl = 0.0;
	double dwurzel = 0.0;
	int igenauigkeit = 1;
	cout << "Geben Sie eine Gleitkommazahl >= 0 ein:";
	cin >> dzahl;
	cout << "Geben Sie eine Genauigkeit > 0 ein:";
	cin >> igenauigkeit;
	dwurzel = wurzelberechnung(dzahl, igenauigkeit);
	cout << "Die Quadratwurzel von " << dzahl << " ist " << dwurzel << "\n";
	cout << "Die Genauigkeit betraegt: " << igenauigkeit << "\n";
	cout << "Der Prueftwert betraegt: " << dwurzel << "*" << dwurzel << "=" << (dwurzel * dwurzel) << "\n";
	return 0;
}

d) Warum sollte man lieber die Bibliotheksfunktion verwenden? Gründe:

• Die Verwendung von Funktionen aus der Standardbibliothek ermöglichen den Einsatz des Programms auf jeglichem System
• Ergebnis ist durch Standardisierung der Bibliothek verfiziert (Fehlerfreiheit)
• Prinzip der Wiederverwendung

Aufgabe 2

a) Ändern Sie den Programmablaufplan (PAP) des ggT Programms (aus der Vorlesung / Hörsaalübung) so, dass der Programmablauf nach Abschluss der Berechnung und Ausgabe der Ergebnisse wieder zurückkehrt zur Eingabeaufforderung für die beiden Zahlen, und alles wieder von vorne losgeht.

b) Schreiben Sie das Programm nach dem von Ihnen geänderten PAP um.

#include <iostream>
using namespace std;
int main()

{
	int i1 = 0, i2 = 0, tmp = 0, n = 1;
	bool bflagend = false;
	while (bflagend == false) {
		 cout << "Zwei positive ganze Zahlen eingeben: "; 		 cin >> i1 >> i2;
		 while (i1 != i2) {
			  cout << "\t(" << i1 << "," << i2 << ")" << endl;
			  if (i1 < i2) i2 = i2 - i1;
			  else {
					tmp = i1;
					i1 = i2;
					i2 = tmp - i1;
			  }
			  ++n;
		 }
		 cout << "\t(" << i1 << "," << i2 << ")" << endl;
		 cout << n << " Schritte zum ggT\n" << endl;
	}
}

Aufgabe 3

Schreiben Sie ein Programm, das einen Operator und zwei Operanden einliest, die  gewünschte Operation durchführt und das Ergebnis anzeigt, zum Beispiel: $> Operation: + 34.5 99 $> Operation: * 3 8.2 $> Ergebnis: 133.5 $> Ergebnis: 24.6 Berücksichtigen Sie die Operatoren +, -, * und / mit den offensichtlichen Bedeutungen. Lesen Sie den Operator in eine string-Variable und die Operanden in double-Variablen. Stellen Sie mittels if fest, welche Operation ausgeführt werden soll, z.B.: if(str_opSym= =“+“).

#include <cstdlib>
#include <iostream>
using namespace std;

int main()
{
	double doperand1 = 0.0, doperand2 = 0.0;
	string soperator = "+";
	cout << "Bitte zwei Operatoren und einen Operand eingeben:\n";
	cout << "Summe a+b mit '+', Differenz a-b mit '-', Produkt a*b mit '*' und Quotient a/b mit '/':\n"; 	cin >> doperand1 >> doperand2 >> soperator;
	if (soperator == "+")
	{
		 cout << "Summe aus " << doperand1 << "+" << doperand2 << "=" << doperand1 + doperand2;
	}
	else
	{
		 if (soperator == "-")
		 {
			  cout << "Differenz aus " << doperand1 << "-" << doperand2 << "=" << doperand1 - doperand2;
		 }
		 else
		 {
			  if (soperator == "*")
			  {
					cout << "Produkt aus " << doperand1 << "*" << doperand2 << "=" << doperand1 * doperand2;
			  }
			  else
			  {
					if (soperator == "/")
					{
						 if (doperand2 != 0.0)
						 {
							  cout << "Quotient aus " << doperand1 << "/" << doperand2 << "=" << doperand1 / doperand2;
						 }
						 else
						 {
							  cout << "Division durch 0 nicht erlaubt.";
						 }
					}
					else
					{
						 cout << "Kein gueltiger Operator eingegeben.";
					}
			  }
		 }
	}
}

Aufgabe 4

Der Median einer Zahlenreihe ist definiert als die Zahl, bei der höchstens die Hälfte der Zahlen aus der Zahlenreihe größer und höchstens die Hälfte der Zahlen aus der Zahlenreihe kleiner ist. Ändern Sie den Programmteil zur Berechnung des Medians aus dem Vorlesungsbeispiel so, dass der Median korrekt berechnet wird. Hinweis: Bei einer geraden Anzahl von Beobachtungen gibt es kein einziges mittleres Element, sondern zwei. Verwenden Sie für eine gerade Anzahl von Temperaturwerten das arithmetische Mittel der beiden mittleren Beobachtungswerte.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main( )
{
	vector vTemps; // Temperaturwerte
	double temp;
	double dmedian=0.0;
	while( cin >> temp ) // einlesen /*&& temp != -274*/
	{
		 vTemps.push_back( temp ); // speichern
	}
	// arithm. Mittel
	double sum = 0;
	for( int i=0; i	{
		 sum += vTemps[i];
	}
	cout << "Temperaturmittel: " << sum/vTemps.size() << endl; // Mittelwert aller Elemente im Vektor vTemps ausgeben 	sort( vTemps.begin(), vTemps.end() ); // sortieren mit Funktion aus StdLib, Header algorithm 	if (vTemps.size() % 2 > 0)
	{
		dmedian = vTemps[ vTemps.size()/2 ];
	}
	else
	{
		 dmedian =  (vTemps[ vTemps.size()/2 -1] + vTemps[ vTemps.size()/2 ])/2;
	}
	cout << "Median: " << dmedian << endl;
}

Aufgabe 5

a) Richten Sie einen vector ein, der die zehn Zeichenketten „null“, „eins“, „zwei“, „drei“, usw. bis „neun“ enthält. Verwenden Sie diesen in einem Programm, das für eine einzulesende Ziffer ihren entsprechenden ausgeschriebenen Wert ausgibt.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
	int ipointer=0;
	vector vZahlen(10);

	vZahlen[0]="null";
	vZahlen[1]="eins";
	vZahlen[2]="zwei";
	vZahlen[3]="drei";
	vZahlen[4]="vier";
	vZahlen[5]="fünf";
	vZahlen[6]="sechs";
	vZahlen[7]="sieben";
	vZahlen[8]="acht";
	vZahlen[9]="neun";

	cout << "Bitte Ziffer eingeben:"; 	cin >> ipointer;
	cout << vZahlen [ ipointer ];
}

b) Erweitern Sie das Programm so, dass auch ausgeschriebene Ziffern wie „sieben“ als Eingabe möglich sind, und das Programm dann die Ziffer aus der entsprechenden Zahl – oder, je nach Eingabe, die ausgeschriebene Zahl aus der Ziffer – ausgibt.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void vektorsuche(int izahl)
{
	vector vZahlen(10);

	vZahlen[0] = "null";
	vZahlen[1] = "eins";
	vZahlen[2] = "zwei";
	vZahlen[3] = "drei";
	vZahlen[4] = "vier";
	vZahlen[5] = "fünf";
	vZahlen[6] = "sechs";
	vZahlen[7] = "sieben";
	vZahlen[8] = "acht";
	vZahlen[9] = "neun";

	if (izahl > 0 && izahl < 10)
	{
		 cout << "Die gesuchte Zahl lautet: " << vZahlen[izahl];
	}
	else
	{
		 cout << "Die gesuchte Zahl wurde nicht gefunden.";
	}
}

int vektorsuche(string szahl)
{
	vector vZahlen(10);

	vZahlen[0] = "null";
	vZahlen[1] = "eins";
	vZahlen[2] = "zwei";
	vZahlen[3] = "drei";
	vZahlen[4] = "vier";
	vZahlen[5] = "fünf";
	vZahlen[6] = "sechs";
	vZahlen[7] = "sieben";
	vZahlen[8] = "acht";
	vZahlen[9] = "neun";

	for (int i = 0; i < 10; i++)
	{
		 if (vZahlen[i] == szahl)
		 {
			cout << "Die gesuchte Zahl lautet " << i;
			return 0;
		 }
	}

	cout << "Die gesuchte Zahl wurde nicht gefunden.";
}

int main()
{
	int izahl = 0;
	string szahl = "<>";
	cin >> izahl;

	if (cin)
	{
		 vektorsuche(izahl);
	}
	else
	{
		 if (!cin)
		 {
			cin.clear();
			cin >> szahl;
			vektorsuche(szahl);
		 }
	}
	return 0;
}

Aufgabe 6

Schreiben Sie ein Programm, das zuerst eine Reihe von Name-Wert Paaren der Form Barbara 22 oder Ben 17 einliest. Legen Sie von jedem Paar den Namen in einem vector namens vNames ab und den Wert in einem vector namens vScores, wobei die Positionen gleich sein sollen (d.h. wenn vNames[7]==Barbara dann auch vScores[7]==22). Beenden Sie die Eingabe durch noname 0. Stellen Sie sicher, dass jeder Name nur einmal  vorkommt und beenden Sie das Programm mit einer informativen Fehlermeldung, wenn ein Name ein zweites Mal eingegeben wird. Geben sie die (Name, Punkte)-Paare zeilenweise aus.

#include <vector>
#include <iostream>
using namespace std;

int main() {
	string stmp = "<>";
	int itmp = 0;
	vector vNames;
	vector vScores;
	while (cin >> stmp >> itmp && (stmp != "noname" || itmp != 0))
	{
		 for (int i = 0; i < vNames.size(); i++)
		 {
			  if (vNames[i] == stmp)
			{
					cerr << "Achtung, es wurde ein Name doppelt eingegeben.\n\"" << stmp << "\" ist schon einmal vorhanden.\nProgramm wird nun beendet.\n";
					return 1;
			}
		 }
		 vScores.push_back(itmp);
		 vNames.push_back(stmp);
	}

	cout << "Folgende Daten wurden einegegeben:\n";

	for (int i = 0; i < vNames.size(); i++)
	{
		 cout << vNames[i] << ", " << vScores[i] << "\n";
	}
	return 0;
}

Aufgabe 7 (optional)

Ändern Sie das einfache Wörterbuch Programm aus der Vorlesung so, dass bei mehrfach gleichen Wörtern nicht nur die Ausgabe unterdrückt wird, sondern dass das einfache Wörterbuch jedes Wort nur einmal speichert und Duplikate eliminiert. Das Programm soll zusätzlich auch die Anzahl der Wörter insgesamt sowie die Anzahl der gefundenen Duplikate ausgeben. Versuchen Sie (wie immer, aber hier ganz besonders), eine möglichst elegante und klare Lösung zu finden.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
	vector  vWords;
	string temp;
	bool bdoppler = false;
	int icounter = 0;

	while (cin >> temp && temp != "quit")
	{
		for (int i = 0; i < vWords.size(); ++i)
		{
			if (temp == vWords[i])
			{
				bdoppler = true;
				icounter = icounter + 1;
			}
		}

		if (bdoppler == false)
		{
			vWords.push_back(temp);
		}

	bdoppler = false;
	}

	cout << "Anzahl der Woerter: " << vWords.size() << endl;
	cout << "Anzahl der gefundenen Duplikate: " << icounter << endl;
	sort(vWords.begin(), vWords.end());

	for (int i = 0; i < vWords.size(); ++i)
	{
		 cout << vWords[i] << endl;
	}
}

Der Beitrag Programmieren, Algorithmen und Datenstrukturen 1 (Praktikum 2) erschien zuerst auf Maximilian Krieg.

• TLD = Top Level Domain
• Windhundverfahrens=Prioritätsprinzip

Erwägungsgründe:

• #16: 2. Chance für Registrare zum Zug zu kommen – z.B.: xyz.de ist schon belegt
• #17: Verstoß gegen die öffentliche Ordnung = Radikale Namen, Aufhetzung, etc.
• #20: First come, first serve – Prioritätsprinzip

Artikel:

• Artikel 1, Absatz 1:
  • Bedingungen
  • Benennung eines Registers
  • allgemeine Regelungsrahmen für die Arbeit des Registers
• Artikel 18:
  • Domänenname wird gesperrt nach gerichtlichem Entscheid, wenn er:
    • verleumderisch oder rassistisch ist
    • gegen die öffentliche Ordnung verstößt
  • Domäne bleibt gesperrt, solange das Urteil gilt
• Artikel 21, Absatz 1:
  • Widerruf eines Domänennamens, wenn er:
    • verwirrend ähnlich ist mit einem anderen Namen
    • identisch ist mit einem anderen Namen
• Artikel 21
  • Öffentliche Einrichtungen, Regierungen etc. haben Vorrecht auf Domänennamen

US-amerikanisches Recht:

§ 1125(D) – CYBERPIRACY PREVENTION

• Markenrechtlich angelehnt
• Bevorzugung der Gewerbetreibenden
• Anticybersquatting = Domäne „verstopfen“
• Unternehmen darf zivilrechtliche Klage gegen Person einleiten, wenn Person:
  • den Namen verwendet um Gewinn zu machen
  • unter diesem Namen Handel betreibt

Fall: sexquisit.de

• Domain seit 1999 registriert auf Unternehmen A
• Marke seit 2002 bei Unternehmen B registriert
• Prioritätsprinzip aufgrund vorheriger Zeit

Regeln im Online-Kauf:

1. Wählen Sie sichere Paßwörter und geben Sie diese niemals an Dritte weiter!
2. Achten Sie auf technische Sicherheit (Verschlüsselung) bei der Datenübertragung!
3. Überprüfen Sie die Seriosität des Anbieters! (Nicht immer eindeutig überprüfbar)
4. Prüfen Sie Artikelbeschreibung sowie Versan dund Lieferbedingungen!
5. Wählen Sie sichere Zahlungsmethoden, Bargeld-Transferservices sind nicht geeignet!
6. Achten Sie auf Ihr Widerrufs- oder Rückgaberecht bei gewerblichen Anbietern!
7. Schützen Sie sich vor „Datenklau“!

Fall: „ricardo.de“

• Deutsche Auktionsseite
• Student kauft Autos im Auslang
• Studen verkauft Autos im Inland
• Gemäß AGBs ist er Versteigerer, Erstnutzer, Verkäufer und Offerent
• Gemäß AGBs ist der potentielle Käufer Ersteigerer, Zweitnutzer, Käufer und Annehmender
• Käufer ersteigert für 26.500€ (Neu 52.000€)
• Verkäufer verweigert die Herausgabe

Gericht

• LG Münster sagt, dass der Verkäufer recht hat
• OLG Hamm sagt, dass der Käufer recht hat
• BGH sagt, dass Käufer recht hat

Unterschied zu realen Auktionshäusern:

• Bieter und Auktionator stehen sich nicht gegenüber
• Kein tatsächlicher Auktionator, der den Zuschlag durchführt
• ricardo.de nicht als Auktionshaus angemeldet

Willenserklärungen:

• empfangsbedürftig: Partner muss informiert werden
• nicht empfangsbedürftig: Partner muss nicht informiert werden
• körperlos
  • Sprache
  • Internet
  • Beides verschwindet sobald das Medium erlischt

Der Beitrag Internetrecht (Vorlesung 10) erschien zuerst auf Maximilian Krieg.

Algorithmen in Assemblerprogramme mit möglichst geringer Codegröße umzusetzen, sowie der Umgang Debugger und Simulator.

Arbeitsverzeichnis:

Kopieren Sie sich das Verzeichnis, welches Ihnen im Praktikum zur Verfügung gestellt wird, in Ihr persönliches Verzeichnis. Dort stehen Ihnen dann alle benötigten Dateien zur Verfügung.

Vorbereitung

Überlegen Sie sich ein Unterprogramm (Funktion), welches eine Zeichenkette in einem Text suchen soll. Die Funktion bekommt die Anfangsadresse des zu durchsuchenden Textes und die Anfangsadresse der zu suchenden Zeichenkette in den Registern R0 und R1 übergeben. Im Register R0 soll zurückgegeben werden , wie oft die zu suchende Zeichenkette im Text gefunden wurde. Bei einer leeren zu suchenden Zeichenkette liefert  die Funktion den Wert 0 zurück. Handelt es sich bei dem zu durchsuchenden Text um eine leere Zeichenkette, so liefert die Funktion den Wert 0 zurück.

Mögliche Aufrufe:

int searchStringInString(char*, char*);

int main (void)
{
int Anzahl;
char* Text="hallo Alles klar?";
char* Suchstring="ll";
char* Leerstring=““;
Anzahl = searchStringInString(Text, Suchstring);
Anzahl = searchStringInString(Text, Leersrtring);
Anzahl = searchStringInString(Leerstring, Suchstring);
Anzahl = searchStringInString(Leerstring, Leerstring);
return 0;
}

Überlegen Sie sich noch weitere Testfälle

Aufgabe 1:

Schreiben Sie Ihr Programm und testen es bevor Sie es im Praktikum vorführen.

.file "searchStringInString.s"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function
searchStringInString:
..
..
..

Lösung 1

@ in R0 wird die Adresse des zu durchsuchenden Text erwartet.
@ in R1 wird die Adresse des zu suchendenn Text erwartet.
@ sollte R0 auf einen leeren String zeigen,
@ oder der gesuchte Text nicht gefunden werden,
@ so wird in R0 der Wert 0 zurueck geliefert.
@ zeigt R1 auf einen leeren String so wird in R0 der Wert 0 zurueck gegeben

.file "searchStringInString.S"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function

searchStringInString:

stmfd sp!, {r4,r5,lr}

mov r4, r0 // Neues Register für den zu durchsuchenden Text

ldr r5,[r0]
cmp r5,#0x0
mov r0,#0x0 // Zähler auf 0 setzen
ldmeqfd sp!, {r4,r5,pc}

mov r3, r1 // Neues Register für den zu suchenden Text
mov r5, r3 // Sicherung der Adresse des zu suchenden Textes

//ldrb r1,[r3]
loop: // Schleife

LDRB r2, [r4],#1 // Erstes bzw. nächstes Zeichen des zu durchsuchenden Strings laden

CMP r1,r2 // Vergleich zu suchendes Zeichen = Zeichen in Zeichenkette
LDREQB r1, [r3],#1 // Wenn r1=r2 dann nächstes zu suchendes Zeichen laden

CMP r1,#0x0 // Vergleich ob r1 das letzte Zeichen war
ADDEQ r0,#0x1 // Zähler um 1 erhöhen
MOVEQ r3, r5 // r1 zurücksetzen

CMP r3, r5
LDREQB r1, [r3],#1

CMP r2, #0x0 // Prüfen ob r2 das letzte Zeichen war

BNE loop // Schleifenaufruf, wenn r2 nicht fertig ist

ldmfd sp!, {r4,r5,pc}

.size searchStringInString, .-searchStringInString

Zusatzaufgabe:

Überlegen Sie sich ein Unterprogramm (Funktion), welches eine Zeichenkette in einem Text suchen soll. Die Funktion bekommt die Anfangsadresse des zu durchsuchenden Textes und die Anfangsadresse der zu suchenden Zeichenkette in den Registern R0 und R1 übergeben. Im Register R0 soll zurückgegeben werden , wie oft die zu suchende Zeichenkette im Text gefunden wurde. Bei einer leeren zu suchenden Zeichenkette liefert die Funktion die Länge des zu durchsuchenden Text zurück. Handelt es sich bei dem zu durchsuchenden Text um eine leere Zeichenkette, so liefert die Funktion den Wert 0 zurück.

Lösung Zusatzaufgabe

@ in R0 wird die Adresse des zu durchsuchenden Text erwartet.
@ in R1 wird die Adresse des zu suchendenn Text erwartet.
@ sollte R0 auf einen leeren String zeigen,
@ oder der gesuchte Text nicht gefunden werden,
@ so wird in R0 der Wert 0 zurueck geliefert.
@ zeigt R1 auf einen leeren String so wird in R0 der Wert 0 zurueck gegeben

.file "searchStringInString.S"
.text
.align 2
.global searchStringInString
.type searchStringInString, %function

searchStringInString:

stmfd sp!, {r4,r5,lr}

mov r4, r0 // Neues Register für den zu durchsuchenden Text

ldr r5,[r0]
cmp r5,#0x0
mov r0,#0x0 // Zähler auf 0 setzen
ldmeqfd sp!, {r4,r5,pc}

mov r3, r1 // Neues Register für den zu suchenden Text
mov r5, r3 // Sicherung der Adresse des zu suchenden Textes

loop: // Schleife

LDRB r2, [r4],#1 // Erstes bzw. nächstes Zeichen des zu durchsuchenden Strings laden

CMP r1,r2 // Vergleich zu suchendes Zeichen = Zeichen in Zeichenkette
LDREQB r1, [r3],#1 // Wenn r1=r2 dann nächstes zu suchendes Zeichen laden

CMP r1,#0x0 // Vergleich ob r1 das letzte Zeichen war
ADDEQ r0,#0x1 // Zähler um 1 erhöhen
MOVEQ r3, r5 // r1 zurücksetzen

CMP r3, r5
LDREQB r1, [r3],#1

CMP r2, #0x0 // Prüfen ob r2 das letzte Zeichen war

BNE loop // Schleifenaufruf, wenn r2 nicht fertig ist

ldmfd sp!, {r4,r5,pc}

.size searchStringInString, .-searchStringInString

Der Beitrag Rechnerarchitektur (Praktikum 6) erschien zuerst auf Maximilian Krieg.

• Router interessiert nur der Netzteil

Leistungsmerkmale

• Leistungsrate(engl. Line Rate) = Paketgröße * pps(Paketpro Sekunde)
• Hersteller verwenden verschiedene Paketgröße

Dynamisches Routing

• Lastverteilung
• Redundanz
• Router informieren nächsten Hop über Änderungen

Kosten

• HopCount = Primär genutzt

Distance Vector Algorithmus

• Konvergiert = Alle kennen alle Routen

Der Beitrag Netzwerke (Vorlesung 10) erschien zuerst auf Maximilian Krieg.

• §30, Absatz 1:
  • Alle am selben Ort/Gemeinde liegenden Firmen müssen sich deutlich unterscheiden
• §30, Absatz 2:
  • Wer zuerst eingetragen wird hat den Vorrang.
  • Alle Nachzügler müssen einen Zusatz zur Firma wählen, der sich deutlich unterscheidet

BGB (SCHADENSERSATZPFLICHT)

• §823, Absatz 1:
  • Bei vorsätzlichem oder fahrlässigem Handeln das Leben, den Körper, die gesundheit, die Freiheit, das Eigentum oder das Recht verletzt ist Schadensersatzpflichtig.
  • Rechte:
    • Eigentumsähnliche Rechte
    • Besitz
    • Allgemeine Persönlichkeitsrechte
    • Recht am eingerichteten und ausgeübten Gewerbebetrieb
• §823, Absatz 2:
  • Betrifft den Fall, dass jemand gegen ein Gesetz verstößt, welches dieses schützt
• §826: 
  • Sittenwidrige Schadensersatzpflicht
  • Gilt, wenn jemand gegen die guten Sitten und vorsätzlich Schaden zufügt

Fall: Shell.de

BGB

• §823:
  • Domäne ist kein Eigentum (Rechtsgut)
  • Sonstiges Gesetz (möglicher Einstieg)
• §826:
  • Nicht sittenwidrig

 PRIORITÄTSPRINZIP

• Herr Shell war zuerst da, greift somit nicht

LÖSUNG

• Wenn mehrere Berechtigte zusammen kommen, muss abgewogen werden, wer ein größeres Interesse und größeren Bekanntheitsgrad hat, kann/darf/muss der bisherige Domain-Inhaber sich einen Zusatz in der Domain zulegen.

Fall: Weideglück

• Domäne vergeben an jemanden, der nicht Weideglück heißt
• Molkerei Weideglück verlangt die Domäne
• Anklage wegen Namensraub und Schädigungsabsicht
• Domäne musste abgetreten werden

Unlauterer Wettbewerb (UWG)

• §4 – Beispiele:
  • Geschäftliche Unerfahrenheit von Kindern und Jugendlichen ausnutzen
  • Angst oder Zwangslage von Benutzern ausnutzen

Prioritätsprinzip

• Wer zuerst kommt, mahlt zuerst

Der Beitrag Internetrecht (Vorlesung 9) erschien zuerst auf Maximilian Krieg.

1. ..
2. ..
3. Designierte Bridge für jedes LAN Segment festlegen

Port-States

Forwarding

BlockingKeine Traffiweiterleitung, Lese BPDUs

ListeningKeine Traffiweiterleitung, Lese und Sende BPDUs

Learning

Disabled

Internetworking

• Wenn Paket zu Groß und Fragmentieren = 0, dann wird Paket verworfen und ICMP-Nachricht informiert Sender darüber

Der Beitrag Netzwerke (Vorlesung 9) erschien zuerst auf Maximilian Krieg.

MarkenG

• §14 Abs. 2:
  1. Keine Marken/Produktpiraterie, weil kein Logo, andere Produkte bzw. Dienstleistung
  2. Keine Verwechslungsgefahr, weil kein ähnliches Logo verwendet wird bzw. das Zeichen nur für Mineralöl geschützt ist
  3. Im Inland bekannt, kein ähnliches Zeichen (unterschiedliche Bereiche), aber keine ungerechtfertigte Ausnutzung bzw. Beeinträchtigung
• §15 Abs. 2:
  • Kein unbegründet/unlauterer Zweck durch Namensverwendung (Er heißt so)
• §15 Abs. 3:
  • Kein unbegründet/unlauterer Zweck durch Namensverwendung (Er heißt so)

Domänenrecht

Kennzeichenrecht (Gewerblicher Rechtsschutz)

• Beispiel:
  • Kampf Samsung vs. Apple – Geschmacksmuster
• Bereiche
  • Patente – Neuheit, Erfindungshöhse, gewerblich Anwendbar
  • Marken – Unterscheidungskraft, Name, Slogans, Symbol
  • Gebrauchsmuster – Neuheit, Erfindungshöhse, gewerblich Anwendbar
  • Geschmacksmuster – Neuheit und Eigenart, Design
• Schutz des geistig-gewerblichen Eigentums
  • Unterlassung
  • Schadensersatz
• Sonderschutzrechte
  • Urheberrecht: Persönliche Geistesschöpfung (Werk) – Automatisch in Deutschland zugewiesen
  • Patent: technische Leistung (Erfindung)
  • Gebrauchsmuster: technische Leistung (Erfindung)
  • Geschmacksmuster:ästhetische Leistung (Muster/Modell)
  • Kennzeichnungsrechte: Marketingleistung (Kennzeichen)

 GEWERBLICHE KENNZEICHEN

• Arten:
  • Waren- oder Dienstleistungsbezeichnung:
    • Eingetragene Marken (MarkenG §4 Nr. 1)
    • Benutzte Marken (MarkenG §4 Nr. 2)
    • Notorisch bekannte Marke (MarkenG §4 Nr. 3)
  • Unternehmensbezeichnung:
    • Name/Firma (HGB §12 BGB/§§ 17 ff.)
• Geschäftliche Bezeichnungen:
  • Unternehmenskennzeichen:
    • Name des Unternehmens (Deutsche Shell AG)
    • Firmenschlagwörter (Shell)
    • Prägender Bestandteil der Firma
  • Werktitel:
    • Büchername
    • Filme
    • Musiktitel
    • Musicals
    • Theaterstück
• Förmliche Rechte
  • Materielle Voraussetzung & formelles Verfahren beim Amt
    • Patent
    • Gebrauchsmuster
    • Geschmacksmuster
    • Eingetragene Marke
    • Nur neue Dinge erlaubt
• Sachliche Rechte 
  • Materielle Voraussetzung, aber kein formelles Verfahren
    • Urheberrecht (automatische Entstehung)
    • Benutzte Marke (Erlangung durch Verkehrsgeltung/Bekanntheit)
      • Probleme beim Nachweis auf offizielle Existanz
    • Unternehmenskennzeichen
    • Werktitel
    • Geschäftsabzeichen

Marke

• Funktion
  • Adressfunktion
  • Marktdurchsetzung und Unterscheidung
  • Schutz vor anderen Unternehmen
  • Werbung
  • Herkunft
  • Garantie
  • usw..

MarkenG

• §4: Entstehung des Markenschutzes
  • Benutzungsmarke:
    • Benutzung mit Verkehrsgeltung
    • Bei Problemen gilt Alter und Bekanntheitsgrad
  • Notorische Marke:
    • notorische Bekanntheit
    • International Anerkannt
    • Muss nicht überall angemeldet werden | Ca, Tesa, Tempo)
  • Eintragungsmarke:
    • Eintragung beim Amt
    • Wer zuerst kommt malt zuerst
• §14: Ausschließliches Recht des Inhabers einer Marke
  • Niemand darf ohne Erlaubnis Marke mitbenutzen
  • Unterlassungsanspruch
  • Schadensersatzanspruch
• §14, Absatz 2:
  • Dritten ist es untersagt ohne Zustimmung des Markeninhabers diese im geschäftlichen Bereich zu verwenden
    1. Identitätsschutz: Schutz vor Verletzung der Marke durch identisches geschütztes Zeichen/Namen (Marken-/Produktpiraterie)
    2. Verwechslungsschutz: Verwendung eines Zeichens, dass so ähnlich ist, dass man die Unternehmen gleichsetzt oder verwechselt (Stärke des Namens/Bekanntheit durch Gericht zu urteilen)
    3. Bekanntheitsschutz: Verwendung eines ähnlichen Zeichens, das nicht geschützt ist, aber Inland bekannt ist und die Bekanntheit in unlauterer Weise ausnutzt oder beeinträchtigt
• §15, Absatz 1: (Ausschließlichkeitsrecht)
  • Erwerb des Schutzes einer geschäftlichen Bezeichnung gewährt ihrem Inhaber ein ausschließliches Recht
• §15, Absatz 2: (Unterlassungsanspruch)
  • Dritten ist es untersagt die geschäftliche Bezeichnung oder ähnliches Zeichen im geschäftlichen Verkehr unbefugt zu benutzen, die geeignet ist Verwechslungen mit der geschützten Bezeichnung hervorzurufen
• §15, Absatz 3: (Schadensersatzanspruch)
  • Im Inland bekannt, geschäftliche Bezeichnung oder ähnliches Zeichen verwendend, Absatz 2 greift nicht, Ausnutzung/Benutzung ohne rechtfertigenden Grund auf unlautere Weise ausnutzt oder beeinträchtigt

Fall: Champagner.de

1. Private, nicht-gewerbliche Seite von Deutschen: champagner.de
2. Franzosen aus der Champagne klagen vor deutschen Gerichten gegen den Namen
3. Markenrecht greift somit nicht weil sie nicht-gewerblich ist
4. Keine Schädigung, da die Seite eher positive Werbung erzeugt hat

Handelsgesetzbuch (HGB)

• Formen der Firma:
  • Einzelfirma – „Vorname+Nachname..e. Kfm“
  • Gesellschaftsfirma – „Vorname+Nachname..GmbH“
  • Personenforma – „Vorname+Nachname e. Kfm“
  • Sachfirma – „Deutsche Telekom AG“
  • Mischfirma – „Darmstadter Schreibwaren Vorname+Nachname GmbH“
  • Phantasiefirma – „XYZ GmbH“
• Funktionen der Firma
  • Kennzeichnung – Identifizieren und Unterscheidung
  • Auskunft – Informationen über Unternehmensträger und Inhalte der Firma usw. („Spielwarenladen“)
  • Werbung – Aussagekräftig Firma wirbt für Unternehmen
  • Wertträger – …
• §1, Abs. 1: (Kaufmann kraft Betätigung)
  • Kaufmann ist der, wer ein Handelsgewerbe betreibt
• §17, Absatz 1: (Begriff der Firma)
  • Firma eines Kaufmanns ist der Name eines Unternehmens, unter dem er die Geschäfte betreibt und die Unterschrift abgibt
• §17, Absatz 2:
  • Kaufmann kann unter der Firma klagen und verklagt werden
• §18, Absatz 1: (Grundsätze der Firmenbildung)
  • Muss Unterscheidungskraft besitzen
  • Eignung zur Kennzeichnung des Kaufmanns vorausgesetzt
  • Darf nicht wie eine Branche heißen (Grenzfall: Software AG)
• §18, Absatz 2:
  • Gesellschaftszusatz muss stimmen (GmbH darf sich nicht AG nennen)
  • Darf keinen Geschäftszweck publizieren, den man nicht bedient (Bäcker, der sich Tankstelle nennt)

Der Beitrag Internetrecht (Vorlesung 8) erschien zuerst auf Maximilian Krieg.

Verständnis für STACK Befehle und deren Nutzung bei Unterprogrammen. Ziel ist es Programme mit möglichst geringer Codegröße zu implementieren, sowie der Umgang mit einem Debugger/Simulator.

Arbeitsverzeichnis:

Kopieren Sie sich das Verzeichnis, welches Ihnen im Praktikum zur Verfügung gestellt wird, in Ihr persönliches Verzeichnis. Dort stehen Ihnen dann alle benötigten Dateien zur Verfügung.

Vorbereitung

Arbeiten Sie sich in folgende Befehle des ARM-Prozessors und in den ARM Procedure Call Standard (APCS) ein:

Instruktion := Bedeutung
STMFD R13, {R1-R4, LR} := Speichert die Registerwerte R1 bis R4 sowie LR (=R14) an die Adresse, die in R13 (=SP) steht, als voll absteigender Stack

LDMFD R13, {R1-R4, PC} := Lädt den Speicherinhalt von der Adresse, die in R13 (=SP) steht, in Form eines voll absteigenden Stacks in die Register R1 bis R4 sowie PC (=R15)

Aufgabe 1:

In folgenden Tabellen ist jeweils ein Speicherauszug gezeigt. Welche Werte stehen in den Registern nach Ausführung des Blocktransferbefehls? R9 = 0x8000

LDMDA R9, {R1, R2, R6}
R1: 4
R2: 5
R6: 6

LDMFD R9, {R1, R2, R6}
R1: 6
R2: 7
R6: 8

// Aufgabe 1: Blocktransferbefehle"
// Name: Matrikelnummer: 
// Datum: 

.file "aufgabe1.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:
stmfd sp!, {r6, r9, lr}
ldr r9, =0x8000

ldmda r9, {r1, r2, r6}
ldmfd r9, {r1, r2, r6}

ldmfd sp!, {r6, r9, pc}
.Lfe1:
.size main,.Lfe1-main

// End of File

Aufgabe 2:

Schreiben Sie ein beliebiges, kleines Programm in ARM Assembler, das durch Unterprogramme strukturiert wird. Folgende Anforderungen werden an das Programm gestellt:

• Die APCS Konvention wird eingehalten
• Das Programm benutzt (mindestens) drei Unterprogramme (UP):
  • UP1 benutzt nur Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf)
  • UP2 benutzt nur Scratchregister und stellt eine Blattroutine dar (ruft somit keine weiteren Unterprogramme auf)
  • UP3 benutzt Nicht-Scratchregister und stellt keine Blattroutine dar

// Befehle = 19, Programmgröße = 19*4 Byte= 76 Byte
.file "aufgabe2.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main: // 5 Befehle
push {lr}
bl up1 // Unterprogramm 1 aufrufen
bl up2 // Unterprogramm 2 aufrufen
bl up3 // Unterprogramm 3 aufrufen
pop {pc}

// UP1 benutzt nur Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf
up1: // 7 Befehle
push {lr}
MOV r0, #0x0 // r0=0
MOV r1, #0x1 // r1=1
bl up2 // Unterprogramm 2 aufrufen
MOV r1,#0x2
bl up2 // Unterprogramm 2 aufrufen
pop {pc}

// UP2 benutzt nur Scratchregister und stellt eine Blattroutine dar (ruft somit keine weiteren Unterprogramme auf)
up2: // 3 Befehle
push {lr}
ADD R0, R0, R1 // r0 und r1 addieren, Ergebnis nach r0 schreiben
pop {pc}

//UP3 benutzt Nicht-Scratchregister und stellt keine Blattroutine dar (ruft somit weitere Unterprogramme auf)
up3: // 4 Befehle
stmfd sp!, {r4, lr} // r4 und lr sichern
ADD r4, r4, #0x1 // r4 um 1 erhöhen
bl up2 // Unterprogramm 2 aufrufen
ldmfd sp!, {r4, pc} // r4 und lr -> pc zurück laden

.Lfe1:
.size main,.Lfe1-main

// End of File

Aufgabe 3:

Schreiben Sie das Programmbeispiel aus Termin 2 (selbst modifizierender Code )in ARM7-Assembler und testen Sie dieses. Beobachten Sie die sich ändernden Speicherstellen/Befehle. Beschäftigen Sie sich mit den Problemen, welches dieses Programm machen kann.

Warum funktioniert das Programm im Simulator?

• Das Programm funktioniert, da innerhalb des Simulators alle Programme im RAM stehen.

Wie groß dürfte die Werteliste werden?

// Befehle = 16, Programmgröße = 16*4 Byte = 64 Byte

.file "aufgabe3.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function
main:

loop:
ADR r0, Total // Accumulate total
LDR r1, [r0]

Add_instr: // Add_instr

ADR r2, Table
LDR r3, [r2],#4

add r5, r1, r3 // Speichere r3 + r1 in r5
str r5, Total // Speichere r5 unter „Total“

LDR r3, Add_instr
add r3, r3,#4 //Speichere r3 + 4 in r3
str r3, Add_instr // Speichere r3 unter „Add_instr“

ldr r6, Count
subs r6,r6,#1 // Speichere r6 – 1 in r6, setze die Statusbits
str r6, Count // Speichere r6 unter „Count“
BGE loop
STR r5, Total // Speichere r5 unter „Total“
b Halt // STP ; Halt execution

Halt:
b Halt

Total: .word 0
One: .word 4
Count: .word 4
Table: .word 39, 25, 4, 98, 17

.Lfe1:
.size main,.Lfe1-main
// End of File

Aufgabe 4:

Berichtigen Sie das Programm nun so, dass der Programmcode (kein sich selbst
modifizierenden Code) im ROM (Read Only Memory) und die sich ändernden Daten im RAM (Random Acces Memory) stehen.

// Befehle = 10  Programmgröße = 10 * 4 Byte = 40 Byte
.file "aufgabe4.S"
.text @ legt eine Textsection fuer PrgrammCode + Konstanten an
.align 2 @ sorgt dafuer, dass nachfolgende Anweisungen auf einer durch 4 teilbaren
Adresse liegen
@ unteren 2 Bit sind 0
.global main @ nimmt das Symbol main in die globale Sysmboltabelle auf
.type main,function

main:

LDR r1, =Table // Laden der Adresse von Table
MOV r0, #0x0 // Ergebnisregister auf 0 setzen
LDR r3, =Count // Laden der Adresse der Zähl-Variable
LDR r3, [r3] // Laden des Wertes der Zähl-Variable

loop:
LDR r2, [r1], #4 // Laden des ersten Wertes der Tabelle nach r2, inkrement danach
ADD r0, r2, r0 // Ergebniswert = Ergebniswert + Tabellenwert
SUBS r3, r3, #1 // Zählvariable dekrementieren mit Status
BPL loop // Solange r3 >=0 ist wiederhole die Loop
STR r0, Total // r0 nach Total speichern

BX LR

.Lfe1:
.size main,.Lfe1-main

.data
Total: .word 0
Count: .word 4
Table: .word 39, 25, 4, 98, 17

// End of File

Der Beitrag Rechnerarchitektur (Praktikum 5) erschien zuerst auf Maximilian Krieg.