Newsgroup: it.comp.lang.c++
Titolo: vector<> e copia

Ho utilizzato per la mia classe matrix, la classe vector<> sperando che
gestisse la copia con "intelligenza". Credo che il metodo si chiami
deep-copy ma non sono sicuro: quando copio un  oggetto ( vector
in questo caso ), non copio i dati ma solo l'istanza della classe + un
riferimento all'array; la copia fisica dei dati avviene se e solo quando 
devono essere modificati.
Purtroppo negli header che ho a disposizione ( egcs-c++ 1.1.2 / egcs-2.91.66
19990314/Linux (egcs-1.1.2 release) ) non fanno cio' : ad ogni copia degli
oggetti tutti i dati vengono copiati. Ci sono implementazioni piu'
"intelligenti" ? oppure classi di altro tipo che si comportino come vector e
che siano sempre "intelligenti" ?
Sto notando adesso la classe string, che sembra fare al caso mio. Ma non
vorrei sparare con un cannone addosso alle mosche ( la class string
implementa molte funzioni che a me NON servono ). 

"Goffredo Baroncelli" <gh...@sphera.bhome> ha scritto nel messaggio
news:slrn8setsf...@sphera.bhome...

C'è la classe valarray adibita al calcolo numerico
(anche se non so se faccia quello che vuoi).
Comunque per qualcosa di meglio prova a cercare librerie
specifiche in rete (ad esempio Blitz++).
Manlio Perillo

 string implementa molte funzioni che a me NON servono ).
Le funzioni che non ti servono non le usi. Qual è il problema?
Max

Le funzioni che non ti servono non le usi. Qual č il problema?
 ho provato al volo un
base_string<int>
ma mi ha dato troppi errori; ora mi studiero con calma i sorgenti.
grazie per le info

implementa molte funzioni che a me NON servono ). 
std::string si comporta come std::vector, niente reference counting.
Per quanto riguarda sparare alle mosche con il cannone, non vedo
quale sia il problema, se usando std::string risolvi bene il problema
vuol dire che e` una classe valida allo scopo. Poi quello che non usi
un buon linker lo butta via o quanto meno un buon s.o. non lo carica
in memoria!
Paolo
-------------------------------------------
  Paolo Marotta
 
http://web.tiscalinet.it/paolo_marotta/
-------------------------------------------


Comunque, č vero che lo standard non impone l'uso di
reference-counting/copy-on-write per std::string, ma non lo vieta nemmeno
(credo) e le librerie standard distribuite con due dei piů famosi
compilatori adottano questa tecnica nell'implementazione di std::string.
Max

std::string si comporta come std::vector, niente reference counting.
Lo standard non dice nulla sul ref-count, e' una scelta progettuale di
chi scrive la libreria standard. Senza ref-count si evitano problemi
in un programma multithread (e chi non usa i thread? o cerca un'altra
implementazione o spera che sia altrettanto veloce come una
ref-count).
-- 
 (o-  | Un OS per domarli, Un OS per trovarli,
 //\  | Un OS per ghermirli e nel buio incatenarli
 V_/_ | 
http://pinguin.linuxave.net
            r punto salmaso at inwind punto it

implementa molte funzioni che a me NON servono ). 
Quel che non usi, non lo paghi (almeno non su visualc++). Se fa quello
che ti serve, non pensarci due volte ad usarla. Altrimenti... Sai
programmare ^_^


 ma mi ha dato troppi errori; ora mi studiero con calma i sorgenti.
intanto e' basic_string<>; in secondo luogo difficilmente riuscirai ad
utilizzarla cosi'. basic_string e' un template solo per poter gestire
tipi di caratteri diversi, ma si aspetta comunque che l'argomento sia un
tipo di carattere.
Ciao,
Nicola


Non è sufficiente che esista un implementazione funzionante di  
char_traits<int>?
Con la versione che ho della libreria standard del gcc, che ha un
implementazione generica di char_traits<> (che in realtà si chiama
string_char_traits<>), basic_string<int> funziona egregiamente.
Max

Puo' darsi. Mi lascia un po' perplesso l'idea di stravolgere il senso
della classe sottostante.
Mi sembra un ennesimo esempio di un atteggiamento piuttosto diffuso tra
i partecipanti di questo newsgroup, specie alcuni che hanno cominciato a
postare da poco, ovvero la tendenza a cercare di stravolgere per i
propri scopi la prima classe trovata, piuttosto che imparare a fondo il
linguaggio e la sua filosofia, e da questi elementi derivare la migliore
soluzione per i propri problemi.
Lo trovo un atteggiamento piuttosto controproducente sulla lunga
distanza, specie di fronte ad un linguaggio articolato e complesso come
il C++.
Ciao,
Nicola

della classe sottostante.
Perche' dovrebbe avere piu' senso
String<wchar> 
di
String<int>
o di 
String<double> 
?
Comunque si tratta di una "collezione" di oggetti...
Non credo di aver stravolto niente. Anzi mi sembra molto piu' giusto
riutilizzare un oggetto che qualcuno ha gia' studiato, debuggato ed
ottimizzato piuttoche che ogni volta riscoprire l'acqua calda.
Ed ora la domandona da 1M$
Ma perche' lo Standard si preuccupa tanto dei programmi multithread ?
Mi sembrerebbe  non meno importate una copy-on-write+ref-count che
ottimizzerebbe tutti quei casi in cui si passano collezzioni di oggetti per
valore ( esempio
MATRICE t1(10,5);
MATRICE t2(5,20);
MATRICE operator *( const MATRICE &t1, const MATRICE &t2 ){
	MATRICE t3(t1.row,t2.col);
	moltiplica( t1,t2,t3 );
	return t3;
}
Come ottimizzereste questo operatore senza ricorre a
copy-on-write/ref-count ?
)
 

 copy-on-write/ref-count ?
Esistono delle tecniche incredibilmente piu' sofisticate, basate sui
template.
Ciao,
Nicola


Vedi ad esempio la libreria Blitz++.
Manlio Perillo


 ha scritto:

Maggiori info su queste "tecniche incredibilmente piu' sofisticate" ? 
( anche perche' blitz _implementa_ la copy-on-write/ref-count )

template.
maggiori info ?

 preblemi con i programmi multithread !
Se ti riferisci a quello che ho detto io su thread, std::vector, e
std::string, credo tu abbia frainteso.
Io dissi due cose:
1. Lo standard non consente l'uso di copy-on-write/ref-count
nell'implementazione di vector<>. E questo non ha che vedere con i thread,
ma con fatto che la copia di un vettore di oggetti deve tradursi
nell'immediata creazione di nuovi oggetti.
2. L'STL (che *non* è la Libreria Standard del C++!, ma una libreria di
SGI che tra le altre cose implementa porzioni della Libreria Standard) ha
scelto di non adottare copy-on-write/ref-count per la propria
implementazione di std::string. Questo ha a che vedere con i thread, ma
non con le specifiche dello standard, che su questo punto non pone
restrizioni. Infatti le librerie standard distribuite con gcc e MSVC usaro
tranquillamente copy-on-write/ref-count nell'implementazione di
std::string.
Max

 std::string.
Aggiungo che, a giudicare dai sorgenti, la versione di std::string della
liberia Rogue-Wave permette di scegliere a compile time se usare
copy-on-write o meno.
Ciao,
Nicola

 maggiori info ?
In questo momento non trovo un riferimento. Sostanzialmente si tratta di
utilizzare template per rappresentare da una parte matrici con
caratteristiche particolari (ad es. triangolari, sparse, ecc.) e
dall'altra la composizione di operazioni su matrici in modo che la
codifica di operazioni complesse sulle matrici stesse non comporti la
loro computazione, quanto il calcolo di una rappresentazione esplicita,
utilizzata per calcolare a richiesta solo quelle parti della matrice
risultato che vengono utilizzate/riferite.
Quando trovo un link te lo posto.
Ciao,
Nicola

 ( anche perche' blitz _implementa_ la copy-on-write/ref-count )
Se intendi le tecniche che si basano sui template, alla home page
della libreria Blitz++ ci sono dei link a dei documenti a riguardo.
Le tecniche sono chiamate "Expression template" e
"Template metaprogramming"
Manlio Perillo

2. L'STL (che *non* è la Libreria Standard del C++!, ma una libreria di
Ok, ora ho capito