Newsgroup: it.comp.lang.c++
Titolo: Allocazione dinamica di CString

non riesco a capire dove sbaglio.
 Le seguenti  linee di codice per me sono corrette:
(VC6 SP4 - windows2000 - .exe MFC)
int *pippo;
pippo= new int[10];
...
delete pippo;
ed infatti funzionano. Se invece provo queste
CString *pippo;
pippo= new CString[10];
...
delete pippo;
funzionano ugualmente, ma questa volta ho un errore a runtime sul delete...
aiuto!
grazie, ciao
Nico

 non riesco a capire dove sbaglio.
Nell'usare new e delete di array.  std::vector<> esiste apposta
e non c'e` proprio nessuna ragione di volersi rendere la vita
difficile, cavolo!
Ma ***PERCHE`***, a giudicare dai post su questo gruppo, mezzo
mondo s'incapponisce a usare costrutti di bassissimo livello,
senza averne piena padronanza ne` ragionevole necessita`, quando
esistono costrutti comodi, veloci, sicuri, e facili da usare?!
Fai:
    #include <vector>
    typedef std::vector<CString> sv_t;
    sv_t pippo;
    pippo = sv_t(10);
e potrai poi usare pippo[0], ..., pippo[9] proprio come se
ti fossi incapponito con il new[], e senza errori in chiusura
(la cancellazione sara` automatica al distruttore di pippo).
Se proprio te l'ha ordinato il dottore di renderti la vita
difficile a tutti i costi, almeno fai "delete[] pippo" al
momento di cancellarlo.  Le quadre "[]" sono necessarie a
norma di standard per distinguere la distruzione di un
array da quella di uno scalare (che causalmente le cose ti
paiano funzionare quando il tipo degli elementi e` un POD,
poco c'entra: potresti avere problemi anche su quelli,
benche` sia meno probabile nella pratica).  Ma non c'e`
proprio nessuna ragione di non usare invece std::vector!
Alex

funzionano ugualmente, ma questa volta ho un errore a runtime sul delete...
Il funzionamento e` solo apparente, in realta` non funziona proprio
perche` il distruttore di CString e` invocato solo per il primo elemento
dell'array.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------


Perche' non fai direttamente
sv_t pippo(10);  o sv_t pippo = sv_t(10);
ed invece costruisci il vettore vuoto e poi usi il copy constructor da un
oggetto temporaneo?

 oggetto temporaneo?
Non un copy constructor ma un'operazione di assegnazione; il
copy constructor e` invece usato (concettualmente) nella forma
    sv_t pippo = sv_t(10);
che tu proponi.
La forma migliore per "costruire" un sv_t con un numero di
elementi (tutti a valore di default) determinato solo "a
valle" della sua costruzione e`, probabilmente,
    pippo.resize(10);
Comunque, anche tutte le altre forme usate (eccetto quella
che usa un ipotetico e inesistente costruttore _implicito_
da intero) sono OK.
Alex




 delete pippo;
fai delete []pippo;
Il compilatore non puo' sapere se un puntatore e' un puntatore ad un oggetto
oppure la base di un vettore di oggetti. Scrivendo delete [] gli dici: "senti
bello, questo e' un vettore di oggetti. Siccome te l'ho allocato come vettore,
tu ti sei messo da parte il numero degli elementi e pertanto adesso chiama il
distruttore per ogni elemento e quindi libera la memoria.".
Una nota polemica: vector<> serve e serve anche sapere come funzionano i
costrutti "a basso livello", quindi ritengo piu' costruttivo spiegare le cose,
mostrando poi anche l'alternativa piu' comoda (che tra l'altro e'
vector<string>...)
Ciao!!!

da intero) sono OK.
Incidentalmente la prima delle forme e' a norma di standard
(non lo sarebbe se fosse "sv_t pippo=10;")
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff


wrote:


 Grazie per l'aiuto, un pò meno per l'atteggiamento... :-(
Prego.  Se questo scambio "di chiarimento" puo` scoraggiare altri
da ripostare ANCORA le stesse domande,  e/o incoraggiare qualcuno
a seguire la netiquette, il beneficio netto per la "qualita` della vita"
sulla rete sara` pero` maggiore in conseguenza dell'"atteggiamento"
che tu deplori, che non in conseguenza dello specifico "aiuto" tecnico
che apprezzi.
Meno di un anno fa, quando stavo giusto scoprendo Python, postavo
su comp.lang.python un tot di richieste del tipo "come posso fare
questa esatta astrusita` visto che sembra possibile solo quest'altra
simile ma non identica?".  Ho ricevuto un tot di risposte su come fare
X, o perche` non si puo` fare Y, e un tot di sommessi e amichevoli
consigli sul "ma non fare queste stranezze, stai sul semplice"; ma
solo quando uno di questi thread e` sfociato in una vera e propria
flamewar con "Tim-bot", sono rimasto abbastanza scosso da dover
riprendere in considerazione l'intero meta-problema e convincermi
che, affascinato dalla novita` e dalla potenza del linguaggio, mi ero
quasi scordato la Prima Direttiva, *FAI LA COSA PIU` SEMPLICE
CHE POSSA FUNZIONARE*.  In questo senso, quella reciproca
sfuriata mi e` stata piu` utile di mille raffinati e astrusi dettagli sulla
manipolazione degli scope in condizioni di eredita` multipla entro
una __setattr__.  Oggi so da dove iniziare l'esplorazione se mai
una simile astrusita` mi serve, ma, cosa piu` importante, so bene
che *NON* mi serve 997 volte su 998; la mia produttivita` ha avuto
molto di piu` da guadagnare da questo episodio, dal rafforzamento
intenso del *RESTA SUL SEMPLICE*, che non dall'apprendimento
degli infiniti possibili dettagli della complessita`.
Posso solo augurare ai lettori di questo gruppo effetti altrettanto
positivi se e quando si troveranno in flamewar analoghe.
Alex

 In realtà la cosa più comoda è il CStringArray...
E che roba è?
EMG

The CStringArray class supports arrays of CString objects. 
The member functions of CStringArray are similar to the member
functions of class CObArray. Because of this similarity, you can use
the CObArray reference documentation for member function specifics.
Wherever you see a CObject pointer as a return value, substitute a
CString (not a CString pointer). Wherever you see a CObject pointer as
a function parameter, substitute a LPCTSTR.
...
...
...
Luc


Scusa, ma ti ha morso una tarantola, o cosa?
Se tu seguissi il NG da tempo capiresti...
Il punto e` che a meno non si sia obbligati a fare diversamente
(un esercizio sui puntatori ad esempio), non c'e` motivo di riscoprire
l'acqua calda. I contenitori che offre la libreria standard sono molto
validi e difficilmente si puo` riuscire a fare meglio.


 The CStringArray class supports arrays of CString objects.
Ovviamente il mio "E che roba è?" era ironicamente riferito al fatto che
mi pare assurdo utilizzare una cosa non standard quando lo stesso si può
fare benissimo (credo meglio) con la libreria e il C++ standard.
EMG

 lo accetta, ma non dovrebbe.
Mi sa che per una volta hai fatto una svista!!!
Io ho scritto:
sv_t pippo(10);
che chiama semplicemente il costruttore che accetta un unico parametro int.
Il fatto che sia dichiarato explicit mi impedisce semplicemente di fare:
sv_t pippo = 10;
ma questo ovviamento tu lo sapevi già.
Vorrei però, se possibile che mi chiarissi un dubbio:
quando io faccio:
sv_t pippo = sv_t(10);
se non ho capito male dovrebbe essere equivalente secondo lo standard a
sv_t pippo(10);
in quanto non viene creato l'oggetto temporaneo e non viene nemmeno chiamato il
costruttore di copia, giusto?
Se è giusto, cosa succede se io dichiaro un copy constructor strano che non fa
una copia corretta tipo:
class A
{
    int privato;
    public:
    A(int valore)
    : privato(valore){}
    A(const A& obj)
    {
        privato = obj.privato * 2;
    }
};
ora questa chiaramente è una follia, ma a norma di standard, cosa dovrebbe
succedere quando scrivo:
A oggetto = A(5); ?
Grazie, FBF.

 costruttore di copia, giusto?
No: il costruttore di copia *deve* essere accessibile (e accettare una
_const_ reference) per usare la prima delle due forme.  Se lo e`, di
certo tutti i compilatori di questo mondo ottimizzeranno non chiamandolo
(e questa ottimizzazione possono sempre farla, anche se il copy ctor
avrebbe eventuali effetti collaterali: questo e` esplicitamente previsto
dallo standard).  Ma se non lo e`, il compilatore DEVE dare errore.
Alex

 wrote:


 e più rapidi da utilizzare.
Le classi di presentazione (UI), essendo comunque dipendenti dal
framework specifico, puoi probabilmente scriverle anche nei termini
dei contenitori antiquati (e sostanzialmente deprecati) del framework
stesso.  Ma anche qui, bisogna distinguere.  Dai un occhio ai possibili
framework di migrazione e vedrai che un qualche supporto per
CString ci puo` anche essere: ad esempio, in WTL c'e`.  E` anche
giusto, tutto sommato: si tratta di una classe-stringa con obbiettivi di
progetto assai diversi da quelli di std::string -- quest'ultima e` fatta
per essere leggera, altamente performante, se mai con funzioni piu`
limitate (niente .Format, niente conversioni a/da Unicode, ecc ecc),
mentre CString sacrifica le prestazioni alla ricchezza funzionale.
CStringArray, invece, "col cavolo" che lo trovi (se non nel piu` vecchio
e polveroso codice scritto solo per MFC...).  Esso non presenta NESSUN
vantaggio rispetto a std::vector<CString>, e quelli della Microsoft non
sono scemi: mantengono CStringArray per compatibilita` con il passato,
ma nel codice nuovo consigliano invece di usare i contenitori standard
(specificamente std::vector).  Vai a qualunque conferenza tecnica dove
si parli di VC++ e MFC, e vedrai: su CString, polemiche pro e contro;
su std::vector<>, unanimita` di consensi.
E nelle classi di modello, quelle che non dovrebbero dipendere dal
framework e dalla presentazione, inserire dipendenze dal framework
sarebbe solo assurdo.
Alex

 wrote in message
news:311ims46obnflqqt5...@4ax.com...


 e più rapidi da utilizzare.
Dagli esempi che hai fatto sembravano molto simili. Però se non hai
tempo da perdere per la libreria standard del C++ forse hai sbagliato
linguaggio.
EMG

EMG
Luc.

 nonostante il carattere di qualcuno, questo è un'ottimo newgroup :-)
Se non sai neppure la differenza fra "mail" e "post", o non puoi darti
la briga di essere preciso nell'uso dei termini tecnici, non sei proprio
qualificato a valutare la qualita` di un newsgroup tecnico.
Alex

 che io ti abbia spedito mail mentre non l'ho fatto?
[...]
Ok, era un post, i'm sorry.
Chiedo scusa per il casotto prodotto e la possibile incazzatura arrecata.
Credo che il mio primo reply (si dice così per i newsgroup? ho ormai paura
dei termini...). ripensandoci dopo un pò, per casini miei, non ero
estremamente tranquillo e rilassato.
Dalle varie risposte che hai dato ai miei post, temo di aver prodotto un
casino molto più grosso del new[] su cui avevo richiesto supporto.
Probabilmente in un altro momento lo stesso post non mi avrebbe dato alcun
fastidio ma ciò purtroppo non è stato ed in quel momento ho avuto l'impulso
di rispondere... il resto lo conosci almeno quanto me...
Adesso cerco di spiegare cosa (dal mio punto di vista, ovviamente...) ho
avvertito in quel post: il motivo per cui mi sono sentito "offeso" (bada,
non che mi avessi mai chiamato "brutto pirla", intendiamoci...) è stato
causato dall'impeto, dalla foga, che trasmetteva la tua risposta.
Una frase del tipo "e non c'e` proprio nessuna ragione di volersi rendere la
vita
difficile, cavolo!" suonava un riprovero per un mio errore, da una persona
che non aveva sufficienti informazioni al contorno per poter giudicare quale
fosse stata la causa del mio problema e/o del mio operato.
Anche la frase "Ma ***PERCHE`***, a giudicare dai post su questo gruppo,
mezzo mondo s'incapponisce a usare costrutti di bassissimo livello, senza
averne piena padronanza ne` ragionevole necessita`" concorderai con me che,
siccome io, di diritto, sono rientrato in quel mezzo mondo, ancora mi senta
giudicato da una persona che, consentimi ancora, non sa niente di me, e non
dovrebbe (anche questa opinione personalissima, e biasimabile) sparare a zer
o sul primo sconosciuto che passa da queste parti per un oggettivo problema.
Anche la frase "Se proprio te l'ha ordinato il dottore di renderti la vita
difficile..." giusto un pizzico di polemica ce l'aveva, o almeno io l'ho
avvertita (chiedo scusa se ho dei problemi a riguardo, ma mi sono ancora
sentito colpito, abbastanza ingiustamente).
Passiamo alle attenuanti generiche: dal tuo post successivo hai detto
(ancora giustamente) che esitono le FAQ, e che se avessi letto quelle prima
di postare, probabilmente non avrei havrei commesso l'errore di chiedere stà
cazzata. Suppongo, quindi che quell'impeto piovutomi addosso al tuo primo
post, sia stato causato più dall'errore "cavolo, eccone un'altro che non sa
usare il newsgroup e rompe con le solite domandine" che da "ma che massa di
ignoranti esistono a questo mondo ma perchè non vanno a zappare invece di
programmare in C++".
Molto probabilmente, anzi sicuramente, tu non hai pensato nessuna delle due
cose che ho scritto quì in alto, ma purtroppo (e questo è un mio problema,
ancora) l'impeto del primo post (almeno a me) trasmetteva una tua
insofferenza verso il sottoscritto ed il problema da egli esposto, comunque
non giustificabile, o quantomeno non giustificabile dall'innocenza della
richiesta di aiuto fatta.
Spero, in tutta onestà, di non aver peggiorato ancora la situazione.
Onestamente, non avevo ed ho davvero nulla contro di te, anzi mi hai aiutato
e te ne sono grato. Non ti conosco e non so abbastanza di te per poterti
giudicare, quindi spero con questo mio, almeno di chiarire la mia posizione.
Sul contenuto dei tuoi successivi post, preferisco sorvolare, se non ti
dispiace.
Ancora, questa è una questione, che per me non ha senso di esistere, e spero
che dopo questo mio, tu concorda con me.


 Chiedo scusa per il casotto prodotto e la possibile incazzatura arrecata.
Complimenti, sei uno dei pochissimi che sa ammettere di aver sbagliato.
Questo ti fa altamente onore.
EMG

 programmare in C++".
Hmmm... non esattamente.  "Un altro che fa le solite domandine" non e`
un _grosso_ problema, e non e` un problema *per nulla* se la risposta
alle domandine non e` nelle FAQ (perche` allora "e` colpa nostra", che
non abbiamo messo nelle FAQ qualcosa che ci va aggiunto!).  Se mai il
problema del gruppo sono i post OT (off topic), di solito relativi a
temi specifici di particolari piattaforme e non al C++ standard; e il
tuo *non* era OT, essendo del tutto relativo al C++ standard.  E cerco
sempre di essere cortese, quando segnalo ai frequentissimi autori di
post OT che *qui rompono i c...* (non uso questa espressione:-); se mai
mi scateno come una belva se qualcuno trova qualcosa da ridire contro
questi cortesi avvertimenti:-).
No, la vera causa dell'impeto era la specifica "issue" tecnica: uso
di new[] e delete[] (o malloc e free, ecc) invece dei contenitori della
libreria standard C++.  E` uno dei temi su cui, convintissimo che i
piatti della bilancia non sono equilibrati, non trattengo la veemenza
che mi sgorga spontanea.  Essendomelo trovato davanti un numero di
volte persino piu` alto del solito (che e` tutto dire) negli ultimi
10-15 giorni sul newsgroup, ero poi ipersensibilizzato in materia.
Quanto alla tua ipotesi, dopo "che da", non ho mai fatto mistero che,
secondo me, si programma troppo il C++ rispetto a quel che non si
farebbe in un mondo di scelte ingegneristiche ottimali.  E` il
linguaggio piu` complesso, piu` ricco, piu` difficile da usare e
quasi impossibile da padroneggiare; anche chi lo padroneggia
(diciamo oltre il 90%, tipo me) ha incrementi di produttivita`
(per la stragrande maggioranza dei problemi) sostanziali anche
passando a linguaggi *appena* piu` semplici (tipo Java), enormi
passando a linguaggi veramente ottimali (tipo Python); diciamo
un 10-20% in un caso, 80-100% nell'altro.  I guadagni sono poi
maggiori per quella enorme maggioranza dei programmatori C++ che
non padroneggia il linguaggio (e relative librerie standard)
neppure al 90%.  Naturalmente, questa situazione che percepisco
urta la mia pulsione all'ottimalita` ingegneristica.  Non si
tratta certo di "andare a zappare", bensi` di scrivere programmi
piu` completi, migliori, e in meno tempo (quindi meno cari),
anche se probabilmente un poco piu` lenti (nulla batte il C++
dal punto di vista delle prestazioni).
Ma questo non ha nulla a che vedere col mio impeto.  Non e`
una questione che "mi attizzi" (eccetto al piu` quando qualche
cattivo consigliere spinge un *principiante* di programmazione
a *cominciare* col C++, o peggio ancora il C o l'assembler:
questa mi colpisce a volte come "circonvenzione d'incapace"!-).
E neppure ha molto a che vedere con l'uso dei contenitori delle
librerie standard (che al contrario *riduce* il "problema", da
me percepito, di "troppo uso del C++, di cui molto a capocchia",
poiche` migliora la qualita` del codice prodotto e aumenta di
molto le prestazioni).
Alex

Complimenti. Al di la' dell'oggetto del contendere e delle tue
specifiche scuse, ho trovato il tuo messaggio abbastanza straordinario.
La posta elettronica ed i suoi affini sono degli strumenti di
comunicazione un po' particolari: sebbene il fatto di scrivere invece di
parlare dovrebbe spingere a maggior riflessivita', quello che succede di
solito e' che la distanza tra gli interlocutori porta a perdere i freni
inibitori, ad agitarsi piu' del ragionevole ed a esprimersi con molta
maggior violenza verbale di quanto si farebbe trovandosi di fronte:
molti scambi sui newsgroup finirebbero a cazzotti se avvenissero con lo
stesso tono trovandosi l'uno di fronte all'altro.
Per questo mi pare molto importante riuscire ad assumere un
atteggiamento come il tuo, di calma analisi dei messaggi che si sono
ricevuti e di esplicita puntualizzazione degli elementi che non si sono
graditi.
Tanto di cappello!
Ciao,
Nicola

 
Ok, tu hai ragione. Ma per motivi <didattici> secondo me è utile fare 
cose del genere, per capire i meccanismi di base. Per me è stato utile. 
In fondo, se tu conosci questi costrutti di basso livello, devi aver 
provato, giusto? E lasciamo provare pure gli altri! Non ti pare?
Tuttavia il tuo consiglio è validissimo, lo darei anch'io; ribadisco che 
si dovrebbe considerare l'eventualità che la persona che fa domande di 
questo tipo sta cercando di capire qualcosa che al momento gli sfugge, e 
suggerirgli il vector<int> (per fare un esempio) non lo aiuta poi tanto!
Sul fatto che richieste simili sono già state fatte e che si potrebbe 
dare un'occhiata indietro prima di riproporle, sono completamente 
d'accordo.
Ciao
  Giovanni

 
si dice follow-up, ma che resti tra noi, non vorrei scatenare polemiche! 
:D

 d'accordo.
Comunque, dovrebbero essere nelle FAQ; se non ci sono, penso che
dovremmo rimediare.  Se ci sono, si puo` almeno insistere che le
FAQ vengano lette prima di postare qui una domanda.
Alex

 
mah! sinceramente non so se č cosě... sono punti di vista. D'altra parte, 
volendo partire da zero, e volendo creare subito applicazioni, non posso 
perň dire altro che č meglio usare le librerie.
ciao!

 perň dire altro che č meglio usare le librerie.
Si`, ma anche se l'obbiettivo non e` fare subito "vere"
applicazioni, ma intanto capire bene come funzionano le
cose, secondo me resta meglio capirlo prima ad ALTO livello,
cioe` con buona astrazione, e poi, se mai, vedere cosa in
concreto c'e` sotto.  Come non occorre capire bene la
fisica quantistica per usare le CPU che ne sfruttano vari
aspetti, cosi` non occorre capire bene la memoria dinamica
'nuda e cruda' per usare i contenitori che sono implementati,
internamente, in termini di essa.
Alex

 problemi anche senza tanto estremismo:-).
tu stai motivando le tue idee, che comunque sono condivisibili. 
Probabilmente il metodo migliore sta nel mezzo... tipo "è utile sapere 
come si gestisce la memoria dinamica, ma uso i container STL perchè è 
molto + comodo e sicuro, e probabilmente + veloce di qualsiasi 
implementazione fatta da una singola persona)

 implementazione fatta da una singola persona)
Si`, con rare eccezioni basate su conoscenze specifiche di
dominio (che comunque riguardano tipicamente contenitori
piu` ricchi: anche implementazioni special-purpose di tali
funzionalita` possono normalmente appoggiarsi in modo del
tutto ottimale su vector/list/deque...).
Alex


Scusa l'ignoranza ma cosa sono ATL, WTL e WFC?
Conosco solo le MFC 'di vista' e da quello che ho letto non sono
un granchè dal punto di vista della OOP e nell'uso della libreria standard del C++
(vedi CString al posto di std::string).
Come sono messi questi altri framework?
Manlio Perillo

 (vedi CString al posto di std::string).
Certo, MFC e` stata sviluppata molto prima dello standard C++, e quindi,
ovviamente, senza usare le innovazioni che attorno allo standard sono nate.
(In effetti si impernia sull'eredita` singola, perche`, quando e` nata,
altro non
c'era...).
ATL si impernia invece sull'eredita` multipla, piu` che altro di template
che
corrispondono alla pattern che Coplien ha chiamato "the Pattern Without
a Name" o anche "A Curiously Recurring Template Pattern" e al giorno
d'oggi viene chiamata abitualmente PWAN.  L'enfasi di ATL e`, senza
compromessi, sulle prestazioni "a tavoletta" nello sviluppo di componenti
COM, specialmente in termini di dimensione del codice prodotto (cio`
ha anche piacevoli ricadute sulla velocita`, grazie a come funzionano le
cache, la memoria virtuale, ecc ecc; ma la vera motivazione sono i casi
di componenti COM destinati a "viaggiare" come codice binario in rete).
Considero l'architettura di ATL estremamente interessante come esempio
di cosa si puo` fare coi template, e come; sullo stesso livello di Blitz++,
che pero` fanno tutt'altre cose.  E` interessante da studiare anche per chi
non abbia interessi di COM o di Windows, solo come campionario di
tecniche degne di nota; e` per questo che ti sto rispondendo qui invece
che su it.comp.programmare.win32 (dove comunque ti consiglio di
spostare la discussione se ti interessa perseguirla su aspetti specifici
di Windows).
WTL e` un'estensione di ATL per costruire vere e proprie applicazioni
Windows, non solo componenti.  Pero` in questo caso l'enfasi totale ed
assoluta sulle prestazioni-massime-a-ogni-costo sembra sprecata.  In
ogni caso, CString e` deliberatamente stata aggiunta (anche se non se
ne sentiva il bisogno, potendo usare le stringhe standard) perche` pare
che fosse la ragione numero uno per cui i programmatori non migravano
da MFC ad ATL.  Comunque, MS non considera WTL come "strategico":
e` parte del Platform SDK liberamente scaricabile, ma non e` un prodotto
commerciale, a pagamento, e non c'e` supporto tecnico ufficiale.
WFC e` un framework cross-language; la prima versione e` disponibile
solo per Java (e probabilmente con questo specifico nome non ce ne
saranno altre), ma e` destinata ad essere il nucleo delle "Common Runtime
Libraries" che nel framework .NET saranno a disposizione di qualsivoglia
linguaggio interamente IL-compliant.  E` in pratica un'evoluzione, in senso
filosofico, delle VCL (l'architetto e` la stessa persona).  Usa infatti
anche
un costrutto che in C++ standard non esiste, e di cui (soprattutto i
novellini)
si sente spesso lamentare la mancanza: un "puntatore a funzione" che
indichi in realta` uno specifico oggetto oltre che un metodo di quel dato
oggetto.  Object Pascal lo ha, la MS lo aggiunse a Java, e ora senza
dubbio lo aggiungera` anche al C++.  (Incidentalmente, NON lo considero
una buona idea: un puntatore-a-interfaccia e` praticamente la stessa
cosa, ma piu` generale!).
Alex

 oggetto.
venendo da Borland C++ quando ho iniziato Delphi, la prima volta che ho
smanettato con i puntatori a funzioni mi ci sono spaccato la testa!! Non
capivo perche' quello _stupido_ compilatore continuasse a ripetermi che un
puntatore a funzione non era un puntatore a metodo... e si rifiutasse
_persino_ di castarlo! LOL
Arathorn
Paolo Invernizzi

 news:MPG.13dab5149...@news.tiscalinet.it...
[...]
purtroppo non ho tempo per rispondere nel dettaglio, e tu scrivi un sacco 
:(
in fondo le posizioni non sono distanti, magari ci sono motivazioni 
diverse, e io concepisco di + che qualcuno voglia "sperimentare" se ne ha 
voglia... tu no, pazienza. punti di vista
tutto qui, tagliamo anche perchč finiamo un po' ot; č stato comunque un 
piacere :D
ciao!

 voglia... tu no, pazienza. punti di vista
Ma certo che concepisco la sperimentazione fine a se stessa!  Ogni
tanto tiro fuori i vecchi mattoncini Lego (ormai che anche i miei figli
sono troppo grandi per aver voglia di giocarci) e metto assieme qualcosa,
cosi`, senza particolari obbiettivi.  In un certo senso e` una tecnica di
meditazione: fornendo alla coscienza un falso scopo, facilita il lavoro
del 90%+ del cervello (che e` ben sotto al livello emergente "coscienza")
e spesso gli permette il "data mining" che ha come risultato l'apparenza
di intuizione o creativita`.
Forse la differenza e` che, se in questi giochetti mi trovassi di fronte a
un problema, non mi sognerei mai di postare su it.comp.lang.lego una
richiesta sul perche` e percome.  A che pro?  Visto che lo scopo e`,
ovviamente, di sola didattica e distrazione, se ci arrivo da solo bene,
se non ci arrivo, bene lo stesso, perche` incapponircisi su...?  Mica ci
devo fare qualcosa di *reale*, dopo tutto!
Alex

 
e la modestia? :D
a parte gli scherzi, mi sembri alquanto competente, complimenti!

 e la modestia? :D
Quella si`.  Infatti mica ho detto che concordo con coloro che
i pregi stessi li ascrivono, solo che alcuni lo fanno.  La mia
personale opinione di me stesso (compreso il dettaglio se io
mi ritenga o meno modesto) non la discuto spesso.  Comunque
posso confermare che io stesso NON mi ritengo conciso.  E a
volte mi dispiace: se avessi il dono di dire tutto l'importante,
con precisione e chiarezza, e oltretutto in poche parole,
sarebbe cosa rara e preziosa.
Ma, come non saro` mai un campione dei cento metri piani,
cosi` non lo saro` di concisione.  Pazienza.
Alex

AIUTO		, gcc non trova nč stdio.h, nč iostream.h, qualcuno ha idee?
per favore in posta:
lul...@tin.it

Premesso che non ho mai postato qua, ma che lurko questi ng (C; C++), e che
sto studiando il C, ti dirņ che a me gcc trova la stdio.h, ma la iostream
non so. Non l'ho mai usata...
Sto studiando sģ il C, ma vado moooolto a rilento!
Ciao
kazuma
