Newsgroup: it.comp.lang.c++
Titolo: Conversione string to const char *

Come è possibile convertire una variabile di tipo string
in una const char * ?
static_cast<const char *>(nomevar) non funziona
--
Lawrence Oluyede
rhy...@myself.com

 
rhy...@myself.com

 
prova
const char* ptr = nomevar.c_str();

Usa const_cast.
forse non mi sono spiegato bene...
da Thinking in C++:
"
const_cast
 To cast away const and/or volatile.
"
io devo far questo:
Text::Text(string filename) {
// questa è l'istruzione incriminata...
// il const ce lo devo appiccicare e non togliere
  ifstream in(filename);
  string line;
  while(getline(in, line))
    str += line + "\n";
}
--
Lawrence Oluyede
rhy...@myself.com

const char* ptr = nomevar.c_str();
mmm grazie ora funziona
--
Lawrence Oluyede
rhy...@myself.com

static_cast<const char *>(nomevar) non funziona
La classe std::string ha un metodo 'c_str()' che restituisce appunto
un const char* della stringa.
Il Ghenio
---------
// TODO: Place your ass here

 >const char* ptr = nomevar.c_str();
Attenzione che il valore ritornato da c_str() puo' cambiarti sotto al
naso. Ti conviene copiare l'array puntato immediatamente.
Ciao,
Nicola

 naso. Ti conviene copiare l'array puntato immediatamente.
Uh? Mi spiegheresti meglio questa cosa?
Grazie
--
Gerolamo



Dopo una qualsiasi chiamata a una funzione membro non-const dell'oggetto
string, non c'č piů alcuna garanzia che il valore precedentemente
restituito da c_str() sia ancora un puntatore valido o che l'array di
caratteri a cui punta sia ancora terminato da un null.
Ad esempio, questo codice ha comportamento indefinito:
   std::string str("ciao");
   const char* cstr = str.c_str();
   str += " ciao";
   std::cerr << cstr << std:::endl
Copiarsi il valore restituito da c_str() non č in generale una buona idea.
Max

 Ad esempio, questo codice ha comportamento indefinito:
Non sono sicuro di aver capito.
Un codice del genere puň provocare problemi?
#include <iostream>
#include <string>
const char * strfun(const char * cstringa)
{
   std::string stringa(cstringa);
   stringa += " e baci";
   return stringa.c_str(); // questo puo' creare problemi?
}
int main()
{
   std::string saluti("Tanti saluti");
   const char * saluti_completi = strfun(saluti.c_str());
   std::cout << saluti_completi << std::endl;
}
--
Gerolamo
"Pongo X = Y    =>    X = Y / Pongo"
(Anonimo su un banco del Politecnico di Milano)

 // questo puo' creare problemi?
Sì, ma non per i motivi che ho spiegato nel mio precedente messaggio.
La validità del puntatore restituito da c_str() è comunque limitata al
tempo di vita della stringa. Si tratta di un puntatore a un array di char
la cui allocazione è unicamente sotto il controllo dell'oggetto
std::string. Quando la stringa è distrutta l'array non c'è più.
Nel mio messaggio davo per scontato che questo fosse chiaro e aggiungevo
(per spiegare il commento di Nicola) che anche il solo fatto di invocare
un metodo non const può invalidare un puntatore precedentemente restituito
da c_str().
Riassumendo, dopo la distruzione del oggetto std::string o dopo la
chiamata di metodo non const, qualsiasi valore precedentemente restituito
da c_str() non può essere usato.
Max

Ricapitolando:
std::string s("Quel che ti pare");
char * p = new char[s.size() + 1];
std::strcpy(p,s.c_str());
Ciao,
Nicola

 std::strcpy(p,s.c_str());
ok.
Allora vi espongo il mio problema:
se devo fare una funzione (o una libreria) che possa venir
chiamata anche da programmi non C/C++, che
debba manipolare delle stringhe, come faccio?
La mia prima idea era di prendere un char * in ingresso
e restituire un char * come valore di ritorno;
all'interno mi sembrava più logico lavorare con le std::string.
Ora non ho capito se un approccio di questo tipo nasconde
un errore (o un orrore...) oppure se va bene.
#include <string>
extern "C" char * strfun(char * cstringa)
{
   std::string stringa(cstringa);
   stringa += " quel che vuoi";
   char * p = new char[s.size() + 1];
   std::strcpy(p,s.c_str());
   return p;
}
--
Gerolamo

 }
Piccolo problema: sulla stringa ritornata deve essere chiamato delete[] (il
che significa che il programma deve essere C++), quindi almeno usa:
char *p=(char *)malloc(s.size() + 1);
che significa che sulla stringa ritornata si usa free. Però:
                 cout<<strfun("Ciao");
è scorretto, perché non chiami free sulla stringa restituita; bisogna per
forza fare così:
char * p=strfun("Ciao");
cout<< p;/*oppure ovviamente:*/
printf(p);
per evitare questo, tutte le funzioni della libreria C ricevono la stringa
in cui inserire il risultato come parametro; restituiscono poi il valore del
parametro, ma solo in analogia a a=b che restituisce a; è così possibile:
strcat(strcpy(stringaC, "parte1"), "parte2");//in questo esempio stringaC
punta a un'area già allocata da prima!
(tradotto in C++ diventa:
stringaCpp="parte1"+"parte2";
)

 in cui inserire il risultato come parametro;
Idea interessante.
Ci penserò, grazie!
--
Gerolamo

 Ci penserò, grazie!
Appunto... Se DEVI proprio allocare la memoria allora DOVRESTI anche fornire
un metodo per deallocarla, in modo che il chiamante possa dirti "ho finito,
libera questa stringa", passarti la stringa da deallocare e ritrovarsi
quindi in mano un puntatore a un'area di memoria liberata.
Quindi se usi new nella FreeMem (o come ti gira di chiamarla) della tua DLL
dovrai usare delete, se usi malloc() dovrai usare free().
ciaotutti,
*