Newsgroup: it.comp.lang.c++
Titolo: utilizzo di libreria che richiede char*

ciao a tutti,
in programma "puro C++" devo interagire con una libreria di funzioni
che richiede come parametri dei char*.
non volendo usare char* nelle mie classi, bensi' delle piu' comode "string",
stavo pensando a come fare
x abbinare le de cose.
ho prima provato solo con .c_str() ma restiruisce un const char*, quindi non
va bene...
allora ho pensato a const_cast. secondo voi va bene? e come dovrei fare x
non avere problemi?
string pippo("pippo");
funzione_libreria(const_cast<char*>(pippo));
va bene?
grazie a tutti!
ciao by Allanon

 non avere problemi?
No, non va bene, perche' non e' consentito modificare l'array puntato
dal valore ritornato da s.c_str(). Al tuo posto prenderei in
considerazione l'utilizzo di vector<char>, o come membri delle tue
classi o come buffer intermedi tra string e char*.
Se il progetto e' grosso valuta bene l'opportunita' di scrivere funzioni
di conversione implicite, anche se magari inline: in questo modo rendi
riconoscibili i punti dell'applicazione in cui hai effettuato le
conversioni, nel caso ti trovassi a dover modificare le cose in futuro.
Ciao,
Nicola

 Nicola
uhm, intendi qualcosa del tipo:
string pippo("pippo");
funzione_libreria(conversione_in_punt_char(pippo));
PS: che p***e sti problemi di compatibilita' C/C++!
non puoi scrivere una classettina che ti trovi a
litigare con strcpy strcat strqua... :-(
--
Ciao by Allanon

 funzione_libreria(conversione_in_punt_char(pippo));
Esatto. Magari funziona pure una classe tipo (scritta di getto e non
testata):
class conversione_in_punt_char {
  public:
    conversione_in_punt_char(std::string & ss) : s(ss),
v(s.begin(),s.end()) {}
    ~conversione_in_punt_char() { s.assign(v.begin(),v.end(); }
    operator char* () { return &v[0]; }
  private:
    std::string & s;
    vector<char> v;
};
Idealmente dovresti poterla sostituire direttamente nel tuo esempio qui
sopra. Se non sbaglio il valore temporaneo dovrebbe "restare in vita"
per il tempo necessario.
Ciao,
Nicola

 per il tempo necessario.
vedi sopra...

 o se la f(char *), rialloca il puntatore?
f non puo' riallocare il puntatore perche' non e' passato per reference,
pero' puo' copiare altrove l'array puntato. Questo e' un problema quando
si ha qualcosa come:
char * cp = ....;
cp = f(cp);
In effetti esistono diversi casi possibili:
- f non modifica l'array puntato ne lo copia: si puo' passare s.c_str()
(salvo problemi di legalita' di cast).
- f non copia l'array, ma lo modifica: vale la mia soluzione.
- f non modifica l'array, ma lo rialloca: si puo' passare s.c_str(), ma
poi bisogna gestire il risultato; presumibilmente ricopiarlo su s e
deallocare il nuovo array.
- f modifica l'array e poi lo copia: buttare la libreria e riscriverla
:-) 
Un altro problema al quale non avevo pensato e' che bisogna inserire
manualmente nel mio vector il terminatore di stringa.
Ciao,
Nicola

 
Non capisco cosa intendi. Nulla di quello che fai con l'argomento della
funzione avrà visibilità fuori di f(), giacchè il puntatore viene passato
per copia. Le cose sarebbero differenti se f() si aspettasse un reference
a un puntatore
   f( char * & p );
ma in questo caso il codice sopra (cioè f(&v[0]) ) non compilerebbe.
Max

 :-)
be', accade in alcune librerie, tra cui anche framework famosi. Credo 
anche windows SDK nella gestione degli unicode, ma dovrei rivedere le 
specifiche

 s.assign(v.begin(),v.end());
grazie! esempio chiarissimo! :-)
unico dubbio e' l'ultima istruzione, di cui non ho chiaro il motivo.
questo e' fatto per rendere consistenti le modifiche fatte nel vector con la
stringa, giusto?
perche' si presume che f modifichi la stringa.
se a me non interessa il valore ritornato potrei anche non farla, penso...
per gestire il terminatore(vedi altro tuo msg):
std::string s("prova");
std::vector<char> v(s.begin(),s.end());
v.push_back('\0');//<-------------------terminatore
f(&v[0]);
s.assign(v.begin(),v.end());
in altro msg scrivi: "In effetti esistono diversi casi possibili..."
quindi se non so cosa fa f non posso usare questa soluzione?
PS: grazie anche per l'esempio della classe...
--
Ciao by Allanon

 specifiche
Appunto :-)
Ciao,
Nicola

 quindi se non so cosa fa f non posso usare questa soluzione?
Diciamo che il tuo problema si puo' dividere in due parti:
- ottenere un puntatore da poter passare a f
- recuperare l'effetto di f
Per la prima parte la mia classe va sempre bene, anche se puo' risultare
esagerata; per la seconda dipende da come f agisce e da se ti interessa
che questi effetti "ricadano" sulla stringa originale.
Ciao,
Nicola