Cómo definir un iterador en una clase std::map

Necesito ayuda para definir una especialidad map, no puedo obtener un mapa especializado:: iterador para compilar correctamente.

¿Cómo necesito definir este iterador para el find() llamar?

Código:

// My case-insensitive-less functor, which has historically worked fine for me:
struct ci_less : std::binary_function<std::string, std::string, bool>
{
  // case-independent (ci) compare_less binary function
  struct nocase_compare : public std::binary_function<unsigned char,unsigned char,bool>
  {
    bool operator() (const unsigned char& c1, const unsigned char& c2) const {
      return tolower (c1) < tolower (c2);
    }
  };
  bool operator() (const std::string & s1, const std::string & s2) const {
    return std::lexicographical_compare (s1.begin (), s1.end (),
                                         s2.begin (), s2.end (),
                                         nocase_compare());  // comparison
  }
};

//My offending code:
template <class T>
class CaseInsensitiveMap : public map<string, T, ci_less>
{
 public:
// This one actually works, but it requires two "find()" calls.
// I can't ethically call find twice.
  const T* lookup(const T& key) const {
    if (find(key) == map<string, T, ci_less>::end()) return 0;
    else                                             return &find(key)->first;
  }
// This one complains with errors shown below.
  T* lookup(const T& key) {
    CaseInsensitiveMap<T>::iterator itr = find(key);
    if (itr == map<string, T, ci_less>::end()) return 0;
    else              return itr->second;
  }
};

Errores:

En función de miembro 'T* CaseInsensitiveMap<T>::lookup(const T&)':
    error: esperado ';' antes 'itr'
    error: 'itr' no fue declarada en este ámbito

preguntado el 03 de mayo de 12 a las 20:05

No creo que std::map estaba destinado a ser heredado de. -

En el futuro, publique su código y errores en línea en lugar de vincularlos a un sitio externo. -

2 Respuestas

Agregue la typename palabra clave al tipo de su variable:

typename CaseInsensitiveMap<T>::iterator itr = find(key);

De todos modos, no deberías heredar contenedores STL. Lee sobre por qué no deberías hacerlo aquí.

Editar: Dado que todo lo que está implementando es un mapa que no distingue entre mayúsculas y minúsculas, puede implementarlo de esta manera, sin heredar std::map, simplemente proporcionando su propio objeto de comparación:

#include <iostream>
#include <map>
#include <string>

using namespace std;

struct nocase_compare {
    bool operator() (const unsigned char& c1, const unsigned char& c2) const {
      return tolower (c1) < tolower (c2);
    }
};

struct map_comparer {
  bool operator() (const std::string & s1, const std::string & s2) const {
    return std::lexicographical_compare (s1.begin (), s1.end (),
                                         s2.begin (), s2.end (),
                                         nocase_compare());  // comparison
  }
};

template<class T>
struct CaseInsensitiveMap {
    typedef std::map<std::string, T, map_comparer> type;
};

int main() {
    CaseInsensitiveMap<int>::type my_map;
    my_map["foo"] = 12;
    std::cout << my_map["FoO"] << "\n";
    my_map["FOO"] = 100;
    std::cout << my_map["fOo"] << "\n";
}

Esto produce:

12
100

contestado el 23 de mayo de 17 a las 13:05

escribe un nombre CaseInSensibleMap::iterator itr = find(key);

en la línea # 31

contestado el 03 de mayo de 12 a las 20:05

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.