#include <QApplication> //Classe per l’applicazzione, necessaria in qualsiasi programma

#include <QPushButton> //Classe per il bottone della finestra

#include <QWidget> //Classe per la form

Dopodiché andiamo a creare la nostra funzione principale main, il classico punto di ingresso del nostro programma.

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

{

Dentro alla funziona main, creiamo un’istanza della classe QApplication, che rappresenta la nostra applicazione, e che è sempre necessaria in qualsiasi programma realizzato con Qt. Come parametri di ingresso, passiamo gli stessi parametri che riceviamo tramite la funzione main, ovvero argc e argv.

QApplication a(argc, argv);

A questo punto creiamo la nostra form, ovvero l’interfaccia grafica (la finestra) che rappresenta la nostra applicazione e che conterrà i vari widgets (bottoni, label, etc…). Inoltre diamo alla form una dimensione in pixel di 200×200.

QWidget w;

w.resize(200, 200);

A tal punto, creiamo un bottone, che ci servirà come metto per chiudere la nostra applicazione. Per farlo instanziamo la classe QPushButton. Instanziando la classe, diamo come parametri al suo costruttore il nome che sarà visualizzato nel tasto (primo parametro) e l’indirizzo dell’oggetto che ospita il nostro bottone, ovvero la form (secondo parametro). Poi, diamo anche le dimensioni di larghezza e altezza del tasto (primo e secondo parametro) e la posizione sulla form (terzo e quarto parametro); il tutto grazie alla funzione setGeometry(…);

QPushButton btn(“Esci”, &w);

btn.setGeometry(50, 50, 85, 85);

Adesso, non ci resta che rendere visibile la nostra interfaccia grafica, associare un’azione al bottone (ovvero quella di chiudere l’applicazione) e infine mandiamo in esecuzione l’applicazione, ovvero l’oggetto a, instanziato all’inizio dalla classe QApplication.

QObject::connect(&btn, SIGNAL(clicked()), &a, SLOT(quit()));

return a.exec();

}

L’azione al bottone, come potete vedere dal codice soprastante, viene data per mezzo l’uso dei SIGNALS e SLOTS, che per spiegarli in maniera efficiente avremmo bisogno di un altro articolo abbastanza lungo. In poche parole vi basta sapere che in quel caso, il segnale è mandato dal bottone, e lo slot ricevente è l’applicazione, che è proprio colei che riceve il segnale di chiusura.

Provate quindi a unire tutte le righe di codice in un unico file .cpp ed eseguirlo tramite con Ctrl+R se state usando QT Creator IDE, oppure lanciate i seguenti comandi una volta posizionati dentro la cartella del progetto:

qmake -project

qmake

make

Quindi, lanciate l’applicazione, e notate l’effetto finale

Come forse molti di voi sapranno è da un bel pò di tempo uscita una nuova versione del famoso framework di librerie per lo sviluppo di applicativi multipiattaforma. Sto parlando di Qt giunto alla versione 4.4 che ha portato molte migliorie e sopratutto novità! Non sto ad entrare nei dettagli tecnici ma passo subito al dunque; molti neofiti del settore possono scoraggiarsi nell’usare queste librerie assieme al linguaggio C++ per il semplice motivo che raggiungere un buon prodotto finale risulta più faticoso rispetto a quanto possa esserlo usando Visual Studio e linguaggio come il Visual Basic. Ma non scoraggiatevi con Qt avete ormai a disposizione tutto quello di cui c’è bisogno. Esiste la versione Open Source, che vi permette di sfruttare tutta la potenza di tali librerie a costo 0, con la sola imposizione di creare software esclusivamente Open Source e non commerciale, per quello bisogna comprarle. Inoltre il framework vi offre tante funzioni e comodità che aiutano nello sviluppo di software. Per sviluppare con Qt potete godere di questi componenti:

1. Librerie Qt (per Windows, Linux o MacOS) scaricabili dal sito ufficiale
2. Qt Designer (incluso nell’istaller per Windows e separatamente per altri OS) scaricabile sempre dal sito ufficiale.
3. Qt Assistant (incluso nell’istaller per Windows e separatamente per altri OS) che vi aiuterà come riferimento al framework, diciamo una sorta di MSDN.
4. Qt Creator è un IDE (es. Visual Studio, per capirci) che ci permette di sviluppare con più comodità, evitando di lavoare quasi esclusivamenet solo via codice, come avveniva fino a tempo fa. La versione è ancora ALPHA, e la release ufficiale stabile è prevista con l’uscita di Qt 4.5; è disponibile anche una versione di un IDE chiamato QDevelop che non è creato dalla società che ha sviluppato Qt, ma che risulta comunque valido (non l’ho mai provato).

Chi usa Qt?
Bene, questa domanda ha una risposta che a molti lettori dovrebbe dare una certa fiducia. Qt è usato da: Adobe, Skype Limited, Firefox (in furuto), VCL Media Player (partendo dall’ultima versione), Tor, KDE (l’intero ambiente desktop di molte distro Linux), e altri ancora…

Inoltre..
Qt è disponibile per qualsiasi piattaforma dekstop come Windows, Linux e MacOS. Le applicazioni finali per cui, saranno facilmente trasportabili da una piattaforma all’altra con poche modifiche. In più, la nuova versione è approdata anche su dispositivi mobili, come cellulari che usano Symbian come OS.

Una notazione importantissima: già dalle ultime versioni di Qt, arrivando all’attuale 4.4 è possibile utilizzarle con tanti linguaggi di programmazione, senza soffermarci per forza al C++. Infatti, Qt è interfacciabile anche con Java, Python e Ruby (se non erro).

Tale framework è oggi giorno sponsorizzato da tanti grossi del settore come: Epson, Google, AMD, Volvo, Philips…

Curiosità: la versione Estesa di Qt (quella commerciale) permette anche l’interfacciamente con Visual Studio).

Non sarà la perfezione, non saranno veloci come la luce, ma non si può dire che siano un cattivo prodotto

Il sito ufficiale: http://trolltech.com/products

#include <cstdlib>
#include <iostream>

using namespace std;

void Swap(int &i, int &j);
void SSwap(int *p);

int main(int argc, char *argv[])
{
int a, b, c, d, e;

a = 1;
b = 2;
c = 3;
d = 4;

//Usiamo la funzione Swap() – Stile C++
cout << “A e B: “ << a << ” “ << b << endl;
Swap(a, b);
cout << “A e B con Swap: “ << a << ” “ << b << “\n\n”;

cout << “C e D: ” << a << ” ” << b << endl;
Swap(c, d);
cout << “C e D con Swap: “ << c << ” “ << d << “\n\n” << “* * *” << “\n\n”;

//Usiamo la funzione SSwap() – Veccio stile C manuale
e = 5;
cout << “E: ” << e << endl;
SSwap(&e);
cout << “E con SSwap: “ << e << endl;

getchar();
return EXIT_SUCCESS;
}

void Swap(int &i, int &j)
{

//esegue un’inversione dei valori tra le variabili
int t;
t = i;
i = j;
j = t;

/* Nello stile C++ non abbiamo bisogno di usare l’operatore *, basta dichiarare
i parametri con l’operatore &, e quindi diamo come parametri direttamente gli
indirizzi. */
}

void SSwap(int *p)
{

//Esegue un’inversione di segno della variabile
*p = -*p;
/* Si noti che in questa funzione dobbiamo dire che come parametro accettiamo
un puntatore. Nell’operare con i dati, abbiamo bisogno di usare l’operatore
*, che indica “all’indirizzo di”, quindi agisce sul valore contenuto dall’indirizzo.
Questo è il contrario di quanto avviene sopra, nello stile del C++ */
}

Si provi a compilare e eseguire il codice

//—————————————————————————

/* Funzioni inline */

//—————————————————————————

#include <stdio.h>
#include <iostream>

using namespace std;

inline int max(int a, int b)
{
return a > b ? a : b;
}

int main(int argc, char* argv[])
{
cout << max(10, 20);
cout << ” ” << max(99, 88);

getchar();
return 0;
}
//—————————————————————————

La funzione inline si dichiara antecedendo appunto la parola chiave inline che non fa altro che effettuare una richiesta al processore, che può anche teoricamente non accettare tale richiesta. La richiesta chiede appunto, come fa register un trattamento speciale. La funzione viene eseguita ogni volta che è necessario e non richiamata, quindi evitiamo tante operazioni e uso di memoria eccessivo. Le funzioni inline possono essere anche membri di classi. Consiglio comunque di usare tale tipologia di funzioni solo in casi in cui le funzioni sono molto concise o comunque al posto di normali funzione che rallentano di molti le prestazioni del software. C’è da annotare che alcuni compilatori non accetteranno sempre e comunque tutte le funzioni inline, per via di certe eccezzioni, in tal caso, il compilatore tratterà la funzione come una normale funzione!

Iniziamo col dire che in C è possibile scrivere GUI (Grapich User Interface) ma non è consigliato, perchè la maggior parte delle librerie in circolazione è disponibile solo per C++ e non per il C, dato che sono destinate a essere usate per la programmazione OOP. Di conseguenza, se siete su Windows per esempio, e volete creare finestre grafiche potete affidarvi alle API o comunque gestire tutto a manina. Potreste anche trovare librerie o robe simili, ma il linguaggio ottimale è il C++, perchè è un linguaggio OOP.

Infatti, ci sarà pure un motivo per cui sia stata inventata la OOP. Parlando a livello molto basso, comprnesibile da tutti, possiamo dire che essa ci permette di pensare “tutto” come oggetti, e di conseguenza anche i vari componenti di una finestra grafica. In questo modo, grazie alle classi che sono le astrazioni degli oggetti, possiamo gestire al meglio il codice.

Ma non soffermiamoci troppo sulla teoria, quella è qualcosa che dobbiamo studiare da noi, parliamo invece di ciò che tratta il post, i framework disonibli! Anticipiano comunque che tutti i framework hanno degli stili di default per creare finestre, quindi non potrete farle di forme a vostro piacimento, se non con modifiche varie al codice.

Ecco i principali framework:

• Qt - Qt è uuna grande libreria che permette di creare interfaccia utente tramite dei widgets, che sono quelli che compongono essenzialmente anche le altre librerie che vedremo in seguito. Esistono due versione del framework Qt: una opensoruce e un’altra shareware. La prima può essere usata solo per sviluppare software open, la seconda per qualsiasi utilizzo. Il framework di Qt offre anche un Designer per creare le finestre in maniera visuale, ed evitare la fatica del codice. Punto di forza è che sono molto potenti, e sopratutto multipiattaforma, ovvero sono disponibili sia per Windows che per Linux. Esistono anche altre versione per altri OS, come per Mac OS. Sono semplici da usare, ma per un principiante non sono il massimo!
• Visual C++ – E’ un IDE offerto dalla Microsoft sotto due licenze: una freeware (limitata) e una sharewre (completa). Esso permette di creare software, compilarlo (ha un compilatore interno di proprietà della Microsoft) e tanto altro. Il framework che usa per creare le interfaccie grafiche è componeto dalle librerie MFC che includono tutte le funzioni delle API. Di conseguenza dobbiamo dire però, che l’uso non è affatto scemplice, e le applicazioni uscenti saranno solo eseguibili su sistemi Windows. Inoltre le ultime versioni permettono di creare anche applicazioni C++/CLI ovvero sfruttando il .NET Framework di Microsoft. Ciò può aiutare la portabilità del softwre finale anche su Linux, dove esiste Mono che è un porting del .NET Framework. Attualmente è supportato fino alla versione 2.0!
• CodeGear C++ Builder 2007 – Questo ambiente è sviluppato dalla Borland Software Corporation ed è adatto per sviluppare GUI sotto Windows XP/Vista. Esiste la versione precedente che supporta anche Windows 98. E’ importante dire che questo ambiente semplifica molto la gestione e la creazione di GUI sotto Windows rispetto a Visual C++ e le MFC, che richiedono tempo e compotenza! E’ veloce, ma non è freeware. L’unica versione è commerciale. Possiede un compilatore proprio, sempre sviluppato dalla Borland. E’ possibile utilizzare due librerie: una integra le API di Windows e altre funzionalità, l’altra include la funzionalità con Linux, per cui sarà possibilità di esportare il prodotto finale.

Esistono anche altri prodotti che permettono di creare GUI, ma questo sono a mio parere i migliori e i più gettonati. Il primo utile per la portatilità del codice, il secondo per ambienti Windows, e il terzo per avere tempo di sviluppo e un ottima gestionabilità dei progetti (sempre per Windows).

Questi di default permettono di creare finestre nello stesso stile di cui sono le finestre del sistema operativo, se si vuole, si potrebbe grazie ad altre librerie creare softwre grafico personalizzato.

Per informazioni o chiarimenti o critiche sull’articolo, lasciate pure un commento!

• Non possono ereditare proprietà da altre classi
• Non possono contenere funzioni membro virtuali
• Nessuna variabile static può essere membro di un unione
• Nessun membro dell’unione può avere un overloading all’operatore =
• Un unione non può essere presa come classe base o genitore

Le unioni possono contenere sia dati che funzioni. Però esiste anche in C++ un particolare uso delle unioni, che vengono detto unioni anonime. Si tratta di unioni che possono contenere solo dati, che come di regola condividono la stessa area di memoria. Questi dati all’interno dell’unione anonima, hanno l’unica caratteristica di avere in comune la stessa area di memoria, del resto è come se fossero delle normali variabili con il normale campo di visibilità delle altre che si trovano fuori l’unione. Infatti, non vi è alcun bisogno per andare a lavorare su un mbro di tale unioni adoperando una dichiarazione e il dot (.) e non vi è alcun bisogno di dare un nome all’unione, ma basta usare la parola chiave union!

Tutto avviene automaticamente, come normali variabili, ecco un esempio:

//unione anonima
union {
long l;
double d;
}

//accesso diretto ai membri dell’unione anonima
l = 10000;
d = 123.2345;

cout << l << ” ” << d << “\n”;

C’è da ricordarsi che le unioni anonime non possono conterere membri private o protected, e inoltre se dichiarata come globale, i dati devono essere preceduti dal modificatore static.

1. Iniziamo con il definire gli header e incorporare il namespace std, che ci metterà a disposizione un accesso più diretto ai membri di iostream:

#include <cstdlib>
#include <iostream>

using namespace std;

2.  A questo punto, creiamo la nostra classe, definendo due funzioni pubbliche e una variabile privata accessibile solo dalle funzioni della classe:

class Math {
int Ris;
public:
void Add(int a, int b);
void Sott(int a, int b);
};

3.  A questo punto accediamo alle funzioni tramite l’operatore :: che indica il campo d’azione, e scriviamo dentro di esse il codice per eseguire i calcoli:

void Math::Add(int a, int b)
{
Ris = a + b;

cout << “La somma di 2 + 2 e’ ” << Ris << “\n”;
}

void Math::Sott(int a, int b)
{
(a > b) ? Ris = a – b : Ris = b – a; //Corrisponde a una forma più “elegante” del controllo if

cout << “La sottrazione di 4 – 2 e’ “ << Ris << “\n”;
}

4.  Adesso, creiamo un’istanza dell’oggetto Math nella funzione principale main() e richiamiamo le funzioni:

int main()
{
Math Matematica; //Creo l’istanza dell’oggetto Math, chiamandola Matematica

Matematica.Add(2, 2); //Esegue la somma tramite la funziona Add dell’oggetto Math
Matematica.Sott(4, 2); //Esegue la sottrazione tramite la funziona Sott dell’oggetto Math

getchar(); //Attendo prima di chiudere il programma
return EXIT_SUCCESS;
}

5.  Adesso il programma è finite, nella sua versione più semplice e imperfetta. L’output sarà il seguente:

La somma di 2 + 2 e’ 4

La sottrazione di 4 – 2 e’ 2

Per chiarimenti, o altro ancora, potete lasciare un commento.

IMPORTANTE: Per usare il codice che sta per seguire bisogna linkare al linker le seguenti lib:

• ws2_32.lib
• Mswsock.lib
• Advapi32.lib

L’header del nostro file .c o .cpp sarà composto dai seguenti header necessari e della dichiarazione di una variabile globale utilizzata per effettuare vari controlli:

#include <windows.h>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <string.h>
int iResult;

Passiamo ora all’inizio della programmazione pratica. Innanzi tutto bisogna creare e inizilizzare un oggetto WSADATA (per maggiori informazioni sulla struttura WSADATA visitate il supporto MS all’indirizzo http://msdn.microsoft.com/en-us/library/ms741563(VS.85).aspx):

WSADATA wsaData;
//Inizializzo Winsock
iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
if(iResult != 0)
{
printf(“WSAStartup failed: %d\n”, iResult);
return 1;
}

Il blocco If, come si può capire serve per controllare eventuali errori. La variabile iResult è una variabile globale, di tipo intero. Alla funzione WSAStartup abbiamo pasato come argomenti due parametri: il primo è la versione dei socket che stiamo usando, ovvero 2.2, il secondo parametro invece è l’indirizzo dell’oggetto WSAData precedentemente creato. Andiamo avanti, e vediamo come fare per gestire passo passo il lato client. Iniziamo col definire una porta che useremo per le connessioni e l’inizializzazione di un oggetto addinfo che contiene una struttura sockaddr (per informazioni a queste due struttura vi rimando sempre al sito MSDN DI Microsoft):

#define PORT “8000″
struct addrinfo *result = NULL, *ptr = NULL, hints;

ZeroMemory(&hints, sizeof(hints));

hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;

In questo caso abbiamo riempito il campo della struttura ai_family con AF_UNSPEC che indica che non è definito la versione del protocollo IP, per cui può essere sia IPv4 che IPv6. Se volessimo definire l’uso dell’IPv4 avremmo messo AF_INET, contrariamente per IPv6 avremmo messo AF_INET6. Il secondo campo, ai_socktype, indica il tipo di socket, in questo caso abbiamo scleto SOCK_STREAM che è quello usato per comunicazioni di rete. Il terzo campo, ai_protocol, riguarda il protocollo usato per la trasmissione e il controllo dei dati trasmessi: il suo valore è IPPROTO_TCP, che indica appunto il protocollo TCP. La scelta risulta pressochè obbligatoria, in quanto prima abbiamo specificato il tipo di socket come SOCK_STREAM, se avessimo invece usato SOCK_DGRAM avremmo potuto usare il protocollo UDP, che appunto usa i datagrammi. Queste sono le specificazioni basilari, per maggiori informazioni sulla struttura addrinfo potete visitare il sito di MS http://msdn.microsoft.com/en-us/library/ms737530(VS.85).aspx

Adesso dobbiamo vedere a quale indirizzo IP dobbiamo connetterci, quindi il server di destinazione. In questo caso useremo la funzione getaddrinfo che restiruisce un valore intero, anche se il nostro valore sarà una stringa come ad esempio “192.168.1.2″ o “irc.azzurra.org”. Andiamo a vedere il codice:

// Resolve the server address and port
iResult = getaddrinfo(argv[1], DEFAULT_PORT, &hints, &result);
if ( iResult != 0 ) {
printf(“getaddrinfo failed: %d\n”, iResult);
WSACleanup();
return 1;
}

La funzione getaddrinfo accetta diversi parametri, precisamente 4.. analizziamoli: il primo è l’host, ovvero il nodo a cui connetterci, esso è rappresentato da un indirizzo IPv4 o 6 in base alle dichiarazioni prima effettuate, ed è passato in formato stringa, tant’è vero che gli abbiamo dato in pasto il parametro argv[1] della funzione main(), quindi il suo valore sarà inserito all’avvio dell’applicazione tramite riga di comando, ovvero: nomeprogramma server_a_cui_connettersi. In seguito abbiamo passato la porta e due indirizzi: il primo è del puntatore a una struttura addrinfo e il secondo a una struttura addrinfo. La funzione restituisce un valore intero, per tale motivo l’abbiamo assegnato alla variabile intera iResult e abbiamo controllato eventuali errori con un iterazione if: se tutto è andato a buon fine, solitamente, riceveremo un valore pari a 0. Altrimenti ci sono diversi tipi di errori, consultabili nella pagina MSDN http://msdn.microsoft.com/en-us/library/ms738520(VS.85).aspx

Adesso, non ci resta che creare ed utilizzare il socket! Creiamo quindi l’oggetto SOCKET con la seguente stringa:

SOCKET ConnectSocket = INVALID_SOCKET;

Quindi inizializziamo il socket, con i valori prima definiti:

ptr=result;

// Socket for connect to server
ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype,
ptr->ai_protocol);

E facile capire, che i parametri passati sono proprio gli elemnti della strutta addrinfo che abbiamo prima riempito. Ma, come proposto dal sito di MSDN Microsoft, è bene cercare sempre eventuali errori, e lo facciamo con un controllo per mezzo dell’istruzione if:

if (ConnectSocket == INVALID_SOCKET) {
printf(“Error at socket(): %ld\n”, WSAGetLastError());
freeaddrinfo(result);
WSACleanup();
return 1;
}

Quindi, facciamo un pò di chiarezza del codice stampato: se il socket ritorna essere invalido, stampiamo la scritta di errore e richiamiamo la funzione WSAGetLastError() che appunto ci comunica l’ultimo errore verificato. Poi liberiamo le risorse tramite la funzione freeaddrinfo() e usiamo WSACleanup per terminare anche l’uso della libreria WS2_32 DLL. Adesso però, prendendo per buono che tutto è andato a buon fine, dobbiamo connettersi a un socket remoto. Bene, è arrivato il momento di usare la funzione connect(). Vediamo un pò di codice, e poi commentiamo:

// Connect to server.
iResult = connect( ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
if (iResult == SOCKET_ERROR) {
closesocket(ConnectSocket);
ConnectSocket = INVALID_SOCKET;

freeaddrinfo(result);

if (ConnectSocket == INVALID_SOCKET) {
printf(“Unable to connect to server!\n”);
WSACleanup();
return 1;
}
}

Analizziamo il codice. Abbiamo usato la funzione connect per connetterci al server remoto, ed ecco i parametri che abbiamo passato alla funzione: il primo è il socket usato per la connessione, il secondo e il terzo sono dei puntatori che accedono agli elementi delle relative strutture, precisamente il server a cui provare a connettersi e la porta. Di seguito poi, come potrete capire, avviene il controllo per verificare l’eventuale presenza di errori, e in tal caso comunicarli. Ora però, dobbiamo inviare e ricevere dati, quindi vediamo come farlo, come comunciare col server:

#define DEFAULT_BUFLEN 512
char *sendbuf = “Qui i dati”;

char recvbuf[DEFAULT_BUFLEN];
// Inviamo un buffer iniziale di dati

iResult = send( ConnectSocket, sendbuf, (int)strlen(sendbuf), 0 );

if (iResult == SOCKET_ERROR) {

printf(“send failed: %d\n”, WSAGetLastError());

closesocket(ConnectSocket);

WSACleanup();

return 1;

}

printf(“Bytes Sent: %ld\n”, iResult);

Molto semplice, abbiamo usato la funzione send per inviare dei dati. Essa accetta come primo parametro il socket da noi creato, in successione i dati da inviare sottoforma di char *, e la lunghezza del buffer dati inviati. L’ultimo argomento è solitamente 0, per ulteriori informazioni potete consultare il sito di MSDN, che è una vera encicplopedia di riferimento

Adesso vediamo come mandare un shutdown il socket per usarlo nel secondo momento per ricevere i dati dal server:

if (iResult == SOCKET_ERROR) {

printf(“shutdown failed: %d\n”, WSAGetLastError());

closesocket(ConnectSocket);

WSACleanup();

return 1;

}

Ed ecco infine come ricevere i dati:

// Receive data until the server closes the connection
do {

iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
if ( iResult > 0 )
printf(“Bytes received: %d\n”, iResult);
else if ( iResult == 0 )
printf(“Connection closed\n”);
else
printf(“recv failed: %d\n”, WSAGetLastError());

} while( iResult > 0 );

In questo caso, i parametri sono simili alla funzione di invio dati, l’unica differenza è che il secondo parametro è il buffer dati che riceviamo e non quello che inviamo, il funzionamento è pressochè simile. Infine, non ci resta che disconnettersi dal server:

iResult = shutdown(ConnectSocket, SD_SEND);
if (iResult == SOCKET_ERROR) {
printf(“shutdown failed: %d\n”, WSAGetLastError());
closesocket(ConnectSocket);
WSACleanup();
return 1;
}

// Cleanup
closesocket(ConnectSocket);
WSACleanup();

return 0;

PS. Buona parte di questo articolo fa parte di una mia traduzione ai post scritti su MSDN in lingua inglese, spero di aver fatto un buon lavoro per alcuni che non masticano bene l’inglese e di aver trasmessmo come iniziare ad usare le socket in WIndows con il linguaggio C/C++.

Ecco il prototipo della funzione malloc(): void *malloc(size_t numero_di_byte);

Essa restituisce un puntatore NULL nel caso avviene qualche errore, come per esempio quando lo spazio richiesto e troppo grande rispetto a quello disponibile (lo spazio viene allocato in uno spazio chiamato heap, che si trova tra l’area di memoria utilizzata dal programma e lo stack). Nel caso tutto è andato a buon fine, malloc() restituisce un puntatore che punta all’indirizzo della memoria richiesta.

La funzione free invece accetta come parametro il puntatore che punta alla memoria richiesta, in modo tale da svuotarla (liberarla, restiruirla al sistema). Una nota importante: richiamate sempre free() con un argomento valido, cioè un puntatore prima utilizzato da malloc(), altrimenti rischiate di distruggere aree di memoria dello heap già libere o comunque far danno!

Vediamo un esempio:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
int *p; //Puntatore che riceverà l’indirizzo della memoria

p = (int *)malloc(10*sizeof(int)); //Richiediamo la memoria per 10 interi

/* Controlliamo che tutto sia andato a buon fine */
if(!p)
{
printf(“Memoria esaurita\n\n”);
exit(1);
}

return EXIT_SUCCESS;
}