Esercitazione argc | argv - 24/11/2014

//ARGC:

# include<iostream>
using namespace std;

int main (int argc, char* argv[])
{
    cout<<argc;
}

*!* "argc" restituirà a video il numero di parametri che vengono passati al momento dell'esecuzione del programma

//ARGC e ARGV[]:

# include<iostream>

using namespace std;

int main (int argc, char* argv[])

{

    int i;

    cout<<argc;

    cout<<endl;

    for(i=0;i<argc;i++)

        {

        cout<<argv[i];

        cout<<endl;

        }

}

*!* "argv[]" restituirà a video le stringhe contenenti il nome dei parametri che vengono passati al momento dell'esecuzione, insieme al precedente "argc":

Prime prove di codice in JAVA

Prime prove di Codice in JAVA seguendo i video Tutorial del Prof. Camuso dal link del canale YouTube -> Playlist 2 - fCamuso

Prima Prova: direttamente dall'esempio proposto in Playlist: Costruiamo una Classe "MainProgramma01" e una Classe "Punto" utilizzando il programma Eclipse

La Classe Punto conterrà al suo interno:

1. - le variabili pubbliche x e y inizzializzate al valore 0
2. - i costruttori relativi all'oggetto Punto

• con il passaggio di due parametri
• tramite l'istruzione "setter"
• tramite l'istruzione "get"

La Classe main() conterrà:

1. la dichiarazione dell'oggetto "p1" e "p2" di tipo "Punto"
2. l'istnze degli oggetti "p1" e "p2" con il passaggio di parametri
3. il richiamo al metodo "setX" dell'oggetto "p2" per inizzializzare la variabile "x" dell'oggetto "p2" al valore passato a parametro 
4. La stampa dei valori per conferma dell'avvenuta operazione

Codice:

public class MainProgramma01 
{
      public static void main(String[] args) 
      {
Punto p1;
Punto p2;

p1=new Punto(23,-12);

p2=new Punto(1,11);

p2.setX(500);

      System.out.print("Valore P1 x: "+p1.x+" Valore P1 y: "+p1.y);
      System.out.print("Valore P2 x: "+p2.x+" Valore P2 y: "+p2.y);
      }
}

public class Punto 
{
   int x=0;
   int y=0;
//costruttori
   public Punto(int _x, int _y)
      {
         x=_x;
         y=_y;
      }
//setter
   public void setX(int _x)
      {
         x=_x;
      }
//getter
   public int getY()
      {
         return y;
      }
}

Funzioni "Friend" e istruzione "operator"

Le Funzioni Friend sono delle funzioni che non fanno parte della Casse. Il loro scopo è quello di assolvere compiti che altrimenti non potrebbero essere assolti.

Class Frazione
{
    friend Frazione Somma(Frazione);

• "friend Frazione" indica il tipo di dato restituito dalla funzione friend
• "(Frazione)" indica il tipo di parametro che verrà passato alla funzione, è possibile tralasciare     nel prototipo dell funzione il parametro
• Una funzione friend i posiziona prima di ogni altra funzione
• Le funzioni friend possono essere utilizzate solo dai membri della classe, non sono                     raggiungibili dal main()
• Una funzione friend è raggiungibile solo dall'oggetto stesso, non da altri oggetti di stessa           tipologia   

private:
        int num;
        int den;
}

Come va implementata una funzione friend:
Frazione Somma (Frazione a)
   {
      ...
      ...
      ...
   }

Se non fosse un metodo friend invece utilizzeremmo la sintassi:
Frazione::Somma (Frazione a)
   {
      ...
      ...
      ...
   }

Istruzione "operator":
E' possibile sostituire alla parola somma l'operatore di somma "+", per farlo utilizzo l'istruzione "operator" seguito dall'operatore matematico (nel nostro caso +):
Frazione operator + (Frazione a)
   {
      ...
      ...
      ...
   }
che implementato all'interno del main() mi permetterà di utilizzare due oggetti come se fossero due numeri, vediamo l'esempio:

main()
 {
   Frazione a(5,3);
   Frazione b(3,2);
   Frazione c;
   
   c=a+b;
}

*!* l'istruzione "operator" può essere utilizzato anche con gli altri operatori matematici +  -  +=  -=  >   <   /   *   ...

Puntatore "this"

Il Puntatore "this" è un Puntatore ad un oggetto, serve ad identificare l'indirizzo di partenza di un oggetto.
Il Puntatore "this" viene utilizzato quando vengono rilevati dei possibili casi di ambiguità del codice:

Esempio di un possibile caso di "Ambiguità" in codice:
Class Prova                                                      Class Prova
{                                                                       {
   public:                                                               public:
      Prova(int a);                                                       Prova(int a);
      {                                                                         {
         a=0;                                                                     this->a=0;
         a++;                                                                     this->a++;
       }                                                                         }
      private:                                                                private:
         int a;                                                                    int a;
}                                                                       }

Passaggio di Puntatori come Parametri di Funzioni

Anche le variabili di tipo Puntatore possono essere passate come parametro sia "per valore" che "per riferimento":

f (int *p)   come per una variabile di tipo intero f (int r)
qui duplico un puntatore di tipo intero                      qui duplico una variabile di tipo intero

è la dichiarazione di un puntatore passato come parametro per valore, passa quindi il contenuto dell'area a cui punta il puntatore.
*!* lo si utilizza quando è necessario mantenere invariato il contenuto di *p
                   
f (int *&q)   come per una variabile di tipo intero f (int &s)
qui passo l'indirizzo del puntatore                      qui passo l'indirizzo di una variabile di tipo intero

è la dichiarazione di un puntatore passato come parametro per riferimetno, passa quindi l'indirizzo di memoria a cui punta il puntatore.
*!* lo si utilizza quando devo modificare il contenuto di *q

Array di Puntatori

#include <iostream>
using namespace std;

int a[10];
int *b;

main()
{
    b=new int[10];   //alloca spazio in memoria al puntatore 'p' e restituisce in 'p' il valore dell' indirizzo del primo elemento
    cout<<"Lezione del 13/10/2014 -> Utilizzo di un array di puntatori"<<endl;
int i;

//Inserimento 
    for(i=0;i<10;i++)
    {
        a[i]=i;   //assegnazione del valore 'i' all'elemento [i] dell'array di interi
        b[i]=i+1;   //assegnazione del valore 'i+1' all'elemento [i] dell'array di puntatori 'b'
    }
//Visualizzazione
       for(i=0;i<10;i++)
       {
             cout<<endl<<"A: " << a[i];
             cout<<endl<<"B: " << b[i];
             cout<<endl<<"Indirizzo puntato da 'b': " << &b[i];   //aumenta su base esadecimale di 4 + 4 perchè è un array di interi (intero=4 byte)
             cout<<endl<<endl;
       }
return 0;
}

Puntatori a un Oggetto

Un puntatore può puntare a un Area di Memoria di tipo "Oggetto", vediamo un esempio di codice:

Class Punto 

{

      ...

      ...

      ...

}

Punto* q;   //dichiarazione di un puntatore "q" di tipo "Punto"

q=new Punto;   //alloco spazio di memoria adatto a tipo "Punto" e restituisco a "q" l'indirizzo di                                       memoria

Per accedere alle proprietà o ai metodi della Classe Punto tramite puntatore posso utilizzare due strumenti:

q -> ascissa=5;   //operatore freccia

(*q).ordinata=7;   //* è l'area di memoria puntata

Quando è necessario dichiarare un Array di puntatori invece utilizziamo la seguente sintassi:

q=new Punto[10];   //alloca 10 strutture, preleva il primo indirizzo dell'area puntata e lo assegna a                                         q[0] - "q" punta ad un area contigua.

for(int i=0;i<10;i++)

{

   q[i].ascissa=5+i;

   q[i].ordinata=7+i;

}

in alternativa:

for(int i=0;i<10;i++)

{

   *(q+i)=i;   //dove "q" è l'indirizzo di partenza e "i" l'elemento 

}

Per deallocare lo spazio assegnata ai puntatori utilizzeremo lo strumento "delete":

per un puntatore: delete q;

per un array di puntatori delete [10]Punto;

*!* Gli indirizzi puntati dagli Array sono salvati in un area di memoria chiamata +HEAP