headers, carpetas y menúes c++

[eferion]

Iniciado por Instru

Creo que lo de null object encontraste información que no es. Yo me refería al patron de diseño. En resumen es que tengas un campo o "algo" dentro de la clase o estructura Persona que identifique si el objeto es válido. Entonces en vez de regresar Null, o lanzar una excepción, regresas un objeto tipo Persona pero con el campo "valido" como falso. Aclaro, esto es un ejemplo.

Código:

return Persona(false);

Es sólo un ejemplo, debes mejorarlo.

Y si revisas mis respuestas encontrarás formas de implementarlo sin tener que modificar tu estructura.

Un saludo

[detective_jd]

Hola instru, gracias por responder, me sirvió lo que me dijiste, al final creé una función fantasma creando un objeto vacío:

ManPersonas.h

Código C++:

Persona getPhantom(){
        Persona p;
        p.id = 0;
        p.nom ="";
        p.ape ="";
        return p;
    }
    Persona getRow(std::string xnom){
        for(Persona p : lista){
            if(p.nom == xnom){
                return p;
            }
        }
        return getPhantom();
    }
    Persona getRow(int xid){
        for(Persona p : lista){
            if(p.id == xid){
                return p;
            }
        }
        return getPhantom();
    }
 

y en crud_per.h hice unos if para solucionar el problema en updated y deleted:

Código C++:

void updated(){   
    int op;
    string xnom;
    Persona p;
    xnom = addString("Nombre");
    p = getRow(xnom);
    if(p.id == 0){
        cout << "\n La persona deseada no existe :(" << endl;
    }
    else {
        cout << "\n Persona: " << p.id << " Nombre: " << p.nom << " Apellido: " << p.ape;
        cout << "\n ¿Desea algún dato? Aceptar=1/Cancelar=2 :";
        cin >> op;
        if(op == 1){
            cout << "\n ¿Desea editar el nombre ("<< p.nom <<") actual? Aceptar=1/Cancelar=2 :";
            cin >> op;
            if(op == 1){
                p.nom = addString("Nombre");
            }
            else {
                pause(2);
            }
            cout << "\n ¿Desea editar el apellido ("<< p.ape <<") actual? Aceptar=1/Cancelar=2 :";
            cin >> op;
            if(op == 1){
                p.ape = addString("Apellido");
            }
            else {
                pause(2);
            }
            if(update(p)){            
                cout << "\n persona editada :)" << endl;            
            }
            else {
                cout << "\n la persona ya existe :(" << endl;
            }
        }
        else if(op == 2) {        
            pause(2);
        }
        else {
            cout << "\n error :(" << endl;
        }
    }
}
void deleted(){
    int op;
    string xnom;
    Persona p;
    xnom = addString("Nombre");
    p = getRow(xnom);
    if(p.id == 0){
        cout << "\n La persona deseada no existe :(" << endl;
    }
    else {
        cout << "\n Persona: " << p.id << " Nombre: " << p.nom << " Apellido: " << p.ape;
        cout << "\n ¿Desea eliminar la persona seleccionada? Aceptar=1/Cancelar=2 :";
        cin >> op;
        if(op == 1){
            deleted(p);
            cout << "\n persona eliminada :)" << endl;
        }
        else if(op == 2) {        
            pause(2);
        }
        else {
            cout << "\n error :(" << endl;
        }
    }
}
 

Pero en ManPersonas.h con el update no me doy cuenta cómo editar, lo del if que me dijiste es para evitarlos duplicados en los nombres (en java usaba el equals), pero que debo usar de la lista para actualizar??

Código C++:

bool update(const Persona& p){ 
        Persona per = getRow(p.id);
        if(per.nom != p.nom){
            if(check(p)){
                return false;
            }
        }
        return true;
    }
 

Espero sus respuestas y saludos

[eferion]

El problema que tiene la función getRow es que sí, vale, es capaz de localizar un elemento en la lista y devolverlo si es que existe... pero te devuelve una copia del elemento. Devolverte una copia implica que no tienes forma de saber dónde se encuentra el elemento original, por lo que para actualizar el elemento en la lista tienes que volver a buscarlo... pero claro, no puedes utilizar getRow porque entonces estarás en las mismas. Siempre puedes copiar parte del código de getRow directamente en la función updated y retocarlo para que cumpla con tus intereses.

¿Solución coñazo? Sí, pero es más un problema asociado a tu diseño que a C++

Un saludo.

[Instru]

Creo que si getRow regresara un iterador, todo sería mas sencillo.

Saludos

[eferion]

Iniciado por Instru

Creo que si getRow regresara un iterador, todo sería mas sencillo.

... o un puntero

[detective_jd]

Hola eferion y Instru, ayer estaba complicado, pero hoy seguí probando y de esta forma me modifica pero la fila queda cómo último elemento de la lista:

Código C++:

bool update(const Persona& p){ 
        Persona per = getRow(p.id);
        if(per.nom != p.nom){
            if(check(p)){
                return false;
            }
        }
        lista.remove(per);
        lista.push_back(p);
    }
 

¿Que devuelva un iterator o un puntero? Instru te refieres a q use la función find, pero intenté usar el insert de la lista y no funcionó.....

Espero sus respuestas y saludos

[eferion]

Para poder modificar el elemento de la lista fuera de la función getRow necesitas que dica función devuelva algo que lo permita.

Devolver por valor un objeto de tipo Persona como estás haciendo actualmente no es la solución porque ese objeto no está relacionado de ninguna forma con la lista. Es simplemente una copia del elemento que se encuentra en la lista y modificar la copia no altera para nada el original ya que no hay relación alguna entre ellos.

En estos casos puedes devolver un iterador o un puntero.

Devolver un iterador tiene como ventaja que permite modificar la lista (puedes añadir un elemento antes o después del actual, puedes eliminar el elemento de la lista, ...) mientras que las desventajas pasan porque los iteradores son muy inestables (a nada que se modifique la lista el iterador puede quedar invalidado), y que la sintaxis de la función es más compleja y dependiente del tipo de contenedor que uses, lo que puede provocar problemas de mantenimiento. En el caso de tener que devolver la posición de un elemento que no está en la lista lo usual es devolver lista.end().


Un puntero no permite borrar elementos de la lista (pero eso en tu caso no es un problema pues ya tienes un remove), pero sí que permite modificar el elemento apuntado. Además la firma de la función getRow será más limpia y estable. En el caso de devolver un elemento que no está en la lista lo usual es devolver un puntero nulo (puntero=nullptr).

Puedes usar cualquiera de las dos opciones y será una solución válida. En tus manos queda.

Un saludo.

[Instru]

Como comentario adicional.
Que no getrow() esta haciendo la misma verificacion que check()? No basta con una?

Por otro lado. Igual, en vez de regresar un iterador o un puntero, regresar una referencia? He visto la flexibilidad que da esto cuando se implementa correctamente.
El único problema que le veo es que no se pueden regresar referencias nulas, por lo que de nuevo caes en usar el patrón de objeto nulo.

En fin.
Ya tienes 3 opciones diferentes.

Saludos

[detective_jd]

Hola eferion y Instru, gracias por responder, verán intenté hacer que me ordene después de modificar pero no logré implementarlo, Instru hice lo que me dijiste de simplificar y borré el check, quedándome el código de esta forma:

Código C++:

#include <list>
#include "Persona.h"
#include "Util.h"
#ifndef MANPERSONAS_H
#define MANPERSONAS_H
using namespace std;    
    std::list<Persona>lista;
    static int maxIdP = 0;
    int getMaxIdP(){
        return ++maxIdP;
    }
    Persona getPhantom(){
        Persona p;
        p.id = 0;
        p.nom ="";
        p.ape ="";
        return p;
    }
    Persona getRow(std::string xnom){
        for(Persona p : lista){
            if(p.nom == xnom){
                return p;
            }
        }
        return getPhantom();
    }
    Persona getRow(int xid){
        for(Persona p : lista){
            if(p.id == xid){
                return p;
            }
        }
        return getPhantom();
    }   
    bool create(const Persona& p){
        if(getRow(p.nom).nom != ""){
            return false;
        }
        else{
            lista.push_back(p);
            return true;
        }
    }
    bool update(const Persona& p){ 
        Persona per = getRow(p.id);
        if(per.nom != p.nom){
            if(getRow(p.nom).nom != ""){
                return false;
            }
        }
        lista.remove(per);
        lista.push_back(p);
    }
    void deleted(const Persona& p){
        lista.remove(p);        
    }
    std::list<Persona> read(){
        return lista;        
    }   
#endif  /* MANPERSONAS_H */
 

Sinceramente y no se enojen conmigo, pero lo que me sugieren lo tengo que ver implementado, ya que busque en google ejemplos de editar con lista, y no encontré nada, intenté implementar los ejemplos con iteradores.....
Los punteros no les agarro la mano...
Les pido disculpas por lo que escribo.

Espero su respuesta y saludos.

[eferion]

Código C++:

// v1
std::list<Persona>::iterator getRow(const std::string& xnom){
  auto lambda = [&xnom]
  ( const Persona& p)
  { return p.nom == xnom; };
 
  return std::find_if(lista.begin(),lista.end(),lambda);
}
 
// v2
std::list<Persona>::iterator getRow(const std::string& xnom){
  auto it = lista.begin();
 
  for( ; it!=lista.end(); ++it )
  {
    if( it->nom == xnom )
      break;
  }  
  return it;
}
 
// v3
Persona* getRow(const std::string& xnom){
  Persona* ptr = nullptr;
 
  for(auto& p : lista){
    if(p.nom == xnom){
      ptr = &p;
      break;
    }
  }
  
  return ptr;
}
 

No las he compilado luego no garantizo que estén libres de errores... pero deberían.

¿Qué problema tienes con los punteros? Trabajar con punteros es casi igual a trabajar con Java. Vale que en C++ hay algo más de curro pero tampoco es excesivo.

[detective_jd]

Hola eferion, gracias por responder, lo mio es falta de costumbre, tal vez con un tiempo programando no tenga tantas mañas con c++, pero quería pedirte en vista que estoy usando listas en este caso una lista enlazada y por el tema de los iteradores, quería pedirte si podrías ponerme el código del create, update, remove y read aadaptado según los iteradores o punteros, el que tu quieras, digo para no mirar de a poco (y sacar mejores conclusiones)...

Espero sus respuestas y saludos.

PD: Ya es de noche en mi país zzzz.

[eferion]

Para borrar un elemento de un contenedor conociendo su iterador:

Código C++:

contenedor.erase(it);
 

Para actualizar un elemento de un contenedor dado su iterador:

Código C++:

// para sustituir objetos por valor o sustituir punteros
*it=elemento;
 
// para copiar el contenido de un puntero en otro
**it=*puntero;
 

Lo mejor que puedes hacer es buscar un tutorial sobre iteradores. En el fondo un iterador no deja de ser una especie de puntero que te permite navegar entre los elementos de un contenedor. Esto te permite tanto modificar el contenedor como los elementos almacenados en el mismo

[detective_jd]

Hola eferion, gracias por responder, verás hice unos cambios al código, pero lo que me dijiste para sustituir el objeto no me funcionó, me dio raramente este error que tuve que comentar:

Consola:

g++ -c -g -std=c++11 -MMD -MP -MF "build/Debug/GNU-Linux-x86/main.o.d" -o build/Debug/GNU-Linux-x86/main.o main.cpp
In file included from crud_per.h:3:0,
from menu_per.h:2,
from main.cpp:2:
ManPersonas.h: In function ‘bool update(const iterator&)’:
ManPersonas.h:65:14: error: no match for ‘operator=’ (operand types are ‘Persona’ and ‘const iterator {aka const std::_List_iterator<Persona>}’)
*per = p; //-> lo que me dijiste me da el error de conversión desconocida
^
ManPersonas.h:65:14: note: candidates are:
In file included from ManPersonas.h:3:0,
from crud_per.h:3,
from menu_per.h:2,
from main.cpp:2:
Persona.h:4:8: note: Persona& Persona::operator=(const Persona&)
struct Persona{
^
Persona.h:4:8: note: no known conversion for argument 1 from ‘const iterator {aka const std::_List_iterator<Persona>}’ to ‘const Persona&’
Persona.h:4:8: note: Persona& Persona::operator=(Persona&&)
Persona.h:4:8: note: no known conversion for argument 1 from ‘const iterator {aka const std::_List_iterator<Persona>}’ to ‘Persona&&’
make[2]: *** [build/Debug/GNU-Linux-x86/main.o] Error 1

ManPersonas.h

Código C++:

#include <list>
#include <algorithm>
#include "Persona.h"
#include "Util.h"
#ifndef MANPERSONAS_H
#define MANPERSONAS_H
using namespace std;    
    std::list<Persona>lista;
    int maxIdP = 0;
    int getMaxIdP(){
        return ++maxIdP;
    }
    // me parece que el fantasma será inútil ahora....
    Persona getPhantom(){
        Persona p;
        p.id = 0;
        p.nom ="";
        p.ape ="";
        return p;
    }
    /*
    Persona getRow(std::string xnom){
        for(Persona p : lista){
            if(p.nom == xnom){
                return p;
            }
        }
        return getPhantom();
    }*/
    std::list<Persona>::iterator getRow(const std::string& xnom){
        return std::find_if(lista.begin(),lista.end(),[&xnom](const Persona& p){ 
            return p.nom == xnom; 
        });
    }
    std::list<Persona>::iterator getRow(int xid){
        return std::find_if(lista.begin(),lista.end(),[&xid](const Persona& p){ 
            return p.id == xid; 
        });
    }
    /*
    Persona getRow(int xid){
        for(Persona p : lista){
            if(p.id == xid){
                return p;
            }
        }
        return getPhantom();
    }*/
    bool create(const Persona& p){
        if(getRow(p.nom)->nom != ""){
            return false;
        }
        else{
            lista.push_back(p);            
            return true;
        }
    }
    bool update(const std::list<Persona>::iterator& p){ 
        std::list<Persona>::iterator per = getRow(p->id);
        if(per->nom != p->nom){
            if(getRow(p->nom)->nom != ""){
                return false;
            }
        }
       // *per = p; -> lo que me dijiste me da el error de conversión desconocida
        return true;        
    }
    void deleted(const std::list<Persona>::iterator& p){
        lista.erase(p);
    }
    std::list<Persona> read(){
        return lista;        
    }   
#endif  /* MANPERSONAS_H */
 

Por otro lado, haciendo pruebas al agregar un elemento, me salió esto de error:

Consola:

---CRUD Personas---

1. Crear Persona
2. Editar Persona
3. Borrar Persona
4. Mostrar Personas
5. Salir

intento nro 1 Ingrese Opción: 1

¿Desea crear una nueva persona? Aceptar=1/Cancelar=2 : 1

intento nro 1 Ingrese Nombre: juandy

intento nro 1 Ingrese Apelido: ocampo

RUN FINISHED; Segmentation fault; real time: 8s; user: 0ms; system: 0ms

crud_per.h - created

Código C++:

void created(){
    int op;
    cout << "\n ¿Desea crear una nueva persona? Aceptar=1/Cancelar=2 : ";
    cin >> op;
    if(op == 1) {
        Persona p;
        p.id = getMaxIdP();
        p.nom = addString("Nombre");
        p.ape = addString("Apelido");
        if(create(p)){
            cout << "\n persona creada :)" << endl;            
        }
        else {
            cout << "\n la persona ya existe :(" << endl;
        }                        
    }
    else if(op == 2) {        
        pause(2);
    }
    else {
        cout << "\n error :(" << endl;
    }
}
 

Espero sus respuestas y saludos

[detective_jd]

Hola eferion, ahora que lo recuerdo me dio el mismo error que cuando trataba de usar punteros y que lo resolví poniendo :

Código C++:

Persona* p = new Persona();
 

pero ahora que debo hacer para solucionar esto sin los punteros, ahí estoy medio perdido...
Perdonen mi lentitud con c++.

Espero sus respuestas y saludos.

[eferion]

Código C++:

bool update(const std::list<Persona>::iterator& p){
 

ManPersonas.h:65:14: error: no match for ‘operator=’ (operand types are ‘Persona’ and ‘const iterator {aka const std::_List_iterator<Persona>}’)

Consejo general: dedica algunas horas a aprender C++.

¿Por qué lo digo? Tengo mis razones:

• El & sirve para crear referencias. Una referencia tiene sentido si con ello evitas mover un volumen de datos importante o si necesitas modificar el estado de la variable y que dicho cambio sea visible fuera de la función. Un iterador es casi como un puntero y el tamaño que ocupa es mínimo (en el caso de std::list debería rondar los 8 bytes) luego no ganas nada pasando el dato por referencia. Si además indicas que la referencia es constante no podrás realizar cambios sobre dicha variable (de ahí el mensaje de error, que te está diciendo textualmente que no sabe cómo realizar una asignación sobre un objeto constante).
• Pasar un entero como referencia constante es otro detalle que no tiene sentido por lo comentado anteriormente. No aporta nada.
• Si no sabes usar las lambdas dedica un par de horas a estudiarlas. No son nada complicadas
• Implementando el constructor por defecto en Persona te podrías ahorrar el método getPhantom. Entendiendo además cómo funcionan los constructores y cuándo son llamados verías que no es necesario en dicha función tener las siguientes líneas:
  
  Código C++:

  p.nom ="";
  p.ape ="";
   

• Si getRow te devuelve un iterador es un suicidio asumir que dicho iterador va a ser siempre válido y tu lo estás asumiendo. Véase por ejemplo:
  
  Código C++:

  bool create(const Persona& p){
          if(getRow(p.nom)->nom != ""){
   

• No sabes leer los mensajes de error
• No sabes usar el depurador de código

Y dado que soy el único que te responde yo de ti me plantearía si no estás abusando un poco de la situación. Quizás deberías poner más de tu parte o por lo menos que se note que estás intentando aprender de tus errores. Que no entiendas C++ es una excusa que sirve un tiempo pero después deja de tener validez. Hay infinidad de recursos en Internet donde explican gran parte de los entresijos de C++. Vale que C++ es complicado, pero aun así al menos yo no veo mejoras por tu parte.

Un saludo.

[detective_jd]

Eferion, gracias por responder, verás nunca fue mi intención abusar de tu ayuda ni de nadie, no me ofende que digas que debo dedicarle horas a c++ xq no sé mucho de hecho los tipos de datos, los cout y cin, y lo poco de lo tradicional del c antiguo, cuando me dijeron de las estructuras std, me gusto, pero cuando me mencionaron sobre los punteros, iteradores y referencias, me fastidie y quedé mareado, ya te diste cuenta de eso.
Con esto te eigo que me pondré a hacer en un semana sin ayuda, empezando con el código anterior que tengo y veo cómo voy avanzando, si me quedó muy complicado escribiré por acá.
Tampoco uso mi poco conocimiento de c++ como excusa, porque lo dije en más de una ocasión...

Saludos y espero sus respuestas.

[detective_jd]

Hola eferion, aunque parezca mentira solucioné mis problemas con el crud que tenía, la clave estaba en el struct Persona.

Código C++:

#ifndef PERSONA_H
#define PERSONA_H
using namespace std;
struct Persona{
    int id;
    string nom;
    string ape;
    bool operator == (const Persona& p){
        return p.id == id;
    }
    // este operator < lo tuve que usar para ordenar mis datos
    bool operator < (const Persona & p) const
    {
        return id < p.id;
    }
};
#endif  /* PERSONA_H */
 

Y en el ManPersonas, luego de borrar, reinsertar, ordeno los datos para que al editar mis datos no tenga problemas con el orden

Código C++:

#include <list>
#include "../Model/Persona.h"
#include "../Lib/Util.h"
#ifndef MANPERSONAS_H
#define MANPERSONAS_H
using namespace std;    
    std::list<Persona> lista;
    int maxIdP = 0;
    int getMaxIdP(){
        return ++maxIdP;
    }
    Persona getPhantom(){
        Persona p;
        p.id = 0;
        p.nom ="";
        p.ape ="";
        return p;
    }    
    Persona getRow(std::string xnom){
        for(Persona p : lista){
            if(p.nom == xnom){
                return p;
            }
        }
        return getPhantom();
    }    
    Persona getRow(int xid){
        for(Persona p : lista){
            if(p.id == xid){
                return p;
            }
        }
        return getPhantom();
    }
    bool create(const Persona& p){
        if(getRow(p.nom).nom != ""){
            maxIdP--;
            return false;
        }
        else{
            lista.push_back(p);            
            return true;
        }
    }
    bool update(const Persona& p){ 
        Persona per = getRow(p.id);
        if(per.nom != p.nom){
            if(getRow(p.nom).nom != ""){
                return false;
            }
        }
        lista.remove(per);
        lista.push_back(p);
        lista.sort();
        return true;        
    }
    void deleted(const Persona& p){
        lista.remove(p);
    }
    std::list<Persona> read(){
        return lista;        
    }   
#endif  /* MANPERSONAS_H */
 

Ahora me quedan hacer andar bien las validaciones tanto en los string como en los enteros, en conclusión este código hecho comparado con lo que tu y Instru me dijeron es malo, pero para safar un poco da aunque debo mejorarlo...

Espero sus respuestas y saludos.

[detective_jd]

Y resulta eferion, que logré hacer las validaciones, pongo el código:

Código C++:

#include <ctime>
#include <ctype.h>
#include <cstring>
#ifndef UTIL_H
#define UTIL_H
using namespace std;
bool checkInt(string s){
    int cont =0;
    for(int i=0; i < s.size(); i++){
        if(s[i] >= 90 and s[i]<= 122) {
            cont++;
        }
    }
    return !s.empty() and cont == 0;
}
bool checkStr(string s){
    int cont =0;
    for(int i=0; i < s.size(); i++){
        if(s[i] >= 48 and s[i]<= 57) {
            cont++;
        }
    }
    return !s.empty() and cont == 0;
}
void pause(int dur) {
    int temp = time(NULL) + dur;
    while(temp > time(NULL));
}
string passUpper(string s){
    for(int i=0; i < s.size(); i++){
        s[i] = toupper(s[i]);
    }
    return s;
}
string addString(string type){
    int intento = 1;
    string nom = "";    
    while(!checkStr(nom)){
        cout << "\n intento nro "<< intento << " Ingrese " << type <<": ";
        cin >> nom;
        intento++;
    }
    return passUpper(nom);
}
 
int addInt(string type){
    int intento = 1;    
    string numero;
    while(!checkInt(numero)){
        cout << "\n intento nro "<< intento << " Ingrese " << type <<": ";
        cin >> numero;
        intento++;
    }
    return std::stoi(numero);
}
#endif  /* UTIL_H */
 

Mil gracias tanto a tí como a Instru.

Saludos.