Hola amigos..

Estoy experimentando con el contenedor set y tengo duda con el operador de sobrecarga que se necesita para meter al contenedor un tipo creado por mi mismo...

Según estuve leyendo y alguien me dijo también que necesito sobrecargar el operador <

Pero este operador menor que, en que forma hace la comparación de elementos?, el contenedor set no permite objetos duplicados, no seria mas lógico sobrecargar == en vez de < para comparar si el elemento ya existe?

https://en.cppreference.com/w/cpp/language/operators
Aqui tienes todos los operadores explicados y con ejemplos.

Para comparar contenedores del mismo tipo y longitud se sobrecarga el operador == los elementos dentro de los contenedores del mismo tipo tambien deben ser elementos del mismo tipo.

La sobrecarga del operador << es para imprimir en pantalla los elementos del set.

Sí, así es. Necesitas sobrecargar el "operator<"; también puedes usar una función objeto (function object) que defina cuando uno de esos tipos es "menor que" el otro, y también puedes crear el set usando una expresión lambda como función de comparación. Las tres son funcionalmente equivalentes.

Un std::set contiene un conjunto ordenado de claves únicas, es por eso que necesitas una función que sirva para las dos cosas, definir el orden y garantizar unicidad. El operator< define un "strict weak ordering" (googlear) que es lo que necesita un std::set para establecer orden y unicidad, que se obtiene a partir de la relación de equivalencia (que no la igualdad), obtenida a partir del mismo operator<.

Rayos cósmicos... he intentado sobrecargar al menos el operador < .. pero algo no anda bien..  esta vez compila, pero no se comporta como esperaba

 
#include "pch.h"
#include <iostream>
#include <set>
 
class Usuario {
 
	char * nombre = nullptr;
 
 
public:
	Usuario() : nombre(new char[16]) {}
	~Usuario();
 
	void SetNombre(const char * _nombre);
 
 
	char * GetNombre() const {
		return this->nombre;
	}
 
	friend bool operator<(const Usuario & _thisUser, const Usuario & _otherUser);
 
 
};
 
Usuario::~Usuario() {
	delete[] nombre;
}
 
void Usuario::SetNombre(const char * _nombre) {
	strcpy(this->nombre, _nombre);
}
 
bool operator<(const Usuario & _thisUser, const Usuario & _otherUser) {
 
	for (int l = 0; l < 16; l++) {
		if (_thisUser.nombre[l] < _otherUser.nombre[l]) {
			return true;
		}
		else {
 
			if (_thisUser.nombre[l] == _otherUser.nombre[l])
				continue;
 
			else
				return false;
 
		}
	}
 
 
}
 
 
 
std::set<Usuario> usuarios;
 
int main(){
 
	char * _nombre = new char[16];
 
	for (int x = 0; x <= 3; x++) {
 
		system("cls");
 
		std::cout << "Ingrese nombre: ";
		std::cin >> _nombre;
 
		std::cout << std::endl;
 
		Usuario usuario;
		usuario.SetNombre(_nombre);
 
		usuarios.insert(usuario);   //ciclo 0 lo realiza bien
                                                      //al intentar guardar en el ciclo 1 se congela
 
	}
 
	delete[] _nombre;
	_nombre = nullptr;
 
	return 0;
 
}
 

He optado por set<> porque deseo ingresar usuarios y no deben repetirse...
Estoy casi seguro que no he sobrecargado correctamente el operador..

Primero voy a hacer algunos comentarios morales:

Estás aprendiendo C++, entonces:

0) necesitas un buen libro.

1) no uses new (y no uses delete). Son mecanismos para situaciones excepcionales. En la vida real, cuando un experto los usa, debe dar explicaciones, convincentes.

2) no uses system(), menos en algo como system("cls"); Si estás intentando aprender el lenguaje, ¿cómo es que ya has aprendido los vicios de un mal programador de hace 30 años?

3) no uses std::endl;  no lo necesitas. Quizá, si en algún momento te encuentras en las fronteras de alguna sofisticada arquitectura concurrente, bueno, en ese momento supongo que ya sabrás. Mientras tanto sólo molesta.

4) no uses strcpy(), estás llamando a la desgracia. Pero de todos modos, así como en C++ no se usan punteros tampoco se usan arrays, así que obviamente strcpy no tiene ninguna razón de ser.

Y un comentario técnico:

Tu programa tiene dos errores:

1) La función de comparación (tu operator<()) no tiene en cuenta cuando las dos cadenas son iguales. Puedes probar con:



2) estás usando delete dos veces sobre el mismo puntero.

En esta porción del

        Usuario usuario;  ///< creas un Usuario 
        // etcetera,,,
        usuarios.insert(usuario);   ///< insertas una copia de tu Usuario en el set.
 

El problema es que usuarios.insert() inserta una copia, y como no has definido qué es hacer una copia de un Usuario, el compilador ha sintetizado tanto el "copy constructor" como el "copy assignment operator", y en ese caso hace una "shallow copy" del puntero nombre.

Luego se está invocando delete[] dos veces sobre cada uno de los punteros. La primera vez cuando la variable local usuario sale de ámbito y la segunda vez cuando el set usuarios sale de ámbito (se invoca el destructor de sus elementos).
Puedes reemplazar tu destructor por este otro para ver que se está invocando dos veces delete[] para cada nombre:

Lectura:
https://en.cppreference.com/w/cpp/language/rule_of_three The rule of three/five/zero