PO1 | Tablica asocjacyjna

// ---------------------------------------------------------------------HEADER
#include <string>
#include <iostream>

using namespace std;

class assoc // to rozroznia duze i male litery
{

protected:
    struct node
    {
        node *next;
        string key;
        int value;
        node(string newkey);
    };

    node *head;
    void clear();
    void insert(string newkey, int newvalue);               // wprowadzenie wartosci do klucza
    virtual bool cmp(const string s1, const string s2) const;       // porownanie dwoch kluczy
    node *find(string newkey) const;                    // wyszukiwanie aktualnego klucza
    void swap(assoc &l);                        //

public:

    assoc();
    assoc(const assoc & l);
    ~assoc();
    assoc& operator=(const assoc & l);
    int & operator[](string newkey);
};

class assocbez : public assoc // a to nie rozroznia wielkosci liter
{
    public:
    bool cmp(const string s1, const string s2) const;
};




// -------------------------------------------------------------------------------------CPP
#include <string>
#include <iostream>
#include <cstdlib>
#include "assoc.h"

using namespace std;


assoc::assoc ()
{
    head = NULL;
}

assoc::assoc (const assoc & l)
{
    node *src, **dst;
    head = NULL;
    src = l.head;
    dst = &head;
    while (src)
    {
        *dst = new node (*src);
        src = src->next;
        dst = &((*dst)->next);
    }
}
assoc::~assoc ()
{
    clear();
}

void assoc::clear ()        // usuwanie klucza
{
    while (head)
    {
        node *t = head->next;
        delete head;
        head = t;
    }
}

void assoc::insert (string newkey, int newvalue)    // wprowadzanie wartosci do klucza
{
    node *nowy = new node (newkey);
    nowy->next = head;
    nowy->value = newvalue;
    head=nowy;
}

void assoc::swap (assoc & l)
{
    node *t = head;
    head = l.head;
    l.head = t;
}

assoc::  node* assoc:: find (string newkey) const   // wyszukiwanie klucza
{
    node* t= head;
    while(t)
    {
        if (cmp(t->key,newkey)) return t;
        t=t->next;
    }
    return NULL;

}

assoc:: node::node(string newkey): next(NULL)       // nowy element "listy"
{
    key=newkey;
}

assoc & assoc::operator= (const assoc & l)      // przypisanie do elementu
{
    if (&l == this) return *this;
    assoc t (l);
    swap (t);
    return *this;
}


int & assoc::operator[] (string newkey) // przeciazenie operatora [], czyli indeksowanie nowym kluczem
{
    node *c = find (newkey);
    if (!c)
    {
        insert (newkey, 0);
        c = head;
    };
    return c->value;
}


bool assoc::cmp (const string s1, const string s2) const    // porownywanie
{
    return(s1==s2);
}


bool assocbez::cmp(const string s1, const string s2) const
{
    string s_1, s_2;

    for (int i = 0; s1[i]; i++)     s_1[i] = tolower(s1[i]);
    for (int i = 0; s2[i]; i++)     s_2[i] = tolower(s2[i]);

    return(s_1==s_2);
}



// ----------------------------------------------------------------------------------------------MAIN
#include <iostream>
#include <string>
#include <cstdlib>
#include "assoc.h"
using namespace std;

//indeksowanie tablic z uzyciem wlasnych danych, np lancuchów tekstu, cos jak etykieta
int main()
{
    assoc ZeZnakami;
    assocbez BezZnakow;

    ZeZnakami["ala"]=14;
    cout << "pierwsza wartosc klucza = " << ZeZnakami["ala"] << endl;

    ZeZnakami["ala"]=16;
    cout << "wartosc z nowa wartoscia = " << ZeZnakami["ala"] << endl;

    ZeZnakami["AlA"] = 14;
    cout << "wartosc z nowa wartoscia = " << ZeZnakami["ala"] << endl;
    cout << "stara wartosc z duzym literami = " << ZeZnakami["AlA"] << endl;



    BezZnakow["cztery"]=44;
    cout << "[cztery] = " << BezZnakow["cztery"] << endl;
    BezZnakow["CztErY"]=4; // przyjmuje kolejna wpisana wartosc bez sprawdzania wielkosci liter
    cout << "[CztErY] = "   << BezZnakow["czterys"] << endl;
}