[C++]Passaggio di array di struct a classe

[flammer]

Salve gente.
Sto progettando un software di gestione per biblioteca come esercizio.
Mi è stato chiesto d progettare la classe biblioteca che contenga un array di struct Infovolume (la quale contiene al suo interno un campo per il nome, uno per il quantitativo e uno per il codicie ISBN). La dimensione di questo array deve essere variabile.
Io ho pensato di creare un construttore con pasaggio di intero in modo da far variare la dimensione dell'array.
Il problema è che non riesco bene a capire come passare l'array di struct Infovolume. Cioè non riesco a capire se bisogna passarlo ad ogni funzione della classe (come ad esempio una funzione Prestito o una funzione disponibilità o una per aggiungere volumi ecc).
Se bisogna passarlo, come fare?
Io ho buttato giù un codice e l'ho testato con il risultato che ho scoperto che non viene aggiornato l'array e nemmeno avviene una corretta inizializzazione.
Vi sarei grati se qualcuno di voi possa passarmi qualche suggerimento.
Grazie mille.

[tomminno]

Salve gente.
Sto progettando un software di gestione per biblioteca come esercizio.
Mi è stato chiesto d progettare la classe biblioteca che contenga un array di struct Infovolume (la quale contiene al suo interno un campo per il nome, uno per il quantitativo e uno per il codicie ISBN). La dimensione di questo array deve essere variabile.
Io ho pensato di creare un construttore con pasaggio di intero in modo da far variare la dimensione dell'array.
Il problema è che non riesco bene a capire come passare l'array di struct Infovolume. Cioè non riesco a capire se bisogna passarlo ad ogni funzione della classe (come ad esempio una funzione Prestito o una funzione disponibilità o una per aggiungere volumi ecc).
Se bisogna passarlo, come fare?
Io ho buttato giù un codice e l'ho testato con il risultato che ho scoperto che non viene aggiornato l'array e nemmeno avviene una corretta inizializzazione.
Vi sarei grati se qualcuno di voi possa passarmi qualche suggerimento.
Grazie mille.

Se stiamo parlando di C++ e hai bisogno di array variabili perchè non un bel vector?


#include <vector>

class Library
{

public:
Library(const std::vector<InfoVolume> & books) : librarybooks(books)
{}
void AddBook(const InfoVolume & newBook)
{librarybooks.push_back(newBook);}
protected:
std::vector<InfoVolume> librarybooks;
};

[flammer]

Grazie Tomminno.
Purtroppo la traccia dell'esercizio mi chiede espressamente di passare un array e al più come suggerimento mi dice che è possibile creare la classe biblioteca come template e passare la dimensione dell'array come paramentro.
Solo che non ho ben capito come fare.
Grazie ancora comunque :)

[tomminno]

Grazie Tomminno.
Purtroppo la traccia dell'esercizio mi chiede espressamente di passare un array e al più come suggerimento mi dice che è possibile creare la classe biblioteca come template e passare la dimensione dell'array come paramentro.
Solo che non ho ben capito come fare.
Grazie ancora comunque :)

Si potrebbe obiettare che vector è un array ;)
Beh questo è un esercizio di C con le classi non di C++.
Se devi usare per forza un array ridimensionabile (e non c'è nessun motivo valido per usare tale struttura dati in C++), la strada più veloce è usare realloc, ma realloc implica che non puoi usare new come allocatore ma malloc.
Altrimenti bisogna fare tutte le volte delle copie dell'array per spostarlo in uno più grande (esattamente quello che fa vector), ovvero abbiamo bisogno di una classe che fa quello che fa vector!
Infatti programmando ad oggetti dovresti avere una classe Array per la gestione di tutte le problematiche riguardo alla gestione dell'array:


template <class T> class Array
{
public:
Array(int size) : maxSize(size), currentSize(0)
{
data = new T[maxSize];
}
Array(T* data, int size) : maxSize(size<<1), currentSize(size)
{
this->data = new T[maxSize];
memcpy(this->data, data, currentSize * sizeof(T));
}
~Array()
{
delete [] data;
}
void Add(const T & newData)
{
if (currentSize >= maxSize)
IncreaseSize();
data[currentSize++] = newData;
}
int Size() const { return currentSize; }
int MaxSize() const { return maxSize; }
operator T*() { return data; }
private:
void IncreaseSize()
{
maxSize = maxSize<<1;
T * newData = new T[maxSize];
memcpy(newData, data, currentSize * sizeof(T));
delete [] data;
data = newData;
}
protected:
int currentSize;
int maxSize;
T*data;
};


A questo punto nella classe Library avrai qualcosa del tipo:


class Library
{
public:
Library(VolumeInfo * books, int size) : books(books, size)
{}
void AddBook(const VolumeInfo & book)
{
books.Add(book);
}
private:
Array<VolumeInfo> books;
};


Ma mi sembra veramente tanto lavoro sprecato, anche perchè Array è una classe abbastanza minimale, andrebbero aggiunti controlli sui valori passati, funzioni per la rimozione di elementi ecc...