Newsgroup: it.comp.lang.c++
Titolo: Classe che non eredita

Sto sicuramente sbagliando qualcosa, non capisco cosa pero':
costruttore della classe Casa:
casa::casa(const char* Indirizzo, int numeroStanze, int numeroBagni){
    indi=Indirizzo; Stanze=numeroStanze; Bagni=numeroBagni;
}
costruttore della classe Villa:
villa::villa(const char* Indirizzo, int numeroStanze, int numeroBagni,
double metriQuadriGiardino){
    villa(const char* Indirizzo, int numeroStanze, int numeroBagni, double
metriQuadriGiardino) : casa(Indirizzo, numeroStanze, numeroBagni);
    meQuadriGiardino=metriQuadriGiardino;
}
il costruttore della classe Villa non eredita, mi da errori di compilazione.
Come posso correggere.
Scusate le domande da niubba, sto imparando adesso per la prima volta il c++

 il costruttore della classe Villa non eredita, mi da errori di compilazione.
Forse ho capito l'errore, qualcuno potrebbe dirmi dove posso trovare
informazioni su come si fa un costruttore per una classe che deve ereditare
tutto da un'altra classe ed aggiungere alcuni parametri?
Grazie
Val

 }
villa::villa(const char* Indirizzo, int numeroStanze, int numeroBagni,
             double metriQuadriGiardino)
         : casa(Indirizzo, numeroStanze, numeroBagni)
{
  meQuadriGiardino = metriQuadriGiardino;
}
oppure
villa::villa(const char* Indirizzo, int numeroStanze, int numeroBagni,
             double metriQuadriGiardino)
         : casa(Indirizzo, numeroStanze, numeroBagni),
           meQuadriGiardino(metriQuadriGiardino)
{}
-- 
Horst

 }
Complimenti!
Funziona!
Grazie mille!
Non e' che per caso avresti anche una funzione che analizza due stringhe e
verifica se stringa2 e' una sottocatena di stringa1 e se lo e' restituisce
l'indirizzo di memoria del carattere di stringa1 dove inizia stringa2
altrimenti restituisce NULL?
Io ho fatto questo:
const char* mstrstr(const char* str1, const char* str2){
    char* passa
        if (strcmp (str1,str2) <= 0) return NULL ;
        else{
         for (int i=0; int<strlen (str1); i++)
            {
                if (*(str1+i)==*str2) passa=(str1+i);
            }
        }
Return &passa;
}
Ma (come e' ovvio) non funziona
Sto seguendo come libro di teso il manuale Apogeo di Shildt e gli esercizi
svolti mi pare di capirli ma quando poi mi applico su quelli da risolvere mi
trasformo in una perfetta idiota: qualche consiglio?
Grazie ancora di tutto
Val

 altrimenti restituisce NULL?
    #include<cstring>
    char * strstr( const char * stringa1, const char * stringa2 )
se invece usi std::string,
    stringa1.find( stringa2 )
-- 
int

 Ma (come e' ovvio) non funziona
In effetti non compila nemmeno, sia per il Return (colpa di Entourage,
suppongo, quindi non lo conto) sia per la mancanza di ; dopo passa.
Non solo... 
Ora per prima cosa vediamo gli errori "sintattici" e "di stile", poi
vediamo l'algoritmo.
 for (int i=0; int<strlen (str1); i++)
questo è privo di senso, dovrebbe essere
 for (int i=0; i<strlen (str1); i++)
o meglio ancora 
 for (size_t i=0; i<strlen (str1); ++i)
1. il tipo di ritorno di strlen è size_t, fai man strlen e te ne
renderai conto. Tu stai confrontando una variabile senza segno con una
con segno. Questo non è bene. Infatti il compilatore protesta.
2. Meglio il postincremento del preincremento. A meno che non hai una
precisa ragione per scrivere i++, scrivi ++i.
Inoltre il tuo codice funziona esclusivamente se le tue stringhe di
caratteri sono \0 terminate. Se no, non funge. Il suo utilizzo rimane
quindi un poco limitato (e molto facilmente finisce per nascondere
bachi).
Infine restituisci &passa. La variabile passa, ha tipo char*. &passa
(ovvero l'indirizzo di passa) è un puntatore a puntatore di carattere.
Tu invece lo hai definito come semplice puntatore a carattere.
Non solo. passa è una variabile locale. Quindi viene distrutta finito il
suo scope. L'indirizzo che restituisci sarà quindi invalido.
Poi veniamo ad un errore logico: se la prima stringa è
lessicograficamente antecedente alla seconda o uguale, allora ritorna
NULL (in C++ sarebbe meglio usare 0 al posto della macro NULL, oppure
definire NULL). 
In primo luogo se le due stringhe sono uguali, l'una è sottostringa
dell'altra. Quindi non dovrebbe ritornare NULL.
Non solo, "amica" contiene la sottostringa "mica", ma è
lessicograficamente antecedente. Non va bene l'algoritmo.
-- 
[ RiK0                                ]
[ Go away! The internet is full!      ]
[ Non credo negli schemi non vincenti ]

 tale "libro". A parte questo:
Che autore mi consigli di seguire?
Ti ringrazio per le tue spiegazioni
Val

 precisa ragione per scrivere i++, scrivi ++i.
Uhm e questo perchč? o_O
(il postincremento č i++, semmai il contrario...)

Tin Toy wrote:

imho, nel caso specifico (i č un size_t) non serve a niente. Diversa la 
storia se i fosse un oggetto di qualche tipo, ma anche lě bisogna vedere 
caso per caso (in generale: con il post-incremento č necessario 
restituire un temporaneo, con il pre-incremento no, quindi č piů 
performante).
-- 
Barcollo ma non mollo!

 Che autore mi consigli di seguire?
io mi sono trovato benino con
C++ Corso di Programmazione
e con
Il Mondo degli Oggetti: Programmazione in C++
EmJey
-- 
Non prendere la vita troppo sul serio...
non ne uscirai mai vivo

 (il postincremento è i++, semmai il contrario...)
Pardon, era il preincremento invece del postincremento, errore mio
La versione "codice" della proposizione comunque è giusta. Meglio ++i di
i++.
Per completezza per Valentina scrivo anche il perchè esteso, cosicchè se
si è confusa con le due informazioni contrastanti contenute nel mio
post, avendo la spiegazione dovrebbe solversi l'eventuale dubbio.
Il perchè è semplice. Anche se con gli int e con i tipi primitivi non
cambia nulla, come abitudine è meglio scrivere ++i, perchè con i tipi
composti cambia eccome.
Il postincremento è generalmente espresso in termini di preincremento (o
meglio, questa è la via "STL").
Tipicamente si ha
const SomeType operator++(int){
      SomeType tmp = *this;
      ++(*this);
      return tmp;
}
In pratica ci tiriamo dietro una copia. Se fatto molte volte (magari in
un ciclo) non è il massimo, specie quando è inutile.
Ovviamente ci sono casi in cui il postincremento serve. Ma quando non
serve è migliore il preincremento.


 Che autore mi consigli di seguire?
Allora... i testi migliori a mio avviso sono lo Stroustrup e il Lippman.
Il primo dei due č perň poco indicato per qualcuno a digiuno di
programmazione. 
Il secondo di piů, ma č comunque un testo relativamente impegnativo.
Il mio consiglio č di scaricare il libro di Eckel (liberamente
distribuito in rete) e di studiare quello. Poi passare al Lippman o allo
Stroustrup, a seconda di quello che ti piace di piů (per allora avrai
piů esperienza).
Io personalmente ho iniziato con il Lippman (ma ero tutt'altro che
digiuno di programmazione). Poi ho preso anche lo Stroustrup. Sono due
eccellenti libri che si complementano bene. Certe parti sono piů
complete sull'uno, altre sull'altro. Ragion per cui sono contento di
averli entrambi.
Questo per il semplice "linguaggio". (semplice poi... oddio...)
