Il blog sull'informatica

Stamattina ho provato ad installare il plugin Axis2 code generator 1.6.1 sul mio Eclipse Galileo. Peccato che ad installazione completata, accedendo al wizard di eclipse non era presente alcuna voce Axis 2. Cercando un po' sul Web ho trovato questo 3d:

http://stackoverflow.com/questions/8075585/not-able-to-se...

in cui si afferma che sia la versione 1.6.1 che la versione 1.4.* sono bacate e quindi funzionano male (o non funzionano del tutto).

Proprio per tale motivo ho scaricato la versione 1.7.0 del plugin in questione, direttamente da questo link:

https://builds.apache.org/job/Axis2/lastStableBuild/org.a...

Copiate il *.jar all'interno della directory dropin, riavviate eclipse e tutto funzionerà alla perfezione.

A presto.

PS: la 1.7.0 è una nightly release (versione di test), quindi se qualcosa non dovesse funzionare alla perfezione non preoccupatevi più di tanto.

Circa un annetto fa ho sviluppato un piccolo client (scritto interamente in linguaggio C) che si interfaccia ad un database Mysql. Ora, per fare in modo che l'interfacciamento con il database possa avvenire, è necessario utilizzare la libreria mysql.h da inserire all'interno del codice sorgente mediante la classica direttiva #include.

Una volta completata la stesura del codice, è necessario scaricare la libreria che consentirà al nostro client di interrogare il database. Per fare ciò occorrerà utilizzare il comando (su piattaforma *buntu):

nightfly@nightbox:~$ sudo apt-get install libmysqlclient-dev

Installiamo il compilatore per generare l'eseguibile partendo dal sorgente:

nightfly@nightbox:~$ sudo apt-get install gcc

Successivamente, occorrerà compilare il sorgente sfruttando gcc e la libreria mysqlclient:

nightfly@nightbox:~$ sudo gcc -o nome_eseguibile sorgente.c -l mysqlclient

A questo punto possiamo avviare l'eseguibile digitando:

nightfly@nightbox:~$ ./nome_eseguibile

Ecco fatto. A presto.

Ecco un piccolo esempio di comunicazione tra agenti JADE.

Agente mittente

import jade.core.Agent;
import jade.core.AID; //libreria necessaria per definire il destinatario
import jade.core.behaviours.*;
import jade.lang.acl.*;

class mioBehaviour extends CyclicBehaviour {
public void action() {
ACLMessage reply = myAgent.receive(); //è l'agente che riceve la risposta
if (reply != null) //appena ricevo una sola risposta non vuota blocco l'agente
{
System.out.println("Ho ricevuto la risposta " + reply.getContent() + " dall'agente " + reply.getSender() );
}
block();
}
}

public class sender extends Agent {
public void setup() {
System.out.println("Agente " +getAID()+ " inizializzato");
ACLMessage msg  = new ACLMessage(ACLMessage.INFORM); //definisco il tipo di messaggio da inviare
msg.setContent("Antani"); //definisco il contenuto del messaggio da inviare
msg.addReceiver( new AID( "destinatario", AID.ISLOCALNAME) ); //destinatario è il nickname che ho assegnato all'agente che riceverà il messaggio
send(msg); //invio il messaggio
System.out.println("Ho inviato il messaggio " + msg.getContent());
addBehaviour(new mioBehaviour()); //ascolto eventuali risposte
}
}

Agente destinatario

import jade.core.Agent;
import jade.core.AID;
import jade.core.behaviours.*;
import jade.lang.acl.*;

class myBehaviour extends CyclicBehaviour {
public void action() {
ACLMessage msg = myAgent.receive(); //è l'agente che riceve la risposta
if (msg != null) //appena ricevo una sola risposta non vuota blocco l'agente
{
System.out.println("Ho ricevuto il messaggio " + msg.getContent() + " dall'agente " + msg.getSender());
ACLMessage reply = msg.createReply();
reply.setPerformative( ACLMessage.INFORM );
reply.setContent("Ricevuto");
myAgent.send(reply);
}
block();
}
}

public class receiver extends Agent{
public void setup() {
System.out.println("Agente " +getAID()+ " inizializzato");
addBehaviour(new myBehaviour());
}
}

Per prima cosa vengono inizializzati i 2 agenti. Successivamente l'agente mittente invia un messaggio all'agente destinatario. Quest'ultimo, alla ricezione del messaggio, elaborerà una risposta da inoltrare all'agente mittente.

Da notare che la ricezione dei messaggi viene gestita mediante dei CyclicBehaviour (ovvero dei behaviour che vengono eseguiti continuamente), proprio per fare in modo che l'agente rimanga in ascolto.

Se l'agente non riceve alcun messaggio il behaviour viene immediatamente arrestato fino alla ricezione del prossimo messaggio non vuoto. Ciò viene implementato attraverso l'istruzione block().

Il codice comunque dovrebbe apparire piuttosto chiaro (sono presenti diversi commenti).

Per ulteriori delucidazioni non esitate a contattarmi. A presto.

Ecco un piccolo esempio di come accedere agli attributi ed ai metodi di una classe mediante puntatore:

 Header

class Cliente
{
    public:
    char nome[20];
    char cognome[20];
    char indirizzo[20];
    char sesso;
    int eta;
    void InserisciNome();
    void InserisciCognome();
    void InserisciIndirizzo();
    void InserisciSesso();
    void InserisciEta();
};

Sorgente 

#include <iostream.h>
#include "cliente2.h"

void Cliente::InserisciNome()
{
    cout << "Inserisci il nome del cliente" << endl;
    cin >> nome;
}

void Cliente::InserisciCognome()
{
    cout << "Inserisci il cognome del cliente" << endl;
    cin >> cognome;
}

void Cliente::InserisciIndirizzo()
{
    cout << "Inserisci l'indirizzo del cliente" << endl;
    cin >> indirizzo;
}

void Cliente::InserisciSesso() //:: operatore di scope
{
    while((sesso!='m') && (sesso!='f'))
    {
        cout << "Inserisci il sesso del cliente" << endl;
        cin >> sesso;
    }
}

void Cliente::InserisciEta()
{
    cout << "Inserisci l'età del cliente" << endl;
    cin >> eta;
}

void main()
{    

    Cliente *cliente;

    cliente=new Cliente();
    cliente->InserisciNome();
    cliente->InserisciCognome();
    cliente->InserisciIndirizzo();
    cliente->InserisciSesso();
    cliente->InserisciEta();

    cout << "Il cliente da te inserito è " << endl;
    cout << cliente->nome << endl;
    cout << cliente->cognome << endl;
    cout << cliente->indirizzo << endl;
    cout << cliente->sesso << endl;
    cout << cliente->eta << endl;
}

A presto! 

Ecco un semplice programmino che fa uso di una classe con funzioni membro:

Header 

class cliente
{
    public:
    char nome[20];
    char cognome[20];
    char indirizzo[20];
    char sesso;
    int eta;
    void InserisciNome();
    void InserisciCognome();
    void InserisciIndirizzo();
    void InserisciSesso();
    void InserisciEta();
};

 
Sorgente

#include <iostream.h>
#include "cliente1.h"

void cliente::InserisciNome()
{
    cout << "Inserisci il nome del cliente: " << endl;
    cin >> nome;
}

void cliente::InserisciCognome()
{
    cout << "Inserisci il cognome del cliente: " << endl;
    cin >> cognome;
}

void cliente::InserisciIndirizzo()
{
    cout << "Inserisci l'indirizzo del cliente: " << endl;
    cin >> indirizzo;
}

void cliente::InserisciSesso()
{
    while((sesso!='m')&&(sesso!='f'))
    {
        cout << "Inserisci il sesso del cliente: " << endl;
        cin >> sesso;
    }
}

void cliente::InserisciEta()
{
    cout << "Inserisci l'età del cliente: " << endl;
    cin >> eta;
}

void main()
{
    cliente cliente;
    cliente.InserisciNome();
    cliente.InserisciCognome();
    cliente.InserisciIndirizzo();
    cliente.InserisciSesso();
    cliente.InserisciEta();
    cout << "I dati riguardanti il cliente sono: " << endl;
    cout << cliente.nome << endl;
    cout << cliente.cognome << endl;
    cout << cliente.indirizzo << endl;
    cout << cliente.sesso << endl;
    cout << cliente.eta << endl;
}

A presto! 

L'overloading è una peculiarità del C++ (non presente quindi in C) che permette di utilizzare lo stesso nome per due o più funzioni, purchè abbiano argomenti diversi. Ecco un esempio:

#include <iostream.h>

int prodotto (int a, int b);
float prodotto (float a, float b);

void main()
{
    int a, b, risultato;
    float c, d, ris;
    cout << "Inserisci il primo numero (intero)" << endl;
    cin >> a;
    cout << "Inserisci il secondo numero (intero)" << endl;
    cin >> b;
    risultato=prodotto(a, b);
    cout << "Il prodotto è pari a: " << risultato << endl;
    cout << "Inserisci il primo numero (reale)" << endl;
    cin >> c;
    cout << "Inserisci il secondo numero (reale)" << endl;
    cin >> d;
    ris=prodotto(c, d);
    cout << "Il prodotto è pari a: " << endl << ris;
}

int prodotto (int a, int b)
{
    int ris;
    ris=a*b;
    return(ris);
}

float prodotto (float a, float b)
{
    float ris;
    ris=a*b;
    return(ris);
}

A presto! 

Molti di voi sapranno che è assolutamente sconveniente scrivere un programma di grandi dimensioni costituito esclusivamente dalla funzione main(). Infatti, è molto più vantaggioso implementare funzioni diverse a seconda delle operazioni che si devono svolgere o, in termini più pratici, dividere un unico grande problema in più sottoproblemi di minore entità (divide et impera). A tal scopo ho pensato di pubblicare il seguente programmino:

#include <iostream.h>

int prodotto(int a, int b); //definizione del prototipo

void main ()
{
    int a, b, risultato;
    cout << "Inserisci il primo numero: " << endl;
    cin >> a;
    cout << "Inserisci il secondo numero: " << endl;
    cin >> b;
    risultato=prodotto(a, b);
    cout << "Il risultato del prodotto è: " << risultato << endl;
}

int prodotto (int a, int b)
{
    int ris;
    ris = a*b;
    return(ris);
}

Come potete notare, immediatamente prima del main() ho definito il prototipo della funzione prodotto, la quale verrà implementata successivamente al main() stesso. Tale operazione risulta obbligatoria, in quanto fa parte dello standard ANSI. Per ciò che concerne invece il posizionamento dei prototipi, è buona norma inserirli all'interno dell'header, anche se la loro definizione prima del main() è comunque consentita.

Spero di essere stato esaustivo, a presto! 

Qui di seguito è riportato il sorgente di un piccolo programmino scritto da me in C++ in cui viene mostrato l'uso delle classi:

Header

class cliente
{
    public:
    char nome[20];
    char cognome[20];
    char indirizzo[20];
    char sesso;
    int eta;
};

Sorgente

#include <iostream.h>
#include "cliente.h"

void main()
{
    cliente cliente;
    cout << "inserisci il nome del cliente:" << endl;
    cin >> cliente.nome;
    cout << "Inserisci il cognome del cliente:" << endl;
    cin >> cliente.cognome;
    cout << "Inserisci l'indirizzo del cliente:" << endl;
    cin >> cliente.indirizzo;
    while ((cliente.sesso!='m') && (cliente.sesso!='f'))
    {
        cout << "inserisci il sesso del cliente (M o F):" << endl;
        cin >> cliente.sesso;
    }
    cout << "Iserisci l'età del cliente" << endl;
    cin >> cliente.eta;

    cout << "Il cliente da te inserito è: " << endl;
    cout << cliente.nome << endl;
    cout << cliente.cognome << endl;
    cout << cliente.indirizzo << endl;
    cout << cliente.sesso << endl;
    cout << cliente.eta << endl;
}

Facciamo ora alcune osservazioni: è buona norma implementare la classe (in questo caso "cliente") all'interno di un header, per rendere il sorgente più comprensibile ed ordinato. Tale header verrà successivamente richiamato mediante #include.

Per ciò che concerne il main ho ritenuto opportuno creare un sistema per verificare che il carattere inserito dall'utente sia effettivamente M oppure F. Infine, l'ultima parte del codice serve a stampare su schermo i dati da noi appena inseriti.

A presto! 

Ecco un semplice programmino per calcolare somma, media e diagonale principale di una matrice 3x3 (vista come vettore bidimensionale):

#include <iostream.h>

void main()
{
 int v[3][3], somma, diagonale, i, j, n;
 float media;
 somma = 0;
 diagonale = 0;
 n = 0;
 for (i=0; i<3; i++) //inserisco gli elementi nella matrice
    for (j=0;j<3;j++)
  {
        cout << "inserisci l'elemento di posizione: " << i << j << endl;
        cin >> v[i][j];
  }
 for (i=0; i<3; i++) //calcolo somma e diagonale principale
    for (j=0;j<3;j++)
    {
        somma += v[i][j];
        if (i==j)
        diagonale += v[i][j];
    }
 for (i=0;i<3;i++)
    for(j=0;j<3;j++)
        n++;
 

cout << "La somma è: " << somma << endl;
media = ((float)somma)/n; //calcolo la media
cout << "La media è: " << media << endl;
cout << "La diagonale principale è: " << diagonale << endl;

}

Facciamo adesso alcune osservazioni. Come potete notare se non avessi utilizzato la conversione esplicita, cioè ((float)somma), nonostante la variabile media sia di tipo float, il risultato che avrei ottenuto sarebbe stato un int, poichè a monte vi è una somma di tipo intero. Avrei potuto ovviare a tale situazione semplicemente dichiarando la variabile somma non più come int ma come float:

#include <iostream.h>

void main()
{
 int v[3][3], diagonale, i, j, n;
 float media, somma;
 somma = 0;
 diagonale = 0;
 n = 0;
 for (i=0; i<3; i++) //inserisco gli elementi nella matrice
    for (j=0;j<3;j++)
  {
        cout << "inserisci l'elemento di posizione: " << i << j << endl;
        cin >> v[i][j];
  }
 for (i=0; i<3; i++) //calcolo somma e diagonale principale
    for (j=0;j<3;j++)
    {
        somma += v[i][j];
        if (i==j)
        diagonale += v[i][j];
    }
 for (i=0;i<3;i++)
    for(j=0;j<3;j++)
        n++;
 

cout << "La somma è: " << somma << endl;
media = somma/n; //calcolo la media
cout << "La media è: " << media << endl;
cout << "La diagonale principale è: " << diagonale << endl ;

}

A presto! 

Ecco un semplicissimo programmino scritto in C++ che calcola la somma di due interi:

#include <iostream.h>

void main()
{
    int a, b, somma;
    cout << "inserisci il primo numero";
    cin >> a;
    cout << "inserisci il secondo numero";
    cin >> b;
    somma = 0;
    somma = a+b;
    cout << "La somma è " << somma;
}