Overloading di <= fra oggetti String
nembo kid
Ho una classe String e una funzione di ridefinizione dell'operatore <= :
class String{
//...
public:
bool operator<= ( const String &right ) const
{ return !( right < *this ); }
//..
};
Non ho capito come possa la relazione (right < *this) determinare la
condizione <= .
Grazie
Andrea Laforgia
>public:
> bool operator<= ( const String &right ) const
> { return !( right < *this ); }
>//..
>};
>
>Non ho capito come possa la relazione (right < *this) determinare la
>condizione <= .
Perché (lhs <= rhs) equivale a !(lhs > rhs)
nembo kid
> Perché (lhs <= rhs) equivale a !(lhs > rhs)
Non comprendo come un confronto fra due deferenziazioni di puntatori
possa determinare se la stringa è più grande o più piccola.
Non funziona:
#include <iostream>
int main()
{
char* s1 = "Rho";
char* s2 = "Domodossola";
if ( *s1 > *s2 )
std::cout << "s1 maggiore di s2\n";
else
std::cout << "s2 minore o uguale di s1\n";
}
L'output è:
s1 maggiore di s2
alasha...@gmail.com
Non è un confronto fra due puntatori, ma fra due oggetti di tipo
'String'.
In effetti, l'autore usa la funzione membro 'bool String::operator<
( const String &right ) const' per implementare una nuova funzione
membro 'bool String::operator<= ( const String &right ) const'.
All'interbo della funzione, 'right' è l'oggetti String passato come
argomento, ' *this ' è l'oggetto String sulla quale venga chiamata la
funzione.
Dunque:
String s1, s2;
s1 <= s2;
' *this ' referisce a s1, 'right' a s2.
Saluti.
Andrea Laforgia
> Non comprendo come un confronto fra due deferenziazioni di puntatori
> possa determinare se la stringa è più grande o più piccola.
<...>
> char* s1 = "Rho";
> char* s2 = "Domodossola";
Non cambiare le carte in tavola: nel messaggio precedente parlavi di
stringhe (quindi suppongo std::string), *NON* di puntatori. Per le
std::string vale il confronto diretto. E' ovvio che confrontare i
puntatori è un conto, confrontare i valori puntati è un altro; e per
confrontare i valori puntati, trattandosi di stringhe "a la C", in C++
bisogna ugualmente usare strcmp() (v. string.h). Lasciatelo dire: hai
moltissima confusione su concetti di base.
?manu*
> Non funziona:
>
> #include <iostream>
>
> int main()
> {
> char* s1 = "Rho";
> char* s2 = "Domodossola";
>
> if ( *s1 > *s2 )
> std::cout << "s1 maggiore di s2\n";
> else
> std::cout << "s2 minore o uguale di s1\n";
> }
>
> L'output è:
>
> s1 maggiore di s2
E tu cosa ti aspettavi, invece?
*s1 è il primo carattere di s1, cioè 'R'. *s2 è 'D'. Da che mondo è
mondo 'R'>'D'.
E.
nembo kid
> moltissima confusione su concetti di base.
Infatti ho deciso di mollare, troppo complicato per me.
Grazie comunque.
Andrea Laforgia
> > moltissima confusione su concetti di base.
>
> Infatti ho deciso di mollare, troppo complicato per me.
Senza offesa, ma secondo me non ti sforzi di capire o, meglio, non hai
voglia di capire. Ti arrendi troppo facilmente. La confusione si cura:
basta chiarire i concetti. Il C++ è sicuramente un linguaggio
complesso, ma non sono questi gli argomenti che lo rendono complesso.
Mi sembra strano che tu trovi confusione su un concetto semplice come:
"(a <= b) equivale a (!(a>b))"
O che non riesca a capire che l'oggetto String citato nell'esempio non
è, evidentemente, un puntatore a char.
Soviet_Mario
> Andrea Laforgia ha scritto:
>
>> moltissima confusione su concetti di base.
>
> Infatti ho deciso di mollare, troppo complicato per me.
si ma perché sottovalutare uno dei principali pregi del C++,
che si possono usare o non usare un sacco delle
caratteristiche più avanzate ? In C++ una cosa (difficile)
sepsso la PUOI fare, con vantaggi, ma non la DEVI fare per
forza.
Infatti si può avere una transizione dolce dal C al C++
usando un po' alla volta le numerose caratteristiche in più,
ma non devi digerirle in un boccone solo.
Poi per carità, dipende da quanto tempo totale ci vuoi
investire e in che arco temporale distribuito. Se l'uno o
l'altro sono troppo scarsi, vero che diventa tempo sprecato
ciao
soviet
>
> Grazie comunque.
nembo kid
> O che non riesca a capire che l'oggetto String citato nell'esempio non
> č, evidentemente, un puntatore a char.
Quella relazione mi era chiara...deriva dall'algebra degli insiemi.
Vorrei capire qualcosa di piů proprio sugli oggetti, come vengono
gestiti in memoria ecc.
Sul libro vengono trattati, giustamente, a un livello di astrazione
superiore, ma vorrei capire un po' dietro cosa c'č.
Provo a cercare un po' con Google.
Grazie comunque.
Andrea Laforgia
> Vorrei capire qualcosa di più proprio sugli oggetti, come vengono
> gestiti in memoria ecc.
C'è un libro di Stanley Lippman che può esserti d'aiuto: "Inside the C+
+ Object Model".
E' piuttosto vecchiotto (1995) e non so se riesci a recuperarlo in
edicola.
Su Amazon c'è: http://snipurl.com/2yeht
Comunque non aspettarti che dietro gli oggetti ci sia chissà cosa. In
sostanza si tratta solo di qualcosa di molto analogo alle strutture.
L'unico elemento di complessità è introdotto dal polimorfismo.
Andrea Laforgia
> si ma perché sottovalutare uno dei principali pregi del C++,
> che si possono usare o non usare un sacco delle
> caratteristiche più avanzate ?
Il fatto è che quelle di cui si è parlato finora non sono affatto
caratteristiche "avanzate". Almeno non per come intendo io le
caratteristiche avanzate di un linguaggio in generale e del C++ in
particolare. Se si ha difficoltà a capire questi concetti basilari,
allora figuriamoci certi temi legati alla programmazione generica.
Insomma, il C++ è difficile, ma la percezione della sua difficoltà
dovrebbe arrivare solo a certi stadi.