Newsgroup: it.comp.programmare.win32
Titolo: Compilatore: AIUTO!!!

Il compilatore che uso (Visual c++ 6) non mi compila  i cicli for, o meglio,
li "salta"!
Ho scaricato da internet il compilatore Borland C++ 5.5, ma non capisco come
funzioni.
Qualcuno che ce l'ha potrebbe spiegarmi dettagliatamente come devo fare?
Se invece usate qualche altro comilatore (c++) potreste dirmi quale?
Gratie a quelli che mi risponderanno e a quelli che mi hanno già risposto su
questo N.G.
Mnx

 ha scritto nel messaggio
news:K9O%5.139746$hk4.5...@news.infostrada.it...


li "salta"!
Hmmm.. ho il sospetto che sia un noto problema di VC++, ma dovresti
postare un po' di codice...
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

std::cout << endl << "Dovresti vedere 10 righe di testo" << endl << endl;
std::endl


Il codice che mi ha mandato xaero me lo compila, anche questo, ma non
funziona! Dove sbaglio?
Grazie per l'interessamento.
#include <iostream.h>
#include <stdio.h>
main(){
for (;;){
 cout<<"Inserire il proprio nome e cognome:";
  char name[20];
 gets (name);
 int count;
 for (count=0;count==20;count++){
 cout << name[count] << "\n";
 }
}
return 0;
 }

 std::endl
allora era meglio:
using namespace std;
cout << endl << "tttt" << endl;
giusto?
quasi quasi passo al C++  :)
quali sono le differenze col C?
le classi?
mi puoi far vedere al volo come funziona una classe semplicissima, con 2
variabili interne un metodo, costreuttore e distruttore?


 for (count=0;count==20;count++){
questa istruzione è sbagliata.
Il secondo parametro è una condizione, finchè è vera il ciclo viene
eseguito.
Nella tua istruzione, count inizialmente assume valore 0 (count=0). Il
suo valore viene poi confrontato con 20 (count=20), essendo falso il
ciclo non viene eseguito.
L'istruzione giusta sarebbe stata
for (count=0; count<20;count++)
Nessun problema del compilatore quindi, ma del programmatore!
ciao!
Sphinx

variabili interne un metodo, costreuttore e distruttore?
class semplice {
 
      private: 
        int count ;
        int *p ;
      public:
        // costruttore
        semplice( int n ) { p = new int[n] ;
                            count = n ;
                          } 
       // distruttore
       ~semplice() { delete [] p ;
                     n = 0 ;
                   } ;
        // metodo inline
        void scrivi_vettore() 
        { 
             if ( n )  
               for ( int i = 0 ; i < count ; i++ )
                   std::cout << p[i] << std::endl ;               


 for (count=0;count==20;count++){
Riscrivibile in 
for ( int count = 0 ; count < 20 ; count++ )
// esempio corretto (occhio che non ho compilato) : 
#include <iostream>
#include <string>
#include <vector>
using namespace std ;
int main()
{
    // un vettore di 5 stringhe
    vector<string> VettStr( 20 ) ;
    // ciclo di lettura delle stringhe
    for ( int i = 0 ; i < 20 ; i++ )
    {
        // vettore temporaneo di 50 caratteri
        char p[50] ;
        cout << "Inserire stringa n." << i+1 << " : "  ;
        // lettura della stringa
        cin.getline( p, sizeof p ) ;
        // memorizzazione
        VettStr.push_back( p ) ;
    }
    // ciclo di scrittura mediante iteratore costante
    for ( vector<string>::const_iterator it =
                          VettStr.begin() ;
          it != VettStr.end() ;
          it++ )
    {
        cout << *it << endl ;
    }
    return 0 ;


 } ;
ma quindi devo per forza usare vettori per memorizzare veariabili interne
della classe?
mi spiego meglio:
cerchiamo di realizzare una classe che faccia qualcosa di concreto (e
desalti le bellezza del C++)
la classe è per esempio cCustomButton, e creerà un bottone personalizzato,
che ne so, magari scrivendo nel DC di un semplice bottone nei messaggi PAINT
nel costruttore ci metto il codice per creare un bottone nel parent
specificato, e ci saranno delle variabili private della classe che
memorizzano l'ID della bitmap delle risorse, oppure la posizione, o del
testo, ecc...
avrò vari metodi che disegneranno il bottone rialzato, schiacciato,
disabilitato, ecc..
e un distruttore che eliminerà queste variabili interne (è necessario
eliminarle?) e distruggerà la finestra
io credevo che avendo le variabili:
  private:
    std::string   strCaptionHiLight;
    std::string   strCaption;
per ogni volta che si creava uuna classe con
CmiaClasseButton(hwnd, str) varBottone;
venivano duplicate anche tutte le variabili interne
sbaglio o è così?


sbaglio o è così?
Certo che e' cosi', altrimenti non avrebbe senso l'uso della classe.
L'unica differenza e' quando si usano i membri statici di classe, che
non sono legati all'istanza della classe, ma alla classe stessa e sono
quindi istanziati una sola volta.


 quindi istanziati una sola volta.
ok.
grazie mille per le delucidazioni
un'ultima cosa:
le altre novità del C++ sarebbero?...
ereditarietà, giusto? l'ho sentita dire, ma non ho ben chiaro come possa
essere utile
esempio pratico:
creo una classe con dei metodi
creo un'altra classe più complessa che gha anche i metodi della classe base,
quindi mi conviene ereditare i membri della classe base. è così?
poi una cosa molto bella che ho visto è l'overloading delle funzioni (e di
operatori)
poi la riassegnazione di operatori, o come si chiama, insomma che cambia la
funzione svolta da un operatore.
una cosa che ho visto in un sorgente sono i template, e riguardo a quelli
non so proprio nulla
grazie
