#include "oggetti_in_serie.h"
/*==============================================================================
Crea in memoria dinamica un array di oggetti di tipo un_oggetto contenente
nOggetti elementi (nOggetti, per default, e' impostato su 1). Tutti gli oggetti
nell'array vengono "azzerati".
==============================================================================*/
oggetti_in_serie::oggetti_in_serie( int nOggetti ) {
s = new un_oggetto[nOggetti];
n = nOggetti;
imposta_tutti( 0 );
}
/*==============================================================================
Libera la memoria dinamica abbinata all'oggetto che stiamo distruggendo.
==============================================================================*/
oggetti_in_serie::~oggetti_in_serie() {
delete[] s;
}
/*==============================================================================
Imposta tutti gli oggetti della serie sul valore passato tramite il parametro.
==============================================================================*/
void oggetti_in_serie::imposta_tutti( int valore ) {
for( int i=0; i<n; ++i )
s[i].imposta( valore );
}
/*==============================================================================
Imposta gli oggetti della serie su valori progressivi a partire da quello
specificato tramite il parametro.
==============================================================================*/
void oggetti_in_serie::imposta_in_serie( int inizio ) {
for( int i=0; i<n; ++i )
s[i].imposta( inizio++ );
}
/*==============================================================================
Imposta l'oggetto all'indice specificato sul valore passato tramite il parametro.
Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
metodo non fa nulla.
==============================================================================*/
void oggetti_in_serie::imposta( int indice, int valore ) {
if( indice >= 0 && indice < n )
s[indice].imposta( valore );
}
/*==============================================================================
Richiama il metodo "visualizza" per ciascuno degli oggetti nella serie.
==============================================================================*/
void oggetti_in_serie::visualizza() {
for( int i=0; i<n; ++i )
s[i].visualizza();
}
/*==============================================================================
Richiama il metodo "visualizza" per l'oggetto all'indice specificato.
Se l'indice riguarda un oggetto non compreso entro i limiti della serie, il
metodo non fa nulla.
==============================================================================*/
void oggetti_in_serie::visualizza( int indice ) {
if( indice >= 0 && indice < n )
s[indice].visualizza();
}
/*==============================================================================
Costruttore di copia e operatore di assegnamento sono resi indisponibili da
questi metodi "fantasma".
==============================================================================*/
oggetti_in_serie::oggetti_in_serie(const oggetti_in_serie& other) {
//copy ctor
}
oggetti_in_serie& oggetti_in_serie::operator=(const oggetti_in_serie& rhs) {
if (this == &rhs) return *this; // handle self assignment
//assignment operator
return *this;
}
Però almeno su quello mi oriento a dovere perché è scritto con la chiara intenzione di spiegare le cose.