Cheats C++

OPERATORE CON PUNTATORE2.Esempio 2

Costruttore di Copia e Ridefinizione Operatore =

RIDEFINIZIONE OPERATORI = E <<NOTACOPIAPROFONDA!DISTRUTTORE!

Ereditarietà, classi e sottoclassi SI NOTINO LE ASSEGNAZIONIprotected PERMETTE ALLE CLASSI DI EREDITAREEREDITARIETA’ PUBBLICAVIENE INVOCATO IL COSTRUTTORE DIDELLA CLASSE PADRE

Keyword Virtual UNA FUNZIONE VIRTUALEPERMETTE ALLE CLASSI DERIVATEDI SOSTITUIREL’IMPLEMENTAZIONE CON QUELLAFORNITA DALLA CLASSE BASENOTA

Ridefinizioni operatori NOTA SU STATICRIDEFINIZIONE OPERATORE = CON INTERORIDEFINIZIONE OPERATORE = CON CLASSERIDEFINIZIONE OPERATORE + CON CLASSERIDEFINIZIONE OPERATORE + = CON CLASSERIDEFINIZIONE OPERATORE ++RIDEFINIZIONE OPERATORE ++ CON INTERORIDEFINIZIONE OPERATORE --RIDEFINIZIONE OPERATORE -- CON INTERORIDEFINIZIONE OPERATORE == CON CLASSERIDEFINIZIONE OPERATORE != CONCLASSERIDEFINIZIONE OPERATORE == CON CLASSINOTA SU PRE E POST INCREMENTO

Liste, vettori, puntatori e loro metodiLISTA E

ITERATORE

Metodi simili a insertLast e insertFirst:

• Stampa lista con iteratore, metodo begin ed end
• Stampa lista con for_each e funzione stampaInt
• Stampa lista con for_each e indirizzo funzione stampaInt

VETTORE E ITERATORI

Metodo simile a insertLast (i vettori hanno solo questo):

• Stampa vettore con iteratore, metodo begin ed end
• Stampa vettore con iteratore inverso, metodo rbegin ed rend
• Stampa vettore con for_each e indirizzo funzione stampaInt
• Stampa elementi specifici del vettore con for_each, metodo begin e indirizzo funzione stampaInt
• Ricerca elemento specifico

METODI OBBLIGATORI

Devo passare da zero a uno, il primo con passaggio di un intero e il secondo con un puntatore:

Stampa con iteratori e metodi

NOTA

Metodo stampa con const_iterator e metodi begin ed end

Ridefinizione operatore con const_iterator e...

METODI begin ED end

▪ Set e multiset

FUNZIONE STAMPA con ITERATORE + RICERCA E INSERIMENTO DI UN NUOVO VALORE

FUNZIONE STAMPA con ITERATORE COSTANTE + STAMPA INVERSA

SET, INSERIMENTO IN SET, STAMPA SET CON ITERATORE

MULTISET, INSERIMENTO IN MULTISET E STAMPA CON ITERATORE OBBLIGATORIO PER IL CONFRONTO IMPLEMENTARE L'OPERATORE < (errore di compilazione altrimenti)

▪ Map

FUNZIONE STAMPA con PASSAGGIO PER REFERENCE + STAMPA VALORI OUTPUT

CREAZIONE MAP CON DIVERSE CHIAVI INSERIMENTO IN MAP STAMPA DIRETTA DEL VALORE DI UNA CHIAVE (SE ESISTE) CONTROLLO + STAMPA DIRETTA RECUPERO O MODIFICA + INSERIMENTO DI UNA CHIAVE

======================================================================================================

RIDEFINIZIONE OPERATORE << CON VECTOR NOTA CHE VA BENE SOLO SE RIDEFINISCO L'OPERATORE <<

CREAZIONE MAP, INSERIMENTO con costrutto specifico E STAMPA

▪ Composizione e Aggregazione con set

COMPOSIZIONE E AGGREGAZIONE COME INDICATO NEL DIAGRAMMA UML FUNZIONI DIAGGIUNTA VARIE

PERLA COMPOSIZIONE

FUNZIONE DI AGGIUNTA PER L'AGGREGAZIONE + FUNZIONE DI RIMOZIONE

NOTA: LE FUNZIONE DI AGGIUNTA NON SONO TUTTE CORRETTE, IN QUANTO INDISACCORDO CON IL DIAGRAMMA UML

IMPLEMENTAZIONE FUNZIONI DI AGGIUNTA PER LA COMPOSIZIONE

CON METODO insert

IMPLEMENTAZIONE FUNZIONE DI AGGIUNTA PER L'AGGREGAZIONE

CON METODO insert + FUNZIONE DI REMOVE CON ITERATORE O CON METODO find

RIDEFINIZIONE OPERATORE << CON ITERATORI (PER COMPOSIZIONE E AGGREGAZIONE)

Composizione e aggregazione con map

MODI INSERIMENTO IN MAP

VANTAGGIO MAP

NOTA SU COERENZA CON UML - COMPOSIZIONE

NOTA SU COERENZA CON UML - AGGREGAZIONE

IMPLEMENTAZIONI FUNZIONI DI AGGIUNTA A SECONDA DELLE MODALITA' DI PASSAGGIO (incoerenza al diagramma UML quella corretta è addPersona3) - COMPOSIZIONE

IMPLEMENTAZIONI FUNZIONI DI AGGIUNTA - AGGREGAZIONE

FUNZIONE getPersona (VANTAGGIO DI USARE IL MAP)

RIDEFINIZIONE OPERATORE << CON ITERATORI (PER COMPOSIZIONE E AGGREGAZIONE)

Template

→TEMPLATE CODICE CHE FUNZIONA
INDIPENDENTEMENTE DAL TIPO DI DATO

<template typename T>
class Codice {
public:
    Codice(T dato) {
        this->dato = dato;
    }
    
    T getDato() {
        return dato;
    }
    
private:
    T dato;
};

======================================================================================================

DIMOSTRAZIONE USO TEMPLATE CON
DIFFERENTI TIPI DI DATO

Codice<int> codiceInt(10);
Codice<float> codiceFloat(3.14);
Codice<char> codiceChar('A');

======================================================================================================

USO TEMPLATE CON CLASSE (A PATTO DI
RIDEFINIRE OPERATORI < E << )

class Persona {
public:
    Persona(string nome, int eta) {
        this->nome = nome;
        this->eta = eta;
    }
    
    string getNome() {
        return nome;
    }
    
    int getEta() {
        return eta;
    }
    
    bool operator<(const Persona& other) const {
        return eta < other.eta;
    }
    
    friend ostream& operator<<(ostream& os, const Persona& persona) {
        os << "Nome: " << persona.nome << ", Eta: " << persona.eta;
        return os;
    }
    
private:
    string nome;
    int eta;
};

Codice<Persona> codicePersona(Persona("Mario", 30));

======================================================================================================

ARRAY (A PATTO DI RIDEFINIRE OPERATORI << E [ ] )

template <typename T, int size>
class Array {
public:
    Array() {
        for (int i = 0; i < size; i++) {
            data[i] = T();
        }
    }
    
    T& operator[](int index) {
        return data[index];
    }
    
    friend ostream& operator<<(ostream& os, const Array& array) {
        for (int i = 0; i < size; i++) {
            os << array.data[i] << " ";
        }
        return os;
    }
    
private:
    T data[size];
};

Array<int, 5> arrayInt;
Array<float, 3> arrayFloat;

======================================================================================================

USO TEMPLATE CON ARRAY (di float, double e
classe Persona) (A PATTO DI RIDEFINIRE
OPERATORI < , << E [ ] )

Array<float, 4> arrayFloat;
Array<double, 2> arrayDouble;
Array<Persona, 3> arrayPersona;

======================================================================================================

RIDEFINIZIONI OPERATORI < E <<

bool operator<(const Array<T, size>& other) const {
    for (int i = 0; i < size; i++) {
        if (data[i] < other.data[i]) {
            return true;
        }
        else if (data[i] > other.data[i]) {
            return false;
        }
    }
    return false;
}

friend ostream& operator<<(ostream& os, const Array& array) {
    for (int i = 0; i < size; i++) {
        os << array.data[i] << " ";
    }
    return os;
}

======================================================================================================

NOTA: RIDEFINIZIONE OPERATORE [ ]

T& operator[](int index) {
    return data[index];
}

======================================================================================================

RIDEFINIZIONE OPERATORE << NOTA PER EVITARE ERRORI
DI COMPILAZIONE

friend ostream& operator<<(ostream& os, const Array& array) {
    for (int i = 0; i < size; i++) {
        os << array.data[i] << " ";
    }
    return os;
}

======================================================================================================

CLASSE TEMPLATE ARRAY

template <typename T, int size>
class Array {
public:
    Array() {
        for (int i = 0; i < size; i++) {
            data[i] = T();
        }
    }
    
    T& operator[](int index) {
        return data[index];
    }
    
    bool operator<(const Array& other) const {
        for (int i = 0; i < size; i++) {
            if (data[i] < other.data[i]) {
                return true;
            }
            else if (data[i] > other.data[i]) {
                return false;
            }
        }
        return false;
    }
    
    friend ostream& operator<<(ostream& os, const Array& array) {
        for (int i = 0; i < size; i++) {
            os << array.data[i] << " ";
        }
        return os;
    }
    
private:
    T data[size];
};

======================================================================================================

NOTA: RIDEFINIZIONE OPERATORE [ ]

template <typename T, int size>
T& Array<T, size>::operator[](int index) {
    return data[index];
}

======================================================================================================

NOTA: IMPLEMENTAZIONE ESTERNA (NOTA RIDEFINIZIONE
SINTASSI) OPERATORE << ( NB SU <> nell’header )

template <typename T, int size>
ostream& operator<<(ostream& os, const Array<T, size>& array) {
    for (int i = 0; i < size; i++) {
        os << array.data[i] << " ";
    }
    return os;
}

======================================================================================================

▪ Esempi Esame

Codice<int> codiceInt(10);
Codice<float> codiceFloat(3.14);
Codice<char> codiceChar('A');

class Persona {
public:
    Persona(string nome, int eta) {
        this->nome = nome;
        this->eta = eta;
    }
    
    string getNome() {
        return nome;
    }
    
    int getEta() {
        return eta;
    }
    
    bool operator<(const Persona& other) const {
        return eta < other.eta;
    }
    
    friend ostream& operator<<(ostream& os, const Persona& persona) {
        os << "Nome: " << persona.nome << ", Eta: " << persona.eta;
        return os;
    }
    
private:
    string nome;
    int eta;
};

Codice<Persona> codicePersona(Persona("Mario", 30));

template <typename T, int size>
class Array {
public:
    Array() {
        for (int i = 0; i < size; i++) {
            data[i] = T();
        }
    }
    
    T& operator[](int index) {
        return data[index];
    }
    
    bool operator<(const Array& other) const {
        for (int i = 0; i < size; i++) {
            if (data[i] < other.data[i]) {
                return true;
            }
            else if (data[i] > other.data[i]) {
                return false;
            }
        }
        return false;
    }
    
    friend ostream& operator<<(ostream& os, const Array& array) {
        for (int i = 0; i < size; i++) {
            os << array.data[i] << " ";
        }
        return os;
    }
    
private:
    T data[size];
};

Array<int, 5> arrayInt;
Array<float, 3> arrayFloat;

Array<float, 4> arrayFloat;
Array<double, 2> arrayDouble;
Array<Persona, 3> arrayPersona;