C++ - Primo approccio

In questo esercizio, il primo in C++, si analizza la struttura dell'oggetto di cui si dichiarano le variabili, il costruttore (stesso nome dell'oggetto), il distruttore e i metodi che possono venire chiamati esternamente.
Si introducono le convenzioni più utilizzate per avere chiarezza nel codice e l'uso di const (per preservare un puntatore).
Infine si introducono i concetti di references e di overload degli operatori.

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

struct vector{
//convenzione: m_var per variabili membre dell'oggetto (Microsoft), altrimenti solo _var
//se utilizzo questa convezione ometto l'uso del this (perchè comunque è di default e _ mi rivela la natura di var
int *_data;
unsigned _size;

//vector(){} è il costruttore di default, se se ne dichiara un altro scompare
vector(unsigned size){//il primo parametro è un puntatore a un vettore, nome standard (this)
_size = size;//qui il this è obbligatorio per la precedenza, altrimenti usare _
_data = (int*) malloc(_size * sizeof(int));
}

unsigned size() const{//in C con const proteggo il puntatore (non i dati però)->const vector pointer
return _size;//il this si può omettere, è di default
}

int operator[] (unsigned i) const{
return _data[i];
}

void set(unsigned i, int val) {
_data[i] = val;
}

~vector(){//alt126 per la tilde
free(_data);
}
};//; necessario alla fine della struct senza nome

void vector_fill_rand(vector &v){//con il reference si scrive v., non si deve passare l'indirizzo
int i;
for(i=0;i<v.size();i++)
v.set(i,rand());
}

void vector_print(vector &v){
int i;
for(i=0;i<v.size();i++)
printf("%d, ", v[i]);//è come scrivere v.operator[](i)
}

void vector_copy(vector *pdest, vector *psorg){
int i;
if(pdest->_size != psorg->_size){
printf("\nRiallocazione memoria");
free(pdest->_data);
pdest->_size = psorg->_size;
pdest->_data = (int*) malloc(pdest->_size * sizeof(int));
}
printf("\nInizio copia...\n");
for(i=0;i<pdest->_size;i++)
pdest->_data[i] = psorg->_data[i];
printf("\nStampa di v2\n");
}


int main(void){
vector v(10);

vector_fill_rand(v);
vector_print(v);

vector v2(1);//il costruttore di v2 viene attivato solo ora; quando dichiariamo creiamo le variabili
vector_copy(&v2, &v);
vector_print(v2);

//le variabili possono essere dichiarate nel codice
double iMedia = 0;
for(unsigned i=0;i<v.size();i++)//visibilità locale delle variabili per i cicli
iMedia += v[i]; //è come scrivere v.operator[](i)
iMedia /= v.size();
printf("\nLa media di v e' %f\n", iMedia);
system("pause");
//viene chiamato il distruttore solo degli oggetti di cui è chiamato il costruttore
}

/*si introducono i riferimenti (references). Si usa un simbolo già usato. 
Puntatore che uso come se fosse una variabile. Il simbolo è &. Si nasconde il fatto che v è un puntatore.
Elemento indispensabile del linguaggio c++. Non sostituisce un puntatore, è un'altra cosa.
Quando si crea si definisce a cosa si riferisce e non può essere cambiata. Non ha una sua zona di memoria,
ma punta a quello per cui è stata creata. Permette al c++ di essere più veloce.

Overloading egli operatori: per una certa classe si può ridefinire il comportamento degli operatori.

Per il debug fino a una certa riga: ctrl+f10, f11 per procedere step by step
*/