Newsgroup: it.comp.lang.c++
Titolo: Argomento di tipo string

Ciao,
	il costruttore della mia classa A prende come argomento una string (non
nel senso di un array di caratteri, proprio un oggetto di tipo string).
Se io faccio una cosa del genere, non funziona (crash del programma a
runtime):
int main (void) {
	A variabile = A("pippo");
}
la cosa mi ha lascato un po' stupito... pensavo che automaticamente,
venisse creato un'oggetto string a partire dall'espressione "pippo".
Devo fare cosi' per farlo funzionare:
int main (void) {
	A variabile = A(string("pippo"));
}
Ma mi chiedo... perche' va in crash a runtime e non a tempo di
compilazione?
Mi sembra che in altri casi simili non avessi problemi... ma magari ho
avuto solo fortuna :-o
Mi sapete illuminare?
Bye e Geazie

 }
Hai provato con il più normale
A variabile("pippo");
? Anche se non so se questo risolverà il problema...
EMG
--
EMAG Software Homepage:     
http://www.emagsoftware.it
The EMG's ZX-Spectrum Page: 
http://www.emagsoftware.it/spectrum
The Best of Spectrum Games: 
http://www.emagsoftware.it/tbosg
The EMG Music page:         
http://www.emagsoftware.it/emgmusic
 

 Mi sapete illuminare?
Scusa, ma il seguente programma viene compilato con successo sia dal g++ 
che dal Borland.
Forse non ho capito la domanda ?
Cosa vuoi fare...
Fai prova A("pippo"); !
Ecco uno stupido esempio...
#include <iostream>
#include <string>
class prova
{
         std::string m_string;
         public:
         prova() {}
         prova(const std::string String) : m_string(String) {}
         const std::string& theString() const
         {
                 return m_string;
         }
};
using namespace std;
int main()
{
         prova A("pippo"); // GUARDA QUA !!!
         cout << "Ciao, " << A.theString() << endl;
         return 0;
}

 }
A me funziona bene. Sicuro che non ci sia un problema nel costruttore ?
E inoltre chiedo, ai piu esperti di me.. che differenza c'è tra
	A variabile = A("pippo");
e
	A variabile = new A("pippo");
Ciao
M

 M
La prima è essenzialmente uguale ma stilisticamente peggiore di
A variabile("pippo");
La seconda è un errore!

 La seconda č un errore!
Aargh.. certo che č un errore. LoL. Scusate :)
Mtců

}
Il problema potrebbe essere nel costruttore di copia della tua classe
A.
Infatti, quello che fai e' creare due istanze di A e usi la prima come
argomento per la seconda.
Se la tua classe fa qualcosa di complesso e non hai definito un
costruttore di copia (e un operatore di assegnamento) il comportamento
del programma potrebbe essere indefinito (e quindi crashare o meno, in
maniera arbitraria).
Quindi, se in A(string) fai qualcosa di particolare, devi definire
anche un
A(const A&) e un  operator=(const A&) che facciano piu' o meno le
stesse cose (e un ~A() per rimettere tutto a posto).
Saluti,
Fabio

 peggiore di A variabile("pippo");
Beh, dire che e' essenzialmente uguale mi pare impreciso, ma capisco
cosa intendi, e certamente e' stilisticamente peggiore.
Tommaso
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Aargh.. certo che è un errore. LoL. Scusate :)
Si, e' un errore. Ad ogni modo c'e' una bella differenza tra:
A variabile = A("pippo");
e
A *variabile = new A("pippo");
nel primo caso variabile e' un oggetto automatico sullo stack.
nel secondo caso variabile e' un puntatore ad un oggetto allocato sullo 
heap.
Tommaso

 La seconda č un errore!
Oppure Java :))
-- 
non vincono, non vinceranno, non hanno domani
la forza č nel puntello impugnato da oneste fortissime mani

 
allora è un *orrore*! :-)
-- 
MSN: sirpsycho_78 -at- hotmail dot com

 cosa intendi, e certamente e' stilisticamente peggiore.
Non sono d'accordo. Dal punto di vista dell'efficenza penso che le due
forme siano uguali per tutti i compilatori. Il problema e' che entrambe
presentano trappole ed a mio avviso la trappola legata alla prima forma
e' piu' facile da scovare rispetto a quella legata alla seconda.
Per scendere nei dettagli: la prima forma richiede che il costruttore
di copia sia accessibile (non privato), anche se la sua chiamata puo'
ed e' spesso eliminata per ottimizzazione. Nel secondo caso invece c'e'
il rischio di scrivere un'istruzione che puo' essere interpretata come
dichiarazione, nel qual caso il baco e' molto piu' sottile. Ad esempio:
int a(int());
Che contrariamente alle aspettative non definisce a e la inizializza a
zero, ma dichiara una funzione con parametro e ritorno intero.
Ciao,
Nicola

 zero, ma dichiara una funzione con parametro e ritorno intero.
Beh, questo e' un concetto piuttosto conosciuto... Nel caso in cui il
C++ most vexing parse dovesse creare problemi ci sono vari modi per
ovviare al problema tra cui usare due coppie di parentesi.


 
Scusa, puoi spiegare meglio? Due parentesi dove?
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

 Scusa, puoi spiegare meglio? Due parentesi dove?
Mi spieghero' meglio....
#include<iostream>
using namespace std;
struct A{
     A(int){cout << "constructor" << endl;}
};
int main()
{
     int n = 0;
     A a(int(n));
}
quando giri il programma non vedrai scritto constructor, infatti a e'
una funzione che ritorna un oggetto di tipo A e che prende un intero
come parametro.
se quello che intendevi e':
dichiarare un oggetto a di tipo A passando al suo constructor il valore
dell'intero n allora puoi:
int valore_da_passare(n);
A a(valore_da_passare);
ovvero rompere lo statement in due.
oppure usare due coppie di parentesi se il tuo compilatore gia' le
supporta:
A a((int(n)));
Nota che siccome il mio esempio, per tenerlo semplice', e' venuto un
pochino troppo stupido, in questo caso banale basterebbe fare invece di:
A a(int(n));
un bel:
A a(n);
direttamente.
In realta' il problema si pone spesso con STL usando iteratori,
altrimento non e' facile creare involontariamente il problema. Per
questo non capisco perche' l'argomento sia stato tirato fuori.
Ti consigli di leggere effective STL a riguardo.


 ovviare al problema tra cui usare due coppie di parentesi.
Come dimostra il messaggio che hai ricevuto in risposta questo e' un
problema non sufficientemente noto. In piu' l'istruzione specifica
compila correttamente e quando si ha fortuna si ottiene un messaggio
diagnostico inatteso da parte del compilatore, riferito ad un'altra
porzione del codice, altrimenti si ha l'apparente "salto" di
un'istruzione.
Francamente tra i due casi mi pare di gran lunga preferibile il primo.
Prendiamo un esempio concreto:
class A {
  public:
    A() {}
  private:
    A(const A &) {}
};
int main()
{
    A a = A();
    int b(int());
    return b;
}
Il Comeau da' i seguenti messaggi:
"decl.cpp", line 10: error: "A::A(const A &)", required for copy that
was
          eliminated, is inaccessible
      A a = A();
            ^
"decl.cpp", line 12: error: return value type does not match the
function type
      return b;
             ^
Ciao,
Nicola

 problema non sufficientemente noto. 
E' trattato su diversi libri, e' stato trattato piu' volte su vari
newsgroups, etc... Per cio' che mi riguarda il probema e' noto. Ovvio
poi che non lo conoscano tutti, ma se e' per questo sono tantissime le
cose del C++ che non tutti conoscono. Il C++ e' un linguaggio molto
difficile e complesso.




Ringrazio tutti per l'aiuto... incredibilmente l'ho ricompilato oggi e non
ho piu' il problema che avevo ieri... l'unica cosa che mi viene in mente e'
che possa essere successo qualcosa di strano con il makefile.
Mah... ad ogni modo vorrei chiarirmi una cosa:
Quando io creo un'oggetto della mia classe con un'istruzione del tipo:
A *variabile = new A("pippo");
Cosa succede? Viene creato un oggetto string (da passare come argomento)
esattemente come se io facessi...
A *variabile = new A(string("pippo"));
E come fa il compilatore a sapere di usare il costruttore A(string)
e non un'altro costruttore? Infatti "pippo" e' un'array di char che a me
(che vengo dal C) pare una cosa un po diversa da un'oggetto string.
E se io volessi aggiungere un'altro costruttore alla mia classe che avesse
come argomento un (char *)? Potrei farlo? Chi vincerebbe nel caso
di una chiamata del tipo:
A *variabile = new A("pippo");
Ehila' quante domande ha un niubbo eh :D
Bye e Grazie
P.S. Ah mi sono scaricato "Thinking in C++" Edizione 2 Volume 1 di Eckel.
Ovviamente potete sbrigativamente segnalarmi cosa leggere su quello per
chiarire i miei dubbi.

 allora č un *orrore*! :-)


 chiarire i miei dubbi.
Tutto, specie il capitolo introduttivo, lol.
Ciao,
-- 
Matteo Settenvini
FSF Associated Member
Email : 
mat...@member.fsf.org
-----BEGIN GEEK CODE BLOCK-----
Version: 3.12
GCS d--(-) s+:- a-- C++ UL+++
P?>++ L+++>$ E+>+++ W+++ N++ o?
w--- O- M++ PS++ PE- Y+>++
PGP+++ t+ 5 X- R tv-- b+++ DI+
D++ G++ e h+ r-- y?
------END GEEK CODE BLOCK------

 chiarire i miei dubbi.
Tutto, specie il capitolo introduttivo, lol.
