[SOLUCIONADO] ¿Cómo fijar un dato de una estructura a la hora de introducirlo?

[dehm]

Bueno, después de éste título tan farragoso, explico mi duda.
Son de esas cosas que no pensé que me daría la lata por su sencillez...y llevo dos días atascado.
Bueno, explico lo que quiero hacer:
Imaginad una estructura de datos:

Código C++:

struct poligono
{
    int n_lados;
    char[20] color;
};
 

En un momento dado, me interesa crear y definir varias instancias de la estructura, pero por comodidad quiero que algun dato quede fijado. Es como cuando en un entorno visual alguna columna ya aparece con un valor predefinido, pero éste puede ser modificado en cualquier momento.

Por ejemplo, tengo que meter 50 objetos polígono en una lista.
Si tengo 8 de ellos cuyo color es "verde", pues me gustaría que la función que crea e inserta los objetos en la lista no me pregunte por el color del mismo, y lo defina como "verde". Igualmente, que se pueda cambiar ese valor a otro, o que directamente me pida el dato del color a la hora de crear el objeto, si no hay ninguno predefinido.

En fin, espero haber sido claro con mi problema. Si no es así, por favor, preguntadme.

Y como siempre, gracias por adelantado!

[Profesor_Falken]

Si no me equivoco puedes declarar una macro:

Código C:

struct poligono
{
    int n_lados;
    char[20] color;
};
 
#define NEW_POLIGONO(P) struct poligono P = {.n_lados = 4, .color ="verde"}
 
[...]
/*Cuando quieras crear una estructura:*/
NEW_POLIGONO(miPoligono);
 

Un saludo

[eferion]

Para eso inventaron los constructores de C++:

Código C++:

struct poligono
{
    int n_lados;
    char[20] color;
 
    poligono( )
    {
      n_lados = 5;
      strcpy( color, "verde" );
    }
};
 
int main( )
{
  poligono poli; // este objeto tiene 5 lados y es de color verde
}
 

[dehm]

Hola Profesor_Falken:

No estoy seguro de entender tu planteamiento.
He desarrollado el constructor de la estructura en función de la solución que me propones:

Código C++:

#include <iostream>
#define NEW_POLIGONO(P) struct poligono P = {.n_lados = 4, .color ="verde"}
 
using namespace std;
 
struct poligono
{
    int n_lados;
    char color[20];
    poligono(int n, const char* c)
    {
        n_lados=n;
        strcpy (color,c);
    }
};
 
int main()
{
    NEW_POLIGONO(mipoligono);
    cout<<mipoligono.n_lados<<" - "<<mipoligono.color<<endl;
    return 0;
}
 

Y (obviamente) funciona. (Me apunto aprender a sacarle partido a las macros)
Pero no me da la flexibilidad que necesito o que quiero.
Sería algo así:

Código C++:

std::list<poligono>listapoligonos;
int num;
char aux[20];
char respuesta='S';
do
   {
    /*en algun momento del bucle de inserción de datos, me gustaría fijar algún dato de la estructura de forma que no tuviera que definirlo  en caso de encontrarme varios repetidos.*/
    /* Igualmente "desbloquear" ese dato cuando no me interese, y que me vuelva a pedir por él*/
 
    std::cin>>num;
    std::cin>>aux;
    poligono P(num,aux);
    listapoligonos.push_back(P);
    std::cout<<"¿Quieres introducir otro poligono?"<<std::endl;
    std::cin>>respuesta;
    }
    while (respuesta=='s' || respuesta=='S');
 

Gracias por la respuesta y disculpa si no la he entendido correctamente

[dehm]

Hola eferion:

Mientras escribía la respuesta a Profesor_Falken has escrito la tuya.
Ciertamente la macro del Profe es casi el equivalente al constructor.
Creo que la clave no está en el constructor, sino de cómo pido los datos para alimentar luego al constructor...ufff...es que estoy empanao esta mañana (y ayer, y antes de ayer....)

Mas o menos el psudocódigo podría ser éste:

Código C++:

bucle de entrada de datos
{
    //No me interesa prefijar ningun dato:
    entrar num_lados
    entrar color
    crear poligono P(num_lados,color)
    //durante un intervalo quiero fijar el color
    definir color, por ejemplo "verde"
    entrar num_lados
    crear poligono P(num_lados,color="verde")
    //en otro momento del bucle de entrada "desbloqueo" el color verde
    entrar num_lados
    entrar color
    crear poligono P(num_lados,color)
    //es decir, que en cualquier momento de la entrada de datos pueda fijar
    //alguno de ellos y que no me lo pida
}
 

P.D. Menudo pseudocódigo cutre

[eferion]

Si lo que quieres es crear varios componentes repetidos puedes optar por varias opciones:

1. Usar constructor copia

Código C++:

struct Test
{
  int valor;
 
  Test( )
    : valor( 0 )
  { }
 
  // Constructor copia
  Test( const Test& otro )
    : valor( otro.valor )
  { }
}
 
int main( )
{
  Test test;
 
  // Imprime '0'
  std::cout << test.valor << std::endl;
 
  test.valor = 21;
 
  // Llamamos al constructor copia
  Test test2( test );
 
  // Imprime '1'
  std::cout << test2.valor << std::endl;
 
  // También funciona, como era de esperar, dentro de bucles:
  for ( int i=0; i < 10; i++ )
  {
    Test temp( test );
    std::cout << test.valor << std::endl;
  }
}
 

2. Guarda los valores que quieres repetir en variables...

Código C++:

struct Test
{
  int valor;
 
  Test( )
    : valor( 0 )
  { }
};
 
int main( )
{
  int valor = 0;
 
  for ( int i=0; i < 10; i++ )
  {
    Test test;
    test.valor = valor;
 
    std::cout << test.valor << std::endl;
    std::cout << "Quieres reutilizar el ultimo valor? ";
    char respuesta;
    std::cin >> respuesta;
 
    if ( respuesta == 'n' )
    {
      std::cout << "Introduce el nuevo valor: ";
      std::cin >> valor;
    }
  }
}
 

[dehm]

Hola eferion:

Gracias por la respuesta. Se acerca a lo que yo quería simular.
El caso es que he hecho un planteamiento, que aunque funciona, no me gusta demasiado. Se trata de crear una estructura para tratar las respuestas a introducir.
A favor:
1.-Que funciona (o eso parece)
En contra:
1.-Demasiado farragoso
2.-Estas estructuras han de estar íntimamente ligadas a la estructura a la que sirven de soporte, y si ésta cambia hay que ir cambiando la estructuras que recogen las respuestas. Esto puede parecer trivial en este ejemplo, pero si tuviéramos algo más serio o más grande creo que no sería muy viable.

Pero lo pongo a ver qué opináis:

Mi estructura del polígono:

Código C++:

struct poligono
{
    int n_lados;
    char color[20];
    poligono(int n, const char* c)
    {
        n_lados=n;
        strcpy (color,c);
    }
};
 

La estructura que recoge la respuesta al dato n_lados:

Código C++:

struct respuesta_num_lados
{
    int numlados;
    bool bloqueado;
    respuesta_num_lados():bloqueado(false) {}
    void fijar (int n)
    {
        bloqueado=true;
        numlados=n;
    }
    void desbloquear()
    {
        bloqueado=false;
    }
};
 

Idem para el dato color

Código C++:

struct respuesta_color
{
    char color[20];
    bool bloqueado;
    respuesta_color():bloqueado(false) {}
    void fijar (char* c)
    {
        strcpy (color,c);
        bloqueado=true;
    }
    void desbloquear()
    {
        bloqueado=false;
    }
};
 

Y el programa que recoge la introducción de los datos:

Código C++:

int main()
{
    std::list<poligono>listapoligonos;
    respuesta_num_lados num;
    respuesta_color col;
    char respuesta='d';
    do
        {
            if (respuesta=='d' || respuesta=='D')
                {
                    cout<<"(1) Fijar Nº de lados"<<endl<<"(2) Fijar Color"<<endl<<"(3) Desbloq. nº lados"<<endl
                        <<"(4) Desbloq. color"<<endl<<"(5) Desbloq. ambos"<<endl<<"(ENTER) para seguir";
                    string opcion;
                    std::getline (cin,opcion);
                    if (opcion=="1")
                        {
                            int n;
                            cout<<"Numero lados: "<<endl;
                            cin>>n;
                            num.fijar(n);
                        }
                    if (opcion=="2")
                        {
                            char aux[20];
                            cout<<"Color: "<<endl;
                            cin>>aux;
                            col.fijar(aux);
                        }
                    if (opcion=="3")
                        {
                            num.desbloquear();
                        }
                    if (opcion=="4")
                        {
                            col.desbloquear();
                        }
                    if (opcion=="5")
                        {
                            num.desbloquear();
                            col.desbloquear();
                        }
                }
 
            if (!num.bloqueado)
                {
                    cout<<"Introduce nº de lados: "<<endl;
                    cin>>num.numlados;
                }
            if (!col.bloqueado)
                {
                    cout<<"Introduce color: "<<endl;
                    cin>>col.color;
                }
            poligono P(num.numlados,col.color);
            listapoligonos.push_back(P);
            cout<<"¿Quieres introducir otro poligono?"<<std::endl;
            cout<<"(S) para introducir (D) para fijar algun valor (N) Salir"<<std::endl;
 
            cin>>respuesta;
            cin.get();
        }
    while (respuesta=='s' || respuesta=='S' || respuesta=='d' || respuesta=='D');
    
    cout<<"Los poligonos son: "<<endl;
    for (auto it=listapoligonos.begin(); it!=listapoligonos.end(); it++)
        {
            cout<<(*it).n_lados<<" - "<<(*it).color<<endl;
        }
}
 

[Profesor_Falken]

Buenas,

Disculpa, en mi ejemplo con la macro yo entendia que estabas usando C y no C++.
En C++ efectivamente existen construcciones mas avanzadas como los constructores.

Respecto a tu problema, no se puede resolver de una forma muy sencilla con una variable global?

Puedes crearte una variable global llamada color_fijado. En principio estaria a null pero cuando quieras fijar un valor se lo asignas y la puedes volver a poner a null cuando quieras desactivar (lo mejor aqui seria crear una funcion que active/desactive).

Posteriormente en tu contructor lo podrias comprobar:

Código C++:

poligono(int n, const char* c)
    {
        n_lados=n;
        if (color_fijado == NULL) {
        strcpy (color,c);
        else {
         strcpy (color,color_fijado);
       }
    }
 

O mejor aun, tienes siempre un color_fijado y cuando llamas al constructor sin indicar el color utilizamos el color_fijado

Código C++:

struct poligono
{
    int n_lados;
    char color[20];
    poligono(int n, const char* c)
    {
        n_lados=n;
        strcpy (color,c);
    }
 
otro constructor que utilice el color_fijado
     poligono(int n)
    {
        n_lados=n;
        strcpy (color,color_fijado);
    }
};
 

Un saludo

[eferion]

Iniciado por dehm

Hola eferion:
Gracias por la respuesta. Se acerca a lo que yo quería simular.
El caso es que he hecho un planteamiento, que aunque funciona, no me gusta demasiado. Se trata de crear una estructura para tratar las respuestas a introducir.
A favor:
1.-Que funciona (o eso parece)
En contra:
1.-Demasiado farragoso
2.-Estas estructuras han de estar íntimamente ligadas a la estructura a la que sirven de soporte, y si ésta cambia hay que ir cambiando la estructuras que recogen las respuestas. Esto puede parecer trivial en este ejemplo, pero si tuviéramos algo más serio o más grande creo que no sería muy viable.

Creo que para el caso es más factible y limpio hacer uso un "gestor" que controle la generación de nuevos elementos:

Código C++:

class GestorPoligonos
{
  public:
 
    GestorPoligonos( )
      : ladosBloqueados( false ),
        colorBloqueado( false )
    {
    }
 
    void BloquearLados( int n )
    {
      ladosBloqueados = true;
      numLados = n;
    }
 
    void BloquearColor( const std::string& c )
    {
      colorBloqueado = true;
      color = c;
    }
 
    void DesbloquearLados( )
    {
      ladosBloqueados = false;
    }
 
    void DesbloquearColor( )
    {
      colorBloqueado = false;
    }
 
    Poligono NuevoPoligono( )
    {
      Poligono poli( numLados, color);
 
      if ( !ladosBloqueados )
      {
        std::cout << "Introduce nº de lados: ";
        std::cin >> poli.n_lados;
      }
 
      if ( !colorBloqueado )
      {
        std::cout << "Introduce color: ";
        std::cin >> poli.color;
      }
 
      return poli;
    }
 
  private:
 
    bool ladosBloqueados;
    bool colorBloqueado;
 
    int numLados;
    std::string color;
};
 

Con esto el main queda más limpio y despejado:

Código C++:

int main()
{
  std::list< Poligono > listapoligonos;
  GestorPoligonos gestor;
  char respuesta='d';
 
  do
  {
    if ( respuesta=='d' || respuesta=='D' )
    {
      std::cout << "(1) Fijar Nº de lados" << std::endl
                << "(2) Fijar Color" << std::endl
                << "(3) Desbloq. nº lados" << std::endl
                << "(4) Desbloq. color" << std::endl
                << "(5) Desbloq. ambos" << std::endl
                << "(ENTER) para seguir" << std::endl;
 
      int opcion;
      std::cin >> opcion;
      switch ( opcion )
      {
        case 1:
        {
          int n;
          std::cout << "Numero lados: ";
          std::cin >> n;
          gestor.BloquearLados( n );
          break;
        }
 
        case 2:
        {
          std::string color;
          std::cout << "Color: ";
          std::cin >> color;
          gestor.BloquearColor( color );
          break;
        }
 
        case 3:
        {
          gestor.DesbloquearLados( );
          break;
        }
 
        case 4:
        {
          gestor.DesbloquearColor( );
          break;
        }
 
        case 5:
        {
          gestor.DesbloquearLados( );
          gestor.DesbloquearColor( );
          break;
        }
      }
    }
    Poligono p = gestor.NuevoPoligono( );
    listapoligonos.push_back( p );
 
    std::cout << "¿Quieres introducir otro poligono?" << std::endl;
    std::cout << "(S) para introducir (D) para fijar algun valor (N) Salir" << std::endl;
 
    std::cin >> respuesta;
    std::cin.get( );
  }
  while (respuesta=='s' || respuesta=='S' || respuesta=='d' || respuesta=='D');
 
  std::cout<< "Los poligonos son: " << std::endl;
  std::for_each( listapoligonos.begin( ), listapoligonos.end( ),
                 []( const Poligono& p )
                 { std::cout << p.n_lados << " - " << p.color << std::endl; } );
}
 

PD.: me he tomado la libertad de cambiar "char[20]" por "std::string" en el poligono para que el diseño quede lo más limpio posible.

[dehm]

Iniciado por Profesor_Falken

Buenas,

Disculpa, en mi ejemplo con la macro yo entendia que estabas usando C y no C++.

No hay de qué darlas. No especifiqué el lenguaje y tengo la mala costumbre de usar structs de primeras cuando estoy enredando para no entretenerme en cuestiones de ámbitos públicos o privados e ir a la parte que quiero resolver, así que se presta a confusión. (Al final nadie me salva de convertir los structs en clases -AKA hacer las cosas 2 veces- o sea que no tiene mucha justificación lo que hago)

La solución que me propones era la que yo intuía cuando inicié el post, y que no fui capaz de darle forma, que es jugar con los constructores. Pero también le veo el problema de que debería de definir tantos constructores como miembros tenga la clase y...en definitiva, no me da la flexibilidad que querría.

Saludos y gracias!

[dehm]

Iniciado por eferion

Creo que para el caso es más factible y limpio hacer uso un "gestor" que controle la generación de nuevos elementos:

Brillante, esa es la pieza que faltaba para que la cosa funcione como deseaba.
¡Ni en mis próximas 50 vidas se me habría ocurrido crear una clase que gestionase los parámetros y retornase el objeto que quiero crear!

Gracias a ti y al Profe. Da gusto tener a gente así en el foro.
Saludos!