Newsgroup: it.comp.lang.c++
Titolo: Imparare il C++

Mi ricollego ai messaggi di qualche News fa ("Non sarebbe male avere le idee
chiare!"), in quanto iniziavo a non capirci + niente. Allora ... voi dite
che per imparare a programmare in C++, non è assolutamente vero che bisogna
partire dal C, anzi che è sconsigliatissimo! Ma allora perché
all'università, per imparare a programmare con il C++ partono sempre dai
rudimenti del C? Intendo le prime funzioni del cazzo, i primi problemini
stupidi ... e solo dopo averne capito la metodologia ... poi iniziano a
passare al C++? Questo sinceramente non lo capisco!!! Insomma, pure io ho
fatto così ... 3 anni e 1/2 di C per poi passare alla programmazione ad
oggetti in C++. Allora, o sono un genio, o è assolutamente indispensabile
iniziare dalle basi per poi passare a tutto il resto!! E poi volevo capire
che cos'é che non va in questo approccio! Insomma, un metodo del C++, quello
+ interno viene costruito con il metodo di programmazione del C. Alcune cose
richiedono essenzialmente quell'approccio. Un esempio è un progetto che ho
tentato di portare dal C al C++, e che ho realizzato che una costruzione
completa ad oggetti, perfettamente conforme alla metodologia della
programmazione ad oggetti è impossibile! Ho tentato di ricostruire un
interprete che avevo costruito in C, ripartendo da 0, per poter passare
crudelmente ad una soluzione + semplice ... che poi si è rivelata un misto
tra programmazione ad oggetti e programmazione strutturata! En beh? Se certi
progetti sono impossibili da realizzare completamente con l'approccio ad
oggetti, come pensate di fare? Abbandonate il progetto? Penso che un minimo
di programmazione strutturata sia necessaria per svolgere un progetto di non
poche righe! Prendiamo in considerazione la creazione di una classe in C++
per la gestione delle liste! Supponiamo che abbiamo l'intenzione di
riscrivercela senza usare i template ... il distruttore come lo fate?
L'append? Se non sbaglio dovreste utilizzare la ricorsione ... e non è lo
stesso che utilizzare il C per fare un distruttore di una lista? Ok ... c'é
sempre l'oggetto di mezzo ... ma io non vedo questa grossa differenza! Alla
fin fine pure la richiesta della memoria dinamica equivale a quella del C
no? Cambia solo la scrittura, ma il metodo è sempre quello:
C++:  int *x = new int[10];
C:      int *x = malloc(sizeof(int) * 10);
altri termini:  puntatore = richiesta di mem!
Penso che studiare il C++ direttamente dal C++, possa essere leggermente
fuoriviante. Ad esempio la riscrittura di un operatore non è altro che una
funzione o sbaglio?  un conto è  2 + 3, e un'altro conto è definire "int
operator +(int x, int y)" e fare quella stessa operazione ... provate voi a
tradurre in assembler i due codici, e capirete che le 2 cose sono totalmente
diverse.
Insomma, per niente tutto il codice del C, viene compilato senza difficoltà
come fosse C++. Poi altra cosa, non sono d'accordo sul fatto che il C++ sia
+ o - difficile del C. Ci sono alcuni progetti che si rivelano molto +
semplici con un linguaggio, ed altri con un altro.

 semplici con un linguaggio, ed altri con un altro.
Scusa ma dubito che esistano progetti piu' semplici in C che in C++. Se non
altro perche' in C++ puoi fare TUTTO quello che puoi fare in C, e altro ancora.
Inoltre la complessita' di un linguaggio non ha nulla a che vedere con la
convenienza nel suo uso per un certo problema. Sarebbe come dire che Perl e'
piu' semplice di Basic.
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Mi sembra che tu la prenda un po' alla lontana. In fondo si parlava solo
di imparare il C++, non tutto lo scibile dell'Informatica...
Ciao,
Nicola

 traduzione in assembler. Per me si puo' benissimo ottenere lo stesso
risultato!
Per niente ... visto che il nuovo  + viene visto come una funzione, ci sono
delle determinate operazioni in asm che devono essere affrontate prima della
chiamata dell'operatore! Certo che se il codice ASM viene scritto a mano è
un'altro conto!
Cmq sia il basic è il linguaggio + semplice per eccellenza, è ovvio che il
Perl è + difficile :-))

 pazzesche. Per niente un interprete per linguaggio funzionale, viene
scritto
Meno file ? Non mi pare che sia un prticolare vantaggio scendere da 81 a 50.
Pochi oggetti ? Forse intendevi poche classi. Solitamente pochi classi con
quelle che tu chiami 'una marea di riscritture' non sono segno di buona
programmazione OO. Per esperienza personale posso dirti che su circa 65000
righe di codice sicuramente sei nell'ordine delle 300-600 classi. Se invece
parliamo di oltre un milione di linee di codice (e qui cito letture perchč
la mia esperienza non arriva cosě lontano) siamo nell'ordine di alcune
migliaia di classi.
Ripeto. Sarebbe utile se dettagliassi meglio i numeri che hai indicato.
Nota personale. Se vuoi imparare il C++, parti dal C++. Se vuoi prima
imparare la programmazione ad oggetti parti da un linguaggio molto piů
semplice, ma estremamente valido. Python.
Ciao, massimo.

intendo)?
piccola nota OT: il Pascal da qualche anno, grazie a Borland, č 
diventato Object Pascal, piů che paragonarlo al C si dovrebbe 
paragonarlo al C++

 di imparare il C++, non tutto lo scibile dell'Informatica...
Infatti. Ma il C++ e' un linguaggetto piuttosto complessino.
Ergo conviene affrontarlo quando si hanno gia' alcune basi o si rischia di
trovarsi a non capire la differenza, per esempio, fra la OO e il supporto del
C++ alla OO.
Se la domanda e' del tipo: parto da zero e voglio arrivare al C++, affronto il
C++ o prima do un'occhiata al C?
La mia risposta e': se parti da zero parti da lontano. Quindi il C++ e' lontano.
Ergo prima Knuth (Pascal) poi l'OO (Smalltalk o Eiffel). Meglio se nel frattempo
dai anche un'occhiata a altre cose (Lisp, Prolog, Perl etc.).
Oppure parti dal C++. Ma anche se arriverai a capire il C++ in tempi piu' brevi
che non nella mia proposta, per arrivare ad capire il resto impiegherai di piu'.
E il resto ti serve comunque per usare bene il C++.


 Perl è + difficile :-))
Ci sono casi in cui il Perl e' MOLTO piu' facile, se con facile intendi che e'
facile risolvere un problema in quel linguaggio come dicevi tu. Prova a scrivere
un grep in basic e vedrai!


 imparare la programmazione ad oggetti parti da un linguaggio molto più


 dato secondo delle operaizioni logiche!!
Se si tratta di programmazione generica e vuoi evitarti la riscrittura
per ogni tipo di dato, perche' non usi i templates?  Qualcosa tipo:
template <typename T> class ilMioDato {
private:
  T dato;
  ...
public:
  bool operator < (const ilMioDato & rhs) const { return dato < rhs.dato; }
  ...
};
O forse non ho capito nulla di cosa vuoi fare ?
8^)
-- 
Maurizio Loreti                         
http://www.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it
The instructions said to use Windows 98 or better - so I installed FreeBSD.

 Smalltalk.
Userò lo stesso linguaggio per fare un programma no? O c'é pure la
possibilità di fare un eseguibile cono 35 linguaggi diversi?

 ha scritto nel messaggio
news:rm4rw2b...@mlinux.pd.infn.it...


 tipo long, double, char?
Con qualunque tipo di dato per cui e' definito un operator < ();
quindi anche con le string e gli int (String e Integer non so cosa
siano).
Come esempio pensa a std::swap definito in <algorithm> - secondo lo
Standard, come
namespace std {
  template <class T> inline void swap (T & a, T & b) {
    T tmp(a);  a = b;  b = tmp;
  }
}
La procedura "swap" puo' essere usata per ogni oggetto per cui e'
definito un copy-ctor ed un assignment operator: da un singolo char a
lunghissimi vettori di oggetti comunque complicati.
Questo approccio si chiama "programmazione generica".  Per fare la
stessa cosa in C avresti dovuto definire una procedura "swap" per ogni
tipo di argomento; non era proprio questo il tuo problema?  Di non
definire la stessa operazione tante volte, una per ogni tipo di
argomento?


 ha scritto nel messaggio
news:rmvgoia...@mlinux.pd.infn.it...


dato secondo delle operaizioni logiche!! La marea di riscritture non si
...
Non sono sicuro di aver capito di cosa stai parlando... ma sospetto
che si tratti di qualcosa come avere
  char
  interi
  long
  float
  double
  long double
e poter implementare gli operatori di confronto fra qualunque
coppia. Per fare questo in C++ si puo' usare un approccio del tipo...
  class Char
  {
    ... Attributi di Char ...
    public:
      friend bool operator < (const Char& a, const Char& b);
      ... Altre operazioni fra Char e Char ...
  };
  class Int
  {
    ... Attributi di Int ...
    public:
      friend bool operator < (const Int& a, const Int& b);
      ... Altre operazioni fra Int e Int ...
      /* Conversione implicita Char->Int */
      Int(const Char& c);
  };
  class Long
  {
    ... Attributi di Long ...
    public:
      friend bool operator < (const Long& a, const Long& b);
      ... Altre operazioni fra Long e Long ...
      /* Conversione implicita Char->Long */
      Long(const Char& c);
      /* Conversione implicita Int->Long */
      Long(const Int& c);
  };
  ...
In pratica per ogni tipo definisci le promozioni possibili.
Facendo in questo modo quando scrivi
    if (a<b)
dove a e' un Char e b e' un LongDouble il compilatore
trovera' la conversione Char->LongDouble (definita come
costruttore non explicit di LongDouble) e chiamera' la
versione di confronto LongDouble/LongDouble.
E' necessario definire tutte le promozioni di un singolo
tipo in quanto il C++ implicitamente ammette una sola
conversione user-defined (ovvero non trasforma Int in
Long per poi trasformare Long in Double).
Per codice ripetitivo un'altra soluzione possibile spesso
misteriosamente ignorata e che funziona con qualunque
linguaggio di programmazione e' scriversi un generatore
di codice. Niente noia, niente sviste, niente copy'n paste,
nessun terrore di dover modificare la struttura (se si
usa un generatore attivo).
HTH
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

costrutti dell'OO, perché dovresti dire che non conosco l'OO ?
perchè è molto raro che una soluziona non possa essere affrontanta con
i metodi della OOP: quindi, se tu non ci riesci i casi sono due:
1) il tuo problema è uno dei rarissimi esempi in cui non si puo
programmare OO (a dire la verità non so neanche se esistano questi
problemi...)
2) tu non conosci la OOP a sufficienza per risolvere il tuo problema.
Anto
--
Antonio Cuni, 18 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

paragonarlo al C++
meglio continuare a paragonarlo al C, altrimenti quel glorioso e
bellissimo linguaggio che è il Pascal si ritrova bistrattato in malo
modo dal C++...


 possibilità di fare un eseguibile cono 35 linguaggi diversi?
Se conosci 35 linguaggi sufficientemente diversi e il tuo programma fa 35 cose
sufficientemente diverse, la cosa migliore e' scrivere il tuo programma in 35
linguaggi.
In generale le soluzioni ottimali sono pero' sviluppate in due o tre linguaggi
diversi, anche perche' e' difficile che un singolo programma debba fare poi
cosi' tante cose e che ci siano piu' di tanti linguaggi a disposizione.


 double
del quale suppongo basti fare un bellissimo template ... che risolva tutto!!
Un'altra cosa è lavorare per un progetto dove i 7 tipi, sono totalmente
diversi fra loro!!! La struttura di un singolo oggetto ... dove per oggetto
intengo la singola informazione del linguaggio per il quale è stato scritto
l'interprete in C e del quale ho intenzione di riscrivere in C++, è una cosa
simile (non guardate come ve lo scrivo):
Classe + esterna:
class oggetto;
1 classe oggetto contiene i seguenti tipi di dato:
class String
class Number
class Constant
class Variable
class Function
class List
Poi ci sono alcune di queste classi che hanno altri tipi di oggetti ... ad
esempio Number si divide  in
class Signed
class Unsigned
class Real
class Ratio
e ancora Function:
class System
class User
Nonché la class Lista non è altro che una lista di Oggetti .... (definizione
ricorsiva di tutta la struttura del tipo dei dati). Beh ... ammesso che in
C++ posso disporre questo tipo di struttura come mi pare e piace ... visto
che gli operatori che mi interessa implementare sono questi:
+   -   *    /    <   >   <=   >=   ==   !=   ^   &   |   &&   ||
Che mettono in relazione qualsiasi tipo di dato (ad esempio String ^ Signed)
secondo delle relazioni logiche che sono previste da questo linguaggio per
cui sto procedendo alla stesura dell'Interprete (non chiedetemi che senso
hanno ... perché sarebbe troppo complicati), come posso io gestire tutti i
casi senza farmi un culo enorme? En beh? Anche perché poi  .... la struttura
di valutazione delle istruzioni si basa su di una lista di "oggetti", dove
appunto ogni oggetti può essere di quel tipo!
Certo che sarebbe troppo comodo confrontare oggetti + o - uguali tra loro
come mi avete detto voi ... in quel caso sarei stato capacissimo farlo pure
io ... ma una soluzione a questo problema che non sia disastrosa ... beh ...
non l'ho ancora trovata! Come vedete gli operatori sono 15, e i tipi di dato
sono 6, che se espansi (cioè eliminare ad esempio Number per sostituirlo
direttamente con i tipi contenuti) ben 10. Facendo un calcolo di tutti i
possibili casi per cui devo implementare i relativi operatori ... quante
riscritture mi vengono fuori?
"Andrea Ferro" <And...@UrkaDVD.it> ha scritto nel messaggio
news:9aodb4$mig$1...@serv1.iunet.it...





 E il resto ti serve comunque per usare bene il C++.
Francamente se l'obiettivo e' il C++ puo' risultare piu' utile
concentrarsi su questo, partendo dal linguaggio tramite lo Stroustrup o
il Lippman-Lajoie, se non addirittura "Accelerated C++" di Koenig-Moo,
per poi passare magari ai libri di Scott Meyers.
Ciao,
Nicola
-- 
Posted from 
mail.divalsim.it
 [194.185.113.194] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 riscritture mi vengono fuori?
Cioe' hai da implementare 1500 operatori. A questo punto o gli operatori
in questione fanno 1500 cose diverse, e in questo caso te li devi
implementare tutti, in qualsiasi linguaggio tu scriva il tuo interprete,
o si possono raggruppare in insiemi di operatori che fanno la stessa
cosa. In questo secondo caso il C++ ti mette a disposizione le funzioni
virtuali, l'overload, le conversioni implicite ed i template per
permetterti di scrivere gli operatori che fanno la stessa cosa una volta
sola. Il C non ti mette a disposizione nessuna di queste cose e quindi
pare difficile credere che lo stesso interprete richieda piu' codice C++
che C, a meno di non usare il C++ molto male.
Ad esempio in C++ puoi scrivere 
template <typename A, typename B> 
bool operator < (const A & a, const B & b) {
  return b > a;
}
Cosi' ti basta definire tutte le varianti dell'operatore > ed ottieni
automaticamente tutte le varianti dell'operatore < (a meno che il tuo >
non abbia un comportamento diverso da < con gli operandi cambiati).


 C++:  int *x = new int[10];
No, in C++ si scriverebbe:
#include <vector>
std::vector<int> x(10);
Piu' semplice, piu' sicuro ed ugualmente efficiente.
