Programmazione a Oggetti - Teoria

RICORSIONE

Un oggetto ricorsivo è quello per cui è possibile dare una definizione in termini di se stesso. Vi è più ricorrente appr. matematica che si utilizza il passo di una dimostrazione dettagli entrambi i casi il formale di: - principi di induzione.

Tutte

Ricorsione una funzione si chiama in altri due a sua volta rilascia la prima.

Ricorsione lineare

di solo una chiamata ricorsiva all’interno della funzione fattoriale. Es dietro logica della chiamata ricorsiva nella realizzazione.

Ricorsione di coda

Alla chiamata successiva - è l’ultima istruzione della funzione insi permette di trasforma (azione iterativo (più efficiente)).

• integano insieme la ricorsione per 3 motivi: infie un unico ciclo del sottoprogramma ad ogni chiamato c'è
• allegata un record di attivazione diverso e diversi record possono es essere contemporaneamente present un allo lstack

• minimo(1)
  • fatt(3)
    • –
  • fatt(2)
    • –
  • fatt(1)
• return 1.
  • se (x = 1) return
    • else
      • return xⁿ fatt(x-1)
      • return x² xⁿ fatt(x-1)

Fattoriale

int fact(int n) {

• if (n) = 1 : return 1 :
  • else return n * fact(n-1)

int fact(int n) {

• int s = 1 :
• for(i = 1 ; i nome; cout > cognome; cout > matricola; } void output() { cout valore = valore; tamp -> next = e; return tamp;
  1. Crea una struttura per l'elemento da inserire
  2. Poniamo il valore
  3. Colleghiamo alla lista
  4. Aggiorniamo la testa

  Cancellazione in testa

  nodo* delhead(nodo* e); nodo* tamp; if (e == 0) return e; tamp = e -> next; delete e; return tamp;
  • Se la lista è vuota, non faccio nulla
  • In posizione il punt della lista
  • Cancello e faccio cancellazione
  • Aggiungo la testa il next di e

  Restituzione di un nodo

  nodo* get_pos(nodo* e, int pos); int i = 0; if (pos < 0) return 0; while (e != 0 && i < pos) e = e -> next; return e;

  EZ

  #include <iostream> #include <fstream> #include <stdlib.h>

  const char nome_file[] = "C:\\CORSI\\PO14\\sorgente.txt" const char dest_file[] = "C:\\CORSI\\PO14\\dati_imposture.txt";

  using namespace std; int main()

  {     ifstream in;     in.open(nome_file, ios::in);     out.open(dest_file, ios::out);

      if(!in) cout << "ERRORE, impossibile aprire il file di sorgente che";     return;

      if(!out) cout << return;

  copy_file(in, out);

  in.close(); out.close();

  } return 0; }

  File -> Vettore

  void file2vec(ifstream & in, TipoValue v[], int &n)

  {     n = 0;     while(in >> v[n])         n++;     return ; }

  Vettore -> File

  void vec2file(ifstream &out, TipoValue v[], int n)

  {     int i = 0;     while(i < n && out)         out << v[i++] << endl

      return;

  }

  Overloading Funzioni

  In C++ è possibile dare a funzioni diverse lo stesso nome a patto che la lista di parametri sia diversa. (Il nome viene sovraccaricato: overload). Ciò è possibile perché lo scope di una funzione è composto dal nome e parametri.

  • Es.
    • void inc(int &x) {
      • x = x+1;
      }
    • void inc(float &x) {
      • x = x+1.0;
      }
    • void inc(int &x, int dx) {
      • x += dx;
      }
  • int main() {
    • float a=0.0;
    • int i=1;
    • int d=10;
    • inc(i);
    • inc(a);
    • inc(i,d);
    • return 0;
    }

  Si parla di ambiguità nel momento in cui il compilatore non riconosce quale funzione richiamare.

  • Es.
    • double func(double i) {} A
    • float func(float i) {} B
  • int main() {
    • func(10.1) → chiama A perché le literals costanti con virgola hanno C/C++ sono double
    • func(10) → AMBIGUA
    • return 0;
    }

  Parametri di default

  Se nella chiamata della funzione un (o più) parametro non sono presenti viene usato quello di default. Tali parametri al default vanno sempre lasciati specificati nel prototipo della funzione alla fine.

  • Es. void Print(int val1=10, int val2=20, int val3=30) {
    • cout << "Values: " << val1 << " " << val2 << " " << val3 << endl;
    }
  • int main() {
    • Print(1,2,3); → 1, 2, 3
    • Print(1,2); → 1, 2, 30
    • Print(1); → 1, 20, 30
    • Print(); → 10, 20, 30
    }
  • Es. void Print(int val=10, int m); → ERRORE!