Help Template C++

[Renxy]

salve a tutti.
devo realizzare una classe con un parametro template.
il tipo template sarà una struttura dati di vario tipo.
come faccio a limitare le possibilità di scelta a un numero limitato di tipi?

le implementazaioni delle funzioni membro della classe che devo realizzare si devono diversificare a seconda del tipo template scelto. come si può realizzare questo?

Thanx

[fek]

Originariamente inviato da Renxy

salve a tutti.
devo realizzare una classe con un parametro template.
il tipo template sarà una struttura dati di vario tipo.
come faccio a limitare le possibilità di scelta a un numero limitato di tipi?

Non puoi in C++.

le implementazaioni delle funzioni membro della classe che devo realizzare si devono diversificare a seconda del tipo template scelto. come si può realizzare questo?

Mi fai un esempio di quello che vuoi fare?

Puoi creare metodi parametrizzati che si basano su un tipo anche diverso da quello con cui parametrizzi la classe. Oppure molto semplicemente scrivi il metodo in termini del tipo parametrico.

Sei sicuro che per risolvere il tuo problema ti devi andare a impelagare con i template in C++? Non e' un argomento banale. Valuta la possibilita' di virtualizzare l'implementazione della tua classe dinamicamente usando il polimorfismo classico.

[Renxy]

Originariamente inviato da fek

Mi fai un esempio di quello che vuoi fare?

Puoi creare metodi parametrizzati che si basano su un tipo anche diverso da quello con cui parametrizzi la classe. Oppure molto semplicemente scrivi il metodo in termini del tipo parametrico.

Sei sicuro che per risolvere il tuo problema ti devi andare a impelagare con i template in C++? Non e' un argomento banale. Valuta la possibilita' di virtualizzare l'implementazione della tua classe dinamicamente usando il polimorfismo classico.

devo usare i tamplate "per contratto", diciamo.
devo realizzare una classe del tipo :

template<class T> class MiaClasse {};
dove T è una struttra dati.
a seconda della struttura dati utilizzata i metodi da esegure sulla MiaClasse devon essere implementati in modi diversi.

[fek]

Originariamente inviato da Renxy

template<class T> class MiaClasse {};
dove T è una struttra dati.
a seconda della struttura dati utilizzata i metodi da esegure sulla MiaClasse devon essere implementati in modi diversi.

Ci sono diverse strategie per fare questo. Fammi un esempio di uno di questi metodi.

[cionci]

Originariamente inviato da Renxy

a seconda della struttura dati utilizzata i metodi da esegure sulla MiaClasse devon essere implementati in modi diversi.

Mi convince poco... Usi un template e poi vai a discriminarne il tipo ?!?!?

[Renxy]

Originariamente inviato da fek

Ci sono diverse strategie per fare questo. Fammi un esempio di uno di questi metodi.

riesumo questo thread.
spiego meglio il mio problema.

devo realizzare una classe c++ che realizzi una struttura dati template "vettore sparso", il parametro template è il tipo dei dati contenuti nel vettore.

esistono diverse possibili implementazioni della struttura : utilizzo di una coppia di std::vector, una coppia di array, un lista, un ABR, una hash table, una std::map.
dovrei rendere possibile l'utilizzo di tutte le implementazioni : l'utente sceglie all'inizio il contenitore e poi deve poterlo usare utilizzando un'interfaccia standard.
es:
sparseVector<int,list> myObj;
myObj.shift();
myObj.scalar(n);

come faccio a realizzare questo, ovvero utilizzar un'interfaccia standard e implementare opportunamente i diversi metodi a seconda della struttura dati scelta?

grazie

[fek]

Originariamente inviato da Renxy

come faccio a realizzare questo, ovvero utilizzar un'interfaccia standard e implementare opportunamente i diversi metodi a seconda della struttura dati scelta?

grazie

Policy-based Design:

In brief, policy-based class design fosters assembling a class with complex behavior out of many little classes (called policies), each of which takes care of only one behavioral or structural aspect. As the name suggests, a policy establishes an interface pertaining to a specific issue. You can implement policies in various ways as long as you respect the policy interface

C'e' una buona descrizione qui:
http://en.wikipedia.org/wiki/Policy-based_design

Questo e' il libro che ti insegna a farlo:
http://www.amazon.com/exec/obidos/AS...593598-4271856

Occhio che non e' banale. C'e' poco di piu' complesso in C++.

[cionci]

Ti realizzi una classe astratta che ti fa da interfaccia con l'utente (che magari contiene già la definizione di alcuni metodi comuni per tutti fli oggetti) e poi derivi da questa classe le varie implementazioni...

Nota che l'utente non dovrà conoscere nemmeno l'esistenza di queste altre classi (leggi non vanno incluse nel programma utente), ma solo della classe astratta... Dopo con un factory method della classe astratta potrai creare i vari oggetti decidendone il tipo...

Tanto per fare un esempio:

SparseVector.h

#include "sparseVectorWithVector.h"
#include "sparseVectorWithArrayPair.h"
#include "sparseVectorWithArrayHashTable.h"

/*questa deve essere una classe astratta che definisci tutta l'interfaccia
delle classi incluse sopra*/
class SparseVector
{
...
...
   /*in base a type decidi quale Sparsevector allocare*/
   static SparseVector * create(SparseVectorType type);
};

SparseVectorWithVector.h

#include "SparseVector.h"

class SparseVectorWithVector: public SparseVector
{
....
};

L'utente dovrà includere solo SparseVector.h

SparseVector sparseVector = SparseVector::create(SparseVectorType::HashTable);

[fek]

La soluzione di cionci va benissimo e ti evita l'uso dei template. Tipico esempio di "Polimorfismo Statico" contro "Polimorfismo Dinamico"

[Renxy]

anche a me andrebbe benissimo. al mio relatore no, purtroppo.

[fek]

Originariamente inviato da Renxy

anche a me andrebbe benissimo. al mio relatore no, purtroppo.

Vuole per forza i template? Ti ha dato la motivazione? Ci sono delle ragioni per preferire il polimorfismo statico a quello dinamico di cionci, ma di solito hanno a che vedere con considerazioni di carattere prestazionale. E non credo che il tuo relatore ti voglia far infrangere uno dei cardini dell'ingegneria del software a cuor leggero...

[Renxy]

mmm.. pensandoci meglio credo che la soluzione di Cionci vada bene.
template deve essere solo il tipo di dati contenuti nel vettore, non il container utilizzato.

[fek]

Originariamente inviato da Renxy

mmm.. pensandoci meglio credo che la soluzione di Cionci vada bene.
template deve essere solo il tipo di dati contenuti nel vettore, non il container utilizzato.

Allora la cosa si complica un po' perche' anche la classe astratta deve essere un template, visto che e' di fatto un contenitore di un tipo generico.

A occhio la soluzione di cionci dovrebbe essere comunque piu' semplice (quando ci sono di mezzo i template mi si attorciglia il cervello).

Mi fai un esempio di operazioni che il contenitore generico deve avere?

[cionci]

Niennte vieta di usare i template per il tipo di dato contenuto nei vettori sparsi...non so, magari è questo che vuole il relatore...

[Renxy]

Originariamente inviato da fek

Mi fai un esempio di operazioni che il contenitore generico deve avere?

servono le operazioni generiche che si usano sui vettori : inserimento, accesso per indice, norma, massimo, minimo, ordinamento etc.

Niennte vieta di usare i template per il tipo di dato contenuto nei vettori sparsi...non so, magari è questo che vuole il relatore...

si, template deve essere il tipo di dato.
comunque anche la classe astratta deve essere template.

[cionci]

Originariamente inviato da Renxy

comunque anche la classe astratta deve essere template.

Certo...e dovrebbe venire fuori un bel lavoretto !!!

[fek]

Originariamente inviato da Renxy

servono le operazioni generiche che si usano sui vettori : inserimento, accesso per indice, norma, massimo, minimo, ordinamento etc.

Ok, quindi diciamo queste tre ad esempio:

insert(T& t);
remove(int index);
sort();

Tiro a caso, per capirci.

Ecco una possibile semplice implementazione policy based:

template <typename T>
class StandardListContainer
{
private:
	std::list<T> m_List;

public:
	void Insert(T item)
	{
		m_List.push_back(item);
	}

	void Remove(T item)
	{
		m_List.remove(item);
	}

	void Sort()
	{
		std::sort(list.begin(), list.end(), std::less<T>());
	}
};

template <typename T>
class NullContainer
{
public:
	void Insert(T item)
	{
	}

	void Remove(T item)
	{
	}

	void Sort()
	{
	}
};

template<typename T, typename ContainerPolicy = StandardListContainer<T> > class SparseVector
{
private:

	ContainerPolicy m_Container;

public:

	SparseVector()
	{
		// Insert some items just for fun...
		m_Container.Insert(T());
	}

	~SparseVector()
	{
		// Remove an item just to try the policy...
		m_Container.Remove(T());
	}

	void Process()
	{
		// Do crazy stuff here...

		m_Container.Sort();

		// Do some more crazy stuff here...
	}
};

Nota come puoi creare classi SparseVector che usino uno o l'altro container che specifichi quando instanzi il template:

SparseVector<int> sparseVectorInt;
SparseVector<int, NullContainer<int> > nullSparseVector;

Di default usi il container basato su std::list. Il Container deve solo onorare l'interfaccia imposta implicitamente da SparseVector e questa e' la parte piu' rognosa in C++ perche' non ti concede nessuno strumento esplicito per gestirla.

[cionci]

Ottimo, così è ancora meglio !!!

[fek]

Originariamente inviato da cionci

Ottimo, così è ancora meglio !!!

In realta' se fosse possibile preferirei la tua soluzione, perche' e' piu' semplice da gestire. Quando inizia a dare errori di instanziazione di template mi va in pappa il cervello.