[SOLUCIONADO] Problema con set

[DvNe]

A ver, he creado una clase usuario para gestionar usuarios que tengan un id único, es por esto que en la parte privada de mi clase he hecho la siguiente declaración:

Código C++:

static set<Cadena> identificadores;
 

(El tipo cadena es una clase que he creado, que tiene las mismas características que un string).

Esta variable estática se inicializa a parte en un .cpp del siguiente modo:

Código C++:

set<Cadena> Usuario::identificadores;
 

Aquí muestro la función de construcción de usuario:

Código C++:

Usuario::Usuario (const Cadena& identificador, const Cadena& nombre, const Cadena& apellidos, const Cadena& direccion, const char* pass) : identificador_(identificador), nombre_( nombre), apellidos_(apellidos), direccion_(direccion), password_(pass) {
 
  IdValido();
}
 

y aquí la función IdValido() que la idea principal es que ya que, según lei, set::insert devuelve un tipo pair formado por un iterador y un tipo bool, inserto el id nuevo y si existe pues se lanza una excepción y si no existe pues se agrega el nuevo usuario:

Código C++:

bool Usuario::IdValido() const throw(Usuario::Id_duplicado) {
  pair<set<Cadena>::iterator,bool> i;
  
  i = identificadores.insert(id());
  if (i.second == false) {
    throw(Id_duplicado(id()));
    return false;
  } else {
    return true;
  }
}
 

Si compilo (compilando con g++ en Linux), obtengo un bad_alloc y según he estado viendo se produce al entrar a la función IdValido(). ¿Alguien me puede decir la razón?

[CalgaryCorpus]

Tal vez el problema está en el codigo que NO estas mostrando.
¿Puedes incluir tambien el codigo que usa la clase Usuario, o el codigo de id() ?

[DvNe]

USUARIO.H

Código C++:

#ifndef _USUARIO_H_
#define _USUARIO_H_
 
#include "cadena.h"
#include "clave.h"
#include "articulo.h"
#include <map>
#include <set>
using std::map;
using std::set;
 
class Usuario {
 public:
  //CONSTRUCTOR Y DESTRUCTOR
  Usuario (const Cadena&, const Cadena&, const Cadena&, const Cadena&, const char*);
  //~Usuario(); Aún no esta hecho
  
  class Id_duplicado {
  public:
    Id_duplicado (const Cadena& id) : id_duplicado(id) {}
    const Cadena idd() { return id_duplicado; }
  private:
    const Cadena id_duplicado;
  };
  //FUNCIONES OBSERVADORAS
  Cadena id() const { return identificador_; }
  Cadena nombre() const { return nombre_; }
  Cadena apellidos() const { return apellidos_; }
  Cadena direccion() const { return direccion_; }
  Cadena password() const { return (*this).password_.clave(); }
 
  //FUNCIONES CON TARJETAS 
  /* Aún no implementadas
  void es_titular_de(Tarjeta&);
  void no_es_titular_de(Tarjeta&);
  const Tarjetas& tarjetas() const;
  */
  
  //FUNCIONES CON LOS ARTICULOS
  typedef map<Articulo*, unsigned> Articulos;
  void compra(Articulo&, unsigned);
  const Articulos& compra() const { return articulos_; } 
  size_t n_articulos() const { return articulos_.size(); }
 
  //SOBRECARGA OPERADOR 
  friend std::ostream& operator << (std::ostream&, const Usuario&); 
  
 private:
  Cadena identificador_;
  Cadena nombre_;
  Cadena apellidos_;
  Cadena direccion_; 
  Clave password_;
  //  typedef map<Numero, Tarjeta*> Tarjetas;
  //   Tarjetas tarjetas_;
  Articulos articulos_;
 
  static set<Cadena> identificadores;
  bool IdValido() const throw(Usuario::Id_duplicado);
  Usuario (const Usuario&); //Deshabilitamos la copia de un usuario
};
 
void mostrar_carro(const Usuario&); //Falta cambiarlo a flujo de salida
//inline const Tarjetas& tarjetas() const { return tarjetas_; }
 
#endif
 

USUARIO.CPP

Código C++:

#include "usuario.h"
#include <iostream>
#include <iomanip>
 
using namespace std;
 
set<Cadena> Usuario::identificadores;
 
Usuario::Usuario (const Cadena& identificador, const Cadena& nombre, const Cadena& apellidos, const Cadena& direccion, const char* pass) : identificador_(identificador), nombre_( nombre), apellidos_(apellidos), direccion_(direccion), password_(pass) {
 
  IdValido();
}
 
bool Usuario::IdValido() const throw(Usuario::Id_duplicado) {
  pair<set<Cadena>::iterator,bool> i;
  
  i = identificadores.insert(id());
  if (i.second == false) {
    throw(Id_duplicado(id()));
    return false;
  } else {
    return true;
  }
}
 

El problema creo que está seguro al 100% en la función IdValido(), puesto que si la pongo como comentario o hago que siempre haga return true; el programa funciona correctamente

[CalgaryCorpus]

Aun no incluyes el codigo que usa la clase Usuario. Solo pusiste el código de ella. Creo que eso ayudará a completar el cuadro.

[DvNe]

Código C++:

#include "usuario.h"
#include <iostream>
#include <iomanip>
 
using namespace std;
 
set<Cadena> Usuario::identificadores;
 
Usuario::Usuario (const Cadena& identificador, const Cadena& nombre, const Cadena& apellidos, const Cadena& direccion, const char* pass) : identificador_(identificador), nombre_( nombre), apellidos_(apellidos), direccion_(direccion), password_(pass) {
  IdValido();
}
 
bool Usuario::IdValido() const throw(Usuario::Id_duplicado) {
  
}
 
ostream& operator << (ostream& output, const Usuario& user) {
  output << user.id() << " [" << user.password() << "] " << user.nombre() << " "
     << user.apellidos() << "\n" << user.direccion() << "\nTarjetas:\n";
  /* for (Tarjetas::iterator i = tarjetas.begin(); i != tarjetas.end(); ++i)
     output << (*i).second << "\n";*/
  return output;
}
 
void Usuario::compra (Articulo& articulo, unsigned cant = 1) {
  if (cant == 0) 
    articulos_.erase(&articulo);
  else 
    articulos_.insert(pair<Articulo*,unsigned>(&articulo,cant));
}
 
void mostrar_carro(const Usuario& user) {
 
  cout << "Carrito de la compra de " << user.nombre() << " [Articulos: "
       << user.n_articulos() << "]\n Cant. Articulo\n================="
       << "=========================================\n";
  for (Usuario::Articulos::const_iterator  p = user.compra().begin(); p != user.compra().end(); p++)
    cout << setfill(' ') << setw(4) <<  p->second << setw(4) << *p->first << "\n";
}
 

Este es el .CPP íntegro de USUARIO no hay nada mas. ¿Quieres que suba el Cadena.cpp?

[CalgaryCorpus]

Parece que no logro comunicarme.
El codigo que usa a la clase Usuario NO ES el codigo que implementa a la clase Usuario.

Debe ser algo asi como

Usuario u;
u.metodos();

o cualquier codigo que tengas que instancie objetos de esa clase.

Perdon por las confusiones.

[DvNe]

Ah claro fallo mio también ya estoy saturado que no encuentro la solución y ya estoy mareado de probar cosas jejeje. La clase usuario la utilizo en un main de prueba en el que voy probando las clases que voy añadiendo, aquí pongo el código:

Código C++:

#include "usuario.h"
#include "clave.h"
#include "articulo.h"
#include "numero.h"
 
using namespace std;
 
int main() {
  try {
    Usuario yo("1","Jose Ramon","Gago Gomez","Paseo del prado","joseramon");
    cout << yo << endl;
    Usuario yo1("2","Jose Ramon","Gago Gomez","Paseo del prado","joseRamon");
    cout << yo1 << endl;
    
    Fecha f1(0,0,1998);
    Articulo art1("110","Fundamentos de C++",f1,29.95,1);
    Fecha f2(0,0,2002);
    Articulo art2("111","Fundamentos BD",f2,25,50);
    try {
      Numero numer(" 123456  78123  45670  ");
      cout << numer << "\n";
      Numero numer1("4417 1234 56789 113  ");
      cout << numer1 << "\n";
      cout << boolalpha << (numer < numer1) << endl;
      cout << boolalpha << (numer1 < numer) << endl;
    } catch (Numero::Incorrecto e) {
      cerr << "Excepcion: NUMERO (" << e.razon() << ")"<<endl;
    }
    yo.compra(art1,21);
    yo.compra(art2,3);
    Usuario::Articulos::const_iterator p = yo.compra().begin();
    while (p != yo.compra().end()) {
      cout << *p->first << " |" << p->second << "\n";
      p++;
    }
    
    mostrar_carro(yo);
   } catch (Usuario::Id_duplicado e) {
    cerr << "Excepcion: ID (" << e.idd() << ") duplicado" << endl;
  }
  return 0;
}
 

[CalgaryCorpus]

Parece todo bien, excepto que no funciona.
Tomando todo el codigo que ofreces, hay varias clases desconocidas, las que deben ser culpables, o bien es el operator <<.
Para comprobarlo mira este codigo, tomado del codigo que has copiado aqui, pero que incluye clases vacias "Clave" y "Fecha", supone que "Cadena" es un string, y borré la clase Articulo y toda referencia a ella, borre gran parte del main().

Código C++:

#include <map>
#include <set>
#include <string>
#include <iostream>
using namespace std;
 
typedef string Cadena;
 
class Clave {
public:
  Clave( string s ) {}
  string clave() const { return ""; }
};
 
class Fecha
{
public:
  Fecha( int x, int y, int z ) {}
};
 
class Usuario {
 public:
  //CONSTRUCTOR Y DESTRUCTOR
  Usuario (const Cadena&, const Cadena&, const Cadena&, const Cadena&, const char*);
  //~Usuario(); Aún no esta hecho
 
  class Id_duplicado {
  public:
    Id_duplicado (const Cadena& id) : id_duplicado(id) {}
    const Cadena idd() { return id_duplicado; }
  private:
    const Cadena id_duplicado;
  };
 
  //FUNCIONES OBSERVADORAS
  Cadena id() const { return identificador_; }
  Cadena nombre() const { return nombre_; }
  Cadena apellidos() const { return apellidos_; }
  Cadena direccion() const { return direccion_; }
  Cadena password() const { return (*this).password_.clave(); }
 
  //FUNCIONES CON TARJETAS 
  /* Aún no implementadas
  void es_titular_de(Tarjeta&);
  void no_es_titular_de(Tarjeta&);
  const Tarjetas& tarjetas() const;
  */
 
  //SOBRECARGA OPERADOR 
  friend std::ostream& operator << (std::ostream&, const Usuario&);
 
 private:
  Cadena identificador_;
  Cadena nombre_;
  Cadena apellidos_;
  Cadena direccion_;
  Clave password_;
  //  typedef map<Numero, Tarjeta*> Tarjetas;
  //   Tarjetas tarjetas_;
 
  static set<Cadena> identificadores;
  bool IdValido() const throw(Usuario::Id_duplicado);
  Usuario (const Usuario&); //Deshabilitamos la copia de un usuario
};
 
set<Cadena> Usuario::identificadores;
 
Usuario::Usuario (const Cadena& identificador, const Cadena& nombre, const Cadena& apellidos, const Cadena& direccion, const char* pass) : identificador_(identificador), nombre_( nombre), apellidos_(apellidos), direccion_(direccion), password_(pass) {
 
  IdValido();
}
 
bool Usuario::IdValido() const throw(Usuario::Id_duplicado) {
  pair<set<Cadena>::iterator,bool> i;
 
  i = identificadores.insert(id());
  if (i.second == false) {
    throw(Id_duplicado(id()));
    return false;
  } else {
    cout << " Usuario con id " << id() << " aceptado" << endl;
    return true;
  }
}
 
int main() {
  try {
    Usuario yo("1","Jose Ramon","Gago Gomez","Paseo del prado","joseramon");
//    cout << yo << endl;
    Usuario yo1("2","Jose Ramon","Gago Gomez","Paseo del prado","joseRamon");
//    cout << yo1 << endl;
  }
  catch (Usuario::Id_duplicado e) {
    cerr << "Excepcion: ID (" << e.idd() << ") duplicado" << endl;
  }
 
  return 0;
}
 

Tu mision:
Prueba que este programa efectivamente funciona.
Incorpora las distintas clases anuladas a este codigo y prueba el main despues de cada reemplazo, sin modificaciones con la idea de solo ejercitar el constructor. Reemplaza una por una.
Luego, incorpora el operator <<
(o al inicio, como te parezca mejor), descomentando las lineas del main que la usan.

Al final incorpora el resto del main que borré.

Si descubres el error en este camino será bueno saber quien era el culpable.
Espero lo puedas compartir despues.

[DvNe]

El fallo me lo da cuando agrego la clase Cadena. He aquí la definición de la clase

Código C++:

#ifndef _CADENA_
#define _CADENA_
#include <iostream>
#include <stdexcept>
 
class Cadena {
 public:
  explicit Cadena (const size_t longitud = 0, const char cadena = ' ');
  Cadena (const Cadena& );
  Cadena (const char* );
 
  ~Cadena() {delete[] cadena_;}
 
  size_t longitud() const {return longitud_ - 1;}
  char* c_str() const {return cadena_;}
 
  Cadena& operator = (const char*);
  Cadena& operator = (const Cadena&);
  Cadena& operator += (const Cadena&);
 
  char operator [] (int pos) const {return cadena_[pos];}
  char& operator [] (int pos) {return cadena_[pos];}
  char at(size_t) const throw (std::out_of_range);
  char& at(size_t) throw (std::out_of_range);
 
  //  operator char*() const {return (*this).cadena_str();}
  Cadena subcadena (int, int) const throw(std::out_of_range);
  
  friend std::ostream& operator << (std::ostream&, const Cadena&);
  friend std::istream& operator >> (std::istream&, Cadena&);
 private:
  char *cadena_;
  size_t longitud_;
};
 
Cadena operator + (const Cadena&, const Cadena&);
 
 
bool operator == (const Cadena&, const Cadena&);
bool operator != (const Cadena&, const Cadena&);
bool operator < (const Cadena&, const Cadena&);
bool operator <= (const Cadena&, const Cadena&);
bool operator > (const Cadena&, const Cadena&);
bool operator >= (const Cadena&, const Cadena&);
#endif
 

Código C++:

#include <iostream>
#include <cstring>
#include <stdexcept>
 
#include "cadena.h"
 
using namespace std;
 
Cadena::Cadena (const size_t longitud, const char caracter) : longitud_(longitud+1) {
  cadena_ = new char[longitud_];
  for (size_t i = 0; i < longitud; ++i)
    cadena_[i] = caracter;
  cadena_[longitud] = '\0';
}
 
Cadena::Cadena (const Cadena &cadena1) : longitud_(cadena1.longitud() + 1){ // <------- AQUÍ ESTABA EL FALLO
  cadena_ = new char[longitud_];
  strcpy(cadena_,cadena1.c_str());
}
 
Cadena::Cadena (const char *cadena) : longitud_(strlen(cadena) + 1){
  cadena_ = new char[longitud_];
  strcpy(cadena_,cadena);
}
 
Cadena& Cadena::operator = (const char* cadena) {
  longitud_ = strlen(cadena) + 1;
  cadena_ = new char[longitud_];
  strcpy(cadena_,cadena);
  return (*this);
}
 
Cadena& Cadena::operator = (const Cadena &cadena1) {
  if (this != &cadena1) {
    delete[] cadena_;
    if (cadena1.c_str()) {
      longitud_ = cadena1.longitud();
      cadena_ = new char[longitud_];
      strcpy(cadena_,cadena1.c_str());
    }
    else 
      cadena_ = NULL;
  }
  return (*this);
}
 
Cadena& Cadena::operator += (const Cadena &cadena1) {
  Cadena cadena2 (longitud() + cadena1.longitud() + 1);
  strcpy(cadena2.cadena_,cadena_);
  strcat(cadena2.cadena_,cadena1.cadena_);
  (*this) = cadena2;
  return (*this);
}
 
char Cadena::at(size_t pos) const throw(std::out_of_range) {
  if (pos < 0 || pos > longitud())
    throw (std::out_of_range("Posicion fuera de rango"));
  else if ((*this)[pos] == 0)
    throw (std::out_of_range("Posicion inexistente"));
  else 
    return (*this)[pos];
}
 
char& Cadena::at(size_t pos) throw(std::out_of_range) {
  if (pos < 0 || pos > longitud())
    throw (std::out_of_range("Posicion fuera de rango"));
  else if ((*this)[pos] == 0)
    throw (std::out_of_range("Posicion inexistente"));
  else
    return (*this)[pos];
}
 
Cadena operator + (const Cadena &cad1, const Cadena &cad2) {
  Cadena aux(cad1);
  aux += cad2;
  return aux;
}
/* Tam_i no puede ser negativo */
Cadena Cadena::subcadena (int pos_i, int tam_i) const  throw(std::out_of_range) {
  if ((size_t) pos_i < 0 || (size_t) pos_i > longitud() - 1)
    throw (std::out_of_range("Posicion inicial fuera de rango"));
 
  if (tam_i < 0 || (size_t) pos_i + tam_i > longitud())
    throw (std::out_of_range("Posicion fuera de rango"));
 
  Cadena cadena (tam_i);
  size_t i = 0;
  for (size_t k = pos_i; k < (size_t) tam_i + pos_i; k++) {
    cadena.at(i) = at(k);
    i++;
  }
  return cadena;
}
/**
 * strcmp(x,y) 
 * Si x == y return 0;
 * Si x <  y return -1;
 * Si x >  y return 1;
 */
 
bool operator == (const Cadena &cad1, const Cadena &cad2) {
  return !(strcmp(cad1.c_str(),cad2.c_str()));
}
 
bool operator != (const Cadena &cad1, const Cadena &cad2) {
  return !(cad1 == cad2);
}
 
bool operator < (const Cadena &cad1, const Cadena &cad2) {
  if (strcmp(cad1.c_str(),cad2.c_str()) >= 0)
    return false;
  return true;
}
 
bool operator <= (const Cadena &cad1, const Cadena &cad2) {
  return cad1 < cad2 || cad1 == cad2;
}
 
bool operator > (const Cadena &cad1, const Cadena &cad2) {
  if (strcmp(cad1.c_str(),cad2.c_str()) <= 0) 
    return false;
  return true;
}
 
bool operator >= (const Cadena &cad1, const Cadena &cad2) {
  return cad1 > cad2 || cad1 == cad2;
}
 
ostream& operator << (ostream &output, const Cadena &c) {
  output << c.c_str();
  return output;
}
 
istream& operator >> (istream &input, Cadena &c) {
  char* entrada = new char[32];
  entrada[0] = '\0';
  input.width(32);
  input >> entrada;
  
  c = entrada;
  delete[] entrada;
  return input;
}
 

EDIT:: Vale ya encontre el fallo, retoco el codigo faltaba un +1 en el segundo constructor de la cadena T.T
Mil gracias por ayudarme

Ya que estoy me gustaría preguntar, la función externa mostrar_carro, deberá mostrar o imprimir el contenido del carro de compra de un usuario en
un flujo de salida, mi duda es

¿Un flujo de salida es un tipo de dato ofstream?

[CalgaryCorpus]

Algo mas que mejorar en el codigo, es que el tipo size_t nunca es negativo, por lo que comparar una variable de tipo size_t ( if( variable < 0 ) ) será siempre falso, o hacer cast antes, para luego comparar if( (size_t) variable < 0 ) tambien sera siempre falso.

Una explicación más profunda del problema a continuacion: (no apto para cardíacos)
El programa que mostrabas generaba un bad_alloc debido a que se intentaba hacer una reserva de memoria tan grande como el numero mas grande que cabe en un entero, esto debido a que el metodo longitud() hace calcula " longitud_ - 1 ", pero esto podria ser negativo cuando longitud_ vale 0 ? La respuesta es no, pues longitud() retorna un size_t (osea, siempre positivo, o cero).

Casi todo el código mostrado antes de presentar la definición de "Cadena" era inocente del problema que se presentaba.

[DvNe]

Vale entendido perfectamente, gran ojo tienes xD.

Intentare limpiar el código como dices. En cuanto a la duda del ofstream ¿me podrías guíar?

[CalgaryCorpus]

Para que el foro sirva, creo que es mejor que abras un tema aparte.
Quien busque ayuda en algo relacionado con ofstreams probablemente se aleje al ver el titulo de este tema ("Problema con set").