Wenas
aquí vengo con otra de esas intrigantes preguntillas del mundo de C++.
Sucede que estoy modificando la clase IniFile de ZaelSiuS; y en aras de hacerla non-case-sensitive, me puse a escribir una clase con sobrecargas de operadores y cosas raras que presento a continuación:
class caselessstr
{
private:
inline string UPPERCASE (const string Str)
{
string Tmp;
#ifdef WIN32
std::transform( Str.begin(), Str.end(), Tmp.begin(), toupper);
#else
std::transform( Str.begin(), Str.end(), Tmp.begin(), std::toupper);
#endif
return Tmp;
};
public:
std::string Data;
caselessstr () {};
caselessstr (const caselessstr &Src) {Data = Src.Data;};
caselessstr (const std::string &Src) {Data = Src;};
caselessstr (const char *Src) {Data = Src;};
~caselessstr () {Data.clear ();};
std::ostream &operator << (std::ostream &O) { O << Data; return O;};
//con Case-lessStr
caselessstr &operator = (const caselessstr &Src) {Data = Src.Data; return *this;};
bool operator == (const caselessstr &Src) {return (UPPERCASE (Data) == UPPERCASE (Src.Data));};
bool operator != (const caselessstr &Src) {return !(operator== (Src));};
bool operator < (const caselessstr &Src) {return (UPPERCASE (Data) < UPPERCASE (Src.Data));};
bool operator > (const caselessstr &Src) {return (UPPERCASE (Data) > UPPERCASE (Src.Data));};
bool operator <= (const caselessstr &Src) {return (UPPERCASE (Data) <= UPPERCASE (Src.Data));};
bool operator >= (const caselessstr &Src) {return (UPPERCASE (Data) >= UPPERCASE (Src.Data));};
//con std::string
caselessstr &operator = (const std::string &Str) {Data = Str.c_str (); return *this;};
bool operator == (const std::string &Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
bool operator != (const std::string &Src) {return !(operator== (Src));};
bool operator < (const std::string &Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
bool operator > (const std::string &Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
bool operator <= (const std::string &Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
bool operator >= (const std::string &Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};
//con const char *
caselessstr &operator = (const char *Src) {Data = Src; return *this;};
bool operator == (const char *Src) {return (UPPERCASE (Data) == UPPERCASE (Src));};
bool operator != (const char *Src) {return !(operator== (Src));};
bool operator < (const char *Src) {return (UPPERCASE (Data) < UPPERCASE (Src));};
bool operator > (const char *Src) {return (UPPERCASE (Data) > UPPERCASE (Src));};
bool operator <= (const char *Src) {return (UPPERCASE (Data) <=UPPERCASE (Src));};
bool operator >= (const char *Src) {return (UPPERCASE (Data) >=UPPERCASE (Src));};
};
dicha clase se usa de la siguiente manera:
typedef std::map< caselessstr, std::map< std::string, std::string> > IniMap;
typedef std::map< std::string, std::string> IniPair;
ahora, en realidad tengo 2 problemas:
1- al hacer algo como:
std::ofstream Archivo ("algo.txt", std::ios_base::trunc);
IniMap X;
//...
Archivo << X;
//...
El compilador me dice que NO existe un operador para "<<" que acepte un caselessstr del lado derecho.
No parece importarle el hecho de que la clase en realidad contiene una sobrecarga para tal efecto >_>
bien. Eso lo "solucioné" poniendo una sobrecarga del operador global "<<"
std::ostream &operator << (std::ostream &O, const caselessstr &Src)
{
O << Src.Data;
return O;
}
2-Luego de eso, esta cosa me marca error en el operador "<", alegando que
"no existe un operador que tome un operando del lado izquierdo del tipo caselessstr"
cuando en realidad la clase tiene el tan mencionado operador.
El error lo marca en el include (que imagino es parte del estandar)
template<class _Ty>
struct less
: public binary_function<_Ty, _Ty, bool>
{ // functor for operator<
bool operator()(const _Ty& _Left, const _Ty& _Right) const
{ // apply operator< to operands
return (_Left < _Right);
}
};
en ese "return (_Left < _Right)"
sugerencias?
bueno, pero no me ayuden todos a la vez T_T
El primer error/problema me parece lógico:
std::ofstream Archivo ("algo.txt", std::ios_base::trunc);
IniMap X;
Archivo << X;
// lo de arriba es lo mismo que
Archivo.operator<<( X ); // Meeec!, la clase std::ofstream no acepta IniMap en la sobrecarga de <<
Del segundo problema no me he enterado muy bien. ¿es un error de compilación?
Edit: ya lo he pillado. (pensando...)
A vore, ese error deberia venir de alguna llamada a función de la STL, tipo Sort o Transform, a la que le pasas un tipo no estándar sin operador < definido. Pero por más que miro tu código no sé qué llamada lo puede estar provocando, ya que empleas tipos std::string para std::transform, y no ccaseless.
y qué tal Find?
if ( m_map.find( section ) != m_map.end() && m_map[section].find( key ) != m_map[section].end() )
recuerdas? :P
-------------------------------------------------------------------
por cierto (Nota Aparte): encontré un leve problemilla en tu código
cuando en un .ini hay algo esto:
[Personaje]
Nombre = Juan Perez
...
Si le das un GetString a Nombre, sólo re regresa "Juan" y le importa un bledo el Perez
intenté arreglarlo, pero me salió peor el remedio que la enfermedad
y esque le he meneado tanto que ya no sé ni donde está el problema XD
(luego paso más detalles, cuando logre solucionarlo (nooo) )
Cita de: "ALRAZ"
por cierto (Nota Aparte): encontré un leve problemilla en tu código
cuando en un .ini hay algo esto:
[Personaje]
Nombre = Juan Perez
Valep, arreglado(aunque un poco chapucero, volveré sobre ello alguna tarde).
Tambien he añadido las funciones para consulta sobre secciones disponibles y sus nombres.
DescargarEnvíame todo el código de tu versión, a ver si logro arreglar el tema del operador < (o pon un enlace aquí). Quizá al compilar con Gcc me de alguna pista más.
perdona que no haya escrito nada todavía
ando un poco liao con esto y con la escuela
lo he hecho tantos ajustes (y sobretodo desajustes) que ya no sé si funciona o no XD
dame algo de tiempo