Newsgroup: it.comp.lang.c++
Titolo: Domanda stupida..

Salve,
io ho una variabile  int per esempio contenente 123;
come faccio a passare 123 in una variabile char* o in un array di char?
il mio problema è che ho una funzione che può prendere solo char e un'altra
che può ritornare solo int.. ; l' intero che ritorna una funzione deve
essere passato alla funzione che prende char... come faccio?!?
grazie

 wrote in message
news:EId%9.118285$0v.34...@news1.tin.it...

Non sei stato molto chiaro.
La funzione puo' prendere solo char o puo' prendere solo char* o array di
char???
Comunque sia ti faccio un esempio:
// questa funzione ritorna interi
int funInt()
{return  10;}
// questa accetta solo char
void funChar(char ch)
{/* fa qualcosa*/}
// e questa accetta solo char *
void funCharPoint(char * cp)
{/*fa qualcosa*/}
int main()
{
    int iTest = funInt();
    funChar((char)iTest);
    funCharPoint((char *)(&iTest));
    return 0;
}
La cosa importante pero' e' che l'intero che ti restituisce la funzione non
abbia valore superiore a 127 o inferiore a -128 altrimenti il suo valore,
trasformato in char cambierebbe.
Maurus

 wrote in message
EId%9.118285$0v.34...@news1.tin.it...

'sta funzione prende char* o un char?
int f1();
void f2(char *);
void f3(char);
int main()
{
int ris=f1();
f2(&ris); /*'&ris' può essere considerato un array di
char[sizeof(int)/sizeof(char)].
               *Attenzione al carattere nullo che termina ogni array di
caratteri...
               */
f3(ris); /*In questo caso, 'ris' viene troncato al suo byte meno
significativo.*/
return 0;
}
Saluti
--
Per l'e-mail rimuovere la frase in maiuscolo e gli underscore.

Scusatemi ma non mi sono spiegato bene. Allora:
vector<int> v;    //v è il mio template di tipo vector
vector<int>::iterator it; //it è un itaratore di tipo vector
it=v.begin();    //it lo faccio puntare al primo elemento del vettore (che
naturamlente è un intero sicuramente > di 127)
myfunc(" prende un puntatore a char");  // questa è la mia funzione che
prende (come si è potuto intuire un puntatore a char)
io devo passare alla funzione myfunc l' iteratore it (che in questo caso è
un puntatore a int), come faccio?
grazie per la disponibilità?
"Zero_su_win" <fiqpgc@_SPAMMER_AL_CONFINO_IN_SIBERIAtin.it> wrote in message
news:Ung%9.118989$0v.34...@news1.tin.it...



Houston, abbiamo un problema.
L'iteratore it non e' di tipo puntatore a int, ma e' di tipo
vector<int>::iterator, per cui non lo puoi passare a myfunc.
Cosa ci dovresti fare dentro myfunc col puntatore a char che gli passeresti?
Voglio dire, lo utilizzi solo in lettura o lo incrementi?
Non puoi cambiare il tipo del parametro formale di myfunc?
Maurus

 wrote in message
news:b1k7cg$145ohs$1...@ID-125555.news.dfncis.de...



Invece di volergli passare direttamente it, trasforma prima il contenuto di
it in una stringa (o un char *) e poi passi questo alla MessageBox.
In sostanza devi passare il *it alla funzione che ti trasforma interi in
stringhe:
// prova cosi'
#include <vector>
#include <sstream>
template <class Num>
  std::string to_string( Num n )
  {
    std::ostringstream oss;
    oss << n;
    return oss.str();
  }
// funzione che prende i char*
void MyMessageBox(char * str)
{
// fa quello che deve fare
}
int main ()
{
    std::vector<int> v;    //v è il mio template di tipo vector
    // qui fai le tue belle push_back per riempire il vettore v
    std::vector<int>::iterator it; //it è un iteratore di tipo vector
    it=v.begin();
    for (; it != v.end(); it++)
        MyMessageBox((char *)(to_string(*it)).c_str());
    return 0;
}
Maurus

 puntato dall'iteratore it. come faccio?
Se la funzione deve solo mostrare message e non modificarlo, allora
probabilmente prende un "char const *" e non un "char *".
Se la funzione vuole un (const) char * che punta a una c-style string
(cioe` un array di caratteri terminato da '\0'), come sembra
probabile, devi passargli una c-style string, non altre cose.
La domanda giusta non e` 
  "come infilare un int (int*, iteratore, ...) in un char* ?"
ma 
  "come ottenere una stringa che rappresenti l'intero puntato da it?"
Una possibile soluzione e` usare il template to_string di cui si sta
parlando in un altro thread:
  template <class Num>
  std::string to_string( Num n )
  {
    std::ostringstream oss;
    oss << n;
    return oss.str();
  }
Questo fa il passaggio  int -> string.
Per ottenere l'intero dall'iteratore basta un *.
Per ottenere una c-style string da una std::string c'e` il metodo
c_str().
Conclusione:
  MessageBox( to_string(*it).c_str(), ... );
che funziona se MessageBox prende un "char const *" e non gestisce la
memoria puntata da message.
        Mauro

 wrote in message
news:87r8apr...@localhost.localdomain...


 apparire un piccolo pop-up;
quindi tu vuoi convertire un intero in una stringa non in un char* (ok, 
in C le stringhe sono normalmente implementate con dei char*, ma c'e` 
una sottile differenza).
Visto che stiamo parlando di C++ direi che la soluzione migliore e` 
questa:
#include <string>
#include <sstream>
template<class T>
std::string to_string(const T& obj)
{
  std::ostringstream ost;
  ost << obj;
  return ost.str();
}
la funzione sopra converte un qualsiasi oggetto in una stringa 
(sempreche` l'oggetto fornisca l'appropriato operator<<).
Per convertire la stringa in const char* usa poi il metodo c_str():
std::vector<int> my_vect = ...;
std::vector<int>::iterator iter = my_vect.begin();
std::string s = to_string(*it);
MessageBox(s.c_str(), ...);
Nota una sola cosa: c_str() restituisce un const char* e tu dici di aver 
bisogno di un char*: le possibilita` sono due:
1) ti sei sbagliato a scrivere e in realta` MessageBox prende un const 
char*
oppure
2) le API di Win32 (immagino che stiamo parlando di win32 o MFC, vero?) 
sono belle tanto quanto il loro sistema operativo e pretendono un char* 
quando un const char* basta e avanza: in questo caso, se sei sicuro che 
MessageBox *non* modifica l'argomento (come mi sembra ragionevole) puoi 
tapparti il naso e fare un const_cast<> per rimuovere il const.
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra

quando un const char* basta e avanza
Ma cosa dici ! MessageBox accetta addirittura un codice fiscale:
LPCTSTR !
;-)
-- 
Andrea Laforgia
#exclude <windows.h>

 debug usa un proxy).
La libreria standard GNU, libstdc++, addirittura usa una classe
nell'implementazione "normale"; devo dire che tutto sommato lo
preferisco, perche' in questo modo si colgono al volo dei problemi di
"importabilita'".
Ciao,
Nicola

 "importabilita'".
come mai usa una classe? Qualche funzionalita` speciale?
ciao Anto
PS: tra l'altro libstdc++ e` quella che uso anche io, ma non me n'ero mai 
accorto: significa che ho sempre scritto codice portabile ;-)


 come mai usa una classe? Qualche funzionalita` speciale?
Del motivo effettivo non ne sono sicuro: me ne sono accorto compilando
del codice che inavvertitamente si appoggiava sull'aspettativa che
vector<>::iterator sia un puntatore.
Un vantaggio e' garantire cose come --v.end(), che possono essere
intese come promesse dallo standard, ma che non sono valide se
vector<>::end() restituisce un puntatore.
Ciao,
Nicola