2016-Programmieren in C/ C++

PfN mit mathem. Anwendung

Frage zuerst
Antwort zuerst
Selbsttest

0.0 (0)

Lernen

Kartei Details

Karten	21
Sprache	Deutsch
Kategorie	Informatik
Stufe	Universität
Erstellt / Aktualisiert	09.04.2015 / 09.06.2023
Lizenzierung	Keine Angabe
Weblink	https://card2brain.ch/box/z4_mappe
Einbinden	<iframe src="https://card2brain.ch/box/z4_mappe/embed" width="780" height="150" scrolling="no" frameborder="0"></iframe>

Flip-Modus

Was fehlt?

______ small_to_large(const void * first, const void * second)
{
    assert(first != NULL);
    assert(second != NULL);

    IntUlongPair *a = (IntUlongPair *) first;
    IntUlongPair *b = (IntUlongPair *) second;

    if(a->first > b->first)
    {
        return 1;
    }
    else if(a->first < b->first)
    {
        return -1;
    }
    else
    {
        if(a->second < b->second)
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
}

void sort_int_ulong_pairs(IntUlongPair *tab, unsigned long len)
{
    assert(tab != NULL);

    qsort((void *) tab, len, sizeof(*tab), &small_to_large);
}

int

Was ist richtig?

begin() Liefert die erste Position des Vektors

end() Zeigt hinter die letzte Position des Vektors

at(int) Geprüfter Zugriff auf Element des Vektors

end() Geprüfter Zugriff auf die letzte Position des Vektors

begin() Geprüfter Zugriff auf die erste Position des Vektors

C++

Wie kann man auf alle Elemente eines Containers zugreifen?

Per Direktzugriff über eckige Klammern kann auf die Elem. zugegriffen werden.

Für den Zugriff auf die Elem. der Container verwendet die STL sog. Iteratoren.
- sind Zeigern ähnlich, aber an ihren Container angepasst
- bilden Glied zwischen Container und Anwendung

Zugriff über die Elementfunktion at() wird geprüft und löst bei Fehlern eine Ausnahme out_of_range aus.

[ ]-Zugriff ist schneller, als at()

Nennen Sie die zwei Präprozessor-Variablen, die für den Dateinamen und für die Zeile in der Datei stehen?

Zwei vordefinierte Makros sind __FILE__ (aktueller Dateiname) und __LINE__ (aktuelle Zeile innerhalb der Datei)

Was wird 'asserted'?

int small_to_large(const void * first, const void * second)
{
    assert(_______);
    assert(_______);

    IntUlongPair *a = (IntUlongPair *) first;
    IntUlongPair *b = (IntUlongPair *) second;

    if(a->first > b->first)
    {
        return 1;
    }
    else if(a->first < b->first)
    {
        return -1;
    }
    else
    {
        if(a->second < b->second)
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
}

void sort_int_ulong_pairs(IntUlongPair *tab, unsigned long len)
{
    assert(tab != NULL);

    qsort((void *) tab, len, sizeof(*tab), &small_to_large);
}

assert(first != NULL);

assert(second != NULL);

assert(second != first);

assert(void != NULL);

assert(first == second);

Was fehlt?

int small_to_large(const void * first, const void * second)
{
    assert(first != NULL);
    assert(second != NULL);

    _______*a = (_______*) first;
    _______*b = (_______*) second;

    if(a->first > b->first)
    {
        return 1;
    }
    else if(a->first < b->first)
    {
        return -1;
    }
    else
    {
        if(a->second < b->second)
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
}

void sort_int_ulong_pairs(IntUlongPair *tab, unsigned long len)
{
    assert(tab != NULL);

    qsort((void *) tab, len, sizeof(*tab), &small_to_large);
}

IntUlongPair

Was ist richtig?

int small_to_large(const void * first, const void * second)
{
    assert(first != NULL);
    assert(second != NULL);

    IntUlongPair *a = (IntUlongPair *) first;
    IntUlongPair *b = (IntUlongPair *) second;

    if(a->first > b->first)
    {
        return __;
    }
    else if(a->first < b->first)
    {
        return __;
    }
    else
    {
        if(a->second < b->second)
        {
            return __;
        }
        else
        {
            return -1;
        }
    }
}

void sort_int_ulong_pairs(IntUlongPair *tab, unsigned long len)
{
    assert(tab != NULL);

    qsort((void *) tab, len, sizeof(*tab), &small_to_large);
}

if(a->first > b->first) { return 1; }

if(a->first < b->first) { return -1; }

else { if(a->second < b->second) { return 1; }}

if(a->first > b->first) { return -1; }

if(a->first < b->first) { return 1; }

Was fehlt?

int small_to_large(const void * first, const void * second)
{
    assert(first != NULL);
    assert(second != NULL);

    IntUlongPair *a = (IntUlongPair *) first;
    IntUlongPair *b = (IntUlongPair *) second;

    if(a->first > b->first)
    {
        return 1;
    }
    else if(a->first < b->first)
    {
        return -1;
    }
    else
    {
        if(a->second < b->second)
        {
            return 1;
        }
        else
        {
            return -1;
        }
    }
}