[SOLUCIONADO] Crear una máscara para ver determinados miembros de una estructura

[dehm]

Hola:

Continuando con temas relacionados con miembros de una estructura, ahora me pregunto si sería posible asociar los datos a una máscara de forma que ésta última me dijese cuales datos serán visibles y cuales no.

He implementado la idea asociando la máscara (un array de bool) con un array de int.....claro, esto es lo fácil

Código C++:

#include <iostream>
using namespace std;
 
void ver(const bool *mascara, const int *secuencia,int numColumnas);
 
const int numColumnas=5;
 
int main()
{
    bool mascara[numColumnas]= {true,true,true,false,false};
    int numeros[numColumnas]= {4,8,6,3,7};
 
    ver(mascara,numeros,numColumnas);
 
    return 0;
}
 
void ver(const bool *mascara, const int *secuencia,int numColumnas)
{
    for (int i=0; i<numColumnas; i++)
    {
        if (mascara[i])
        {
            cout<<secuencia[i]<<" - ";
        }
    }
}
 

Pero lo que realmente me interesa sería implementar esa idea para los miembros de una estructura:
Algo como:

Código C++:

#include <iostream>
using namespace std;
 
struct datos
{
    int dato1;
    float dato2;
    char dato3;
    char dato4[5];
    bool dato5;
    datos():dato1(3),dato2(2.33),dato3('X'),dato5(true)
    {
        strcpy(dato4,"Pepe");
    }
};
 
void ver(const bool *mascara, const datos&D,int numColumnas);
 
const int numColumnas=5;
 
int main()
{
    datos D;
    bool mascara[numColumnas]= {true,true,true,false,false};
    ver(mascara,D,numColumnas);
return 0;
}
 
void ver(const bool *mascara, const datos&D,int numColumnas)
{
//realmente la idea sería intentar que los datos de la estructura se pudieran ligar
//al array que sirve de máscara para poder en un sólo bucle discriminar los datos
//visibles y los que no lo serán...vamos...como si los miembros de la estructura
//fueran un array
}
 

[leosansan]

Iniciado por dehm

Hola:

Continuando con temas relacionados con miembros de una estructura, ahora me pregunto si sería posible asociar los datos a una máscara de forma que ésta última me dijese cuales datos serán visibles y cuales no.
.................................................. .......

Pero lo que realmente me interesa sería implementar esa idea para los miembros de una estructura:
Algo como:
...........................................

Perdona por la tardanza amigo dehm pero es que tiene "miga" tu propuesta.

Después de darle bastantes vueltas al asunto me ha salido lo que sigue , que cumple con el cometido, pero creo que debería de haber alguna solución más sencilla.

Código C++:

#include <iostream>
 
using namespace std;
 
struct datos
{
    int dato1 ;
    float dato2 ;
    char dato3 ;
    char dato4 [ 5 ] ;
    bool dato5 ;
    datos():dato1 ( 3 ) , dato2 ( 2.33 ) , dato3 ( 'X' ) ,dato5 ( true )
    {
        strcpy ( dato4 , "Pepe" ) ;
    }
};
 
void ver ( const bool *mascara , const datos&D ,int numColumnas ) ;
 
const int numColumnas = 5 ;
 
int main ( void ) {
    datos D ;
    bool mascara [ numColumnas ]= { true , false , true , true , false } ;
    ver( mascara , D , numColumnas ) ;
return 0 ;
}
 
void ver(const bool *mascara, const datos&D,int numColumnas) { 
  if ( mascara [ 0 ] ) cout << D.dato1 << " - " ;
  if ( mascara [ 1 ] ) cout << D.dato2 << " - " ;
  if ( mascara [ 2 ] ) cout << D.dato3 << " - " ;
  if ( mascara [ 3 ] ) cout << D.dato4 << " - " ;
  if ( mascara [ 4 ] ) cout << D.dato5 << " - " ;    
}
 

La verdad es que aquí echo en falta algo tan elemental en Python como usar arrays cuyos elementos pueden ser de distintos "tipos" y claro todo es mucho más sencillo. Pero en fin, estamos en C/C++ y hay lo que hay.

Espero que te sirva al menos de orientación para otras opciones que se te puedan ocurrir. Y si eso sucede no te olvides de compartirlas aquí.

¡¡¡Saluditos!!!

[eferion]

Siempre hay soluciones.

En mi caso, yo primero declararía una clase que me permitiese manejar tipos de forma genérica (algo parecido a lo que echa de menos leosansan)

Código C++:

class Variant
{
  public:
 
    enum DataType
    {
      DTInt,
      DTChar,
      DTFloat
    };
 
    Variant( )
      : _type( DTInt )
    {
      _data.intData = 0;
    }
 
    explicit Variant( int valor )
      : _type( DTInt )
    {
      _data.intData = valor;
    }
 
    explicit Variant( char valor )
      : _type( DTChar )
    {
      _data.charData = valor;
    }
 
    explicit Variant( float valor )
      : _type( DTFloat )
    {
      _data.floatData = valor;
    }
 
    DataType Type( ) const
    { return _type; }
 
    Variant& operator=( int valor )
    {
      _type = DTInt;
      _data.intData = valor;
 
      return *this;
    }
 
    Variant& operator=( char valor )
    {
      _type = DTChar;
      _data.charData = valor;
 
      return *this;
    }
 
    Variant& operator=( float valor )
    {
      _type = DTFloat;
      _data.floatData = valor;
 
      return *this;
    }
 
    int ToInt( ) const
    {
      int to_return = 0;
      switch ( _type )
      {
        case DTInt:
          to_return = _data.intData;
          break;
 
        case DTFloat:
          to_return = static_cast< int >( _data.floatData );
          break;
      }
 
      return to_return;
    }
 
    float ToFloat( ) const
    {
      float to_return = 0.0;
      switch ( _type )
      {
        case DTFloat:
          to_return = _data.floatData;
          break;
 
        case DTInt:
          to_return = static_cast< float >( _data.intData );
          break;
      }
 
      return to_return;
    }
 
    char ToChar( ) const
    {
      char to_return = 0;
 
      switch ( _type )
      {
        case DTChar:
          to_return = _data.charData;
          break;
      }
 
      return to_return;
    }
 
  private:
 
    union Data
    {
      int intData;
      char charData;
      float floatData;
    };
 
 
    Data _data;
    DataType _type;
};
 

Se puede preparar para que admita más tipos, pero tampoco quería alargar demasiado el ejemplo.

Ahora necesitamos conectar esta clase con "cout" para poder imprimir el valor almacenado sin tener que andar haciendo cosas raras:

Código C++:

std::ostream& operator << ( std::ostream& stream, const Variant& variant )
{
  switch ( variant.Type( ) )
  {
    case Variant::DTInt:
      stream << variant.ToInt( );
      break;
 
    case Variant::DTChar:
      stream << variant.ToChar( );
      break;
 
    case Variant::DTFloat:
      stream << variant.ToFloat( );
      break;
  }
 
  return stream;
}
 

Ahora, por sencillez, modifico ligeramente la estructura. Prefiero eso a tener una función externa, pero para gustos los colores:

Código C++:

enum class Mascara
{
  Campo1,
  Campo2,
  Campo3
};
 
struct datos
{
    int dato1;
    float dato2;
    char dato3;
 
    datos( )
      : dato1( 3 ),
        dato2( 3.85 ),
        dato3( 'X' )
    {
    }
 
    Variant Valor( Mascara mascara ) const
    {
      Variant to_return;
 
      switch ( mascara )
      {
        case Mascara::Campo1:
          to_return = dato1;
          break;
 
        case Mascara::Campo2:
          to_return = dato2;
          break;
 
        case Mascara::Campo3:
          to_return = dato3;
          break;
      }
 
      return to_return;
    }
};
 

Y ahora ya enlazamos todo esto con la aplicación:

Código C++:

void ver(const std::vector< Mascara >& mascara, const datos&D);
 
int main()
{
  datos D;
  std::vector< Mascara > mascara { Mascara::Campo1, Mascara::Campo3 };
  ver( mascara,D );
  return 0;
}
 
void ver(const std::vector< Mascara >& mascara, const datos&D)
{
  for ( auto it = mascara.begin( ); it != mascara.end( ); ++it )
  {
    std::cout << D.Valor( *it ) << " - ";
  }
}
 

Et voilá. Todo funciona a pedir de boca XD

[dehm]

Hola leosansan....muchas gracias por la respuesta. Ciertamente yo también le daba vueltas al tema de cómo "obviar" el tipo. De hecho estaba trasteando con punteros void e intentando colársela al compilador con el nuevo tipo auto...pero no sé por qué siempre que intento hacer esas ñapas el compilador me corta el rollo rápidamente.

eferion....este tipo de respuestas me va a obligar a aprender C++
Ya en serio, muchas gracias. Y fuera de bromas necesito 2-3 horas (mínimo) para entender todas las cosas que has puesto. En cuanto lo tenga todo claro lo comento aquí....espero no tener que dar la lata de nuevo.

Gracias a ambos.

[eferion]

Iniciado por dehm

De hecho estaba trasteando con punteros void e intentando colársela al compilador con el nuevo tipo auto...pero no sé por qué siempre que intento hacer esas ñapas el compilador me corta el rollo rápidamente.

"auto" es una palabra clave que se sustituye por un tipo concreto (int, float, string) en tiempo de compilación. Para poder hacer esto, el compilador tiene que poder adivinar el tipo de la variable en tiempo de compilación. Por ejemplo:

Código C++:

auto variable; // Error de compilación, no se puede determinar el tipo
 
auto var2 = 45; // var2 será de tipo int
 

Además, dado que el tipo se determina en tiempo de compilación, éste no es mutable. Te lo explico con un ejemplo:

Código C++:

auto var1 = 4; // var1 será de tipo int
 
var1 = "Hola"; // Error de compilación, var1 no puede cambiarse a string
 

Espero que estos comentarios te aclaren los motivos por los que el compilador no aceptaba tus usos de "auto".

Iniciado por dehm

eferion....este tipo de respuestas me va a obligar a aprender C++
Ya en serio, muchas gracias. Y fuera de bromas necesito 2-3 horas (mínimo) para entender todas las cosas que has puesto. En cuanto lo tenga todo claro lo comento aquí....espero no tener que dar la lata de nuevo.

Lo de aprender C++ es una buena idea :)

Y no, preguntar dudas no es el equivalente a dar la lata.

Un saludo.

EDITADO:

PD.: La clase "Variant" se puede adaptar de forma sencilla para que trabaje también con strings, eso sí, dado que la clase string hace uso de memoria dinámica no es conveniente incluir la instancia de string dentro del union so pena de corromper la memoria:

Código C++:

class Variant
{
  public:
 
    enum DataType
    {
      DTInt,
      DTChar,
      DTFloat,
      DTString
    };
 
    explicit Variant( const std::string& valor )
      : _type( DTString )
    {
      _string = valor;
    }
 
    Variant& operator=( const std::string& valor )
    {
      _type = DTString ;
      _string = valor;
 
      return *this;
    }
 
  private:
 
    union Data
    {
      int intData;
      char charData;
      float floatData;
    };
 
    Data _data;
    DataType _type;
    std::string _string;
};
 

El resto de la implementación os la podéis imaginar :)

Un saludo.

[dehm]

Y fuera de bromas necesito 2-3 horas (mínimo) para entender todas las cosas que has puesto

Un mes después....

Me he quedado aquí:

Código C++:

enum class Mascara
{
  Campo1,
  Campo2,
  Campo3
};
 

No sé leer ésto

[eferion]

por partes:

Código C++:

enum Mascara
{
  Campo1,
  Campo2,
  Campo3
};
 

Esto se entiende, no? Un enumerado con varios elementos.

Código C++:

enum class Mascara;
 

Esta es una característica nueva de C++11. "class" hace que para acceder a los miembros del enumerado sea necesario indicar el nombre del enumerado:

Código con enum class

Código C++:

enum class Mascara
{
  Campo1
};
 
foo( Mascara::Campo1 );
 

Código con un enum típico

Código C++:

enum Mascara
{
  Campo1
};
 
foo( Campo1 );
 

Dicho con código, el efecto de "class" sería una estructura como la siguiente:

Código C++:

class Mascara
{
  public:
    enum Mascara
    {
      Campo1,
      Campo2,
      Campo3
    };
}
 

[dehm]

Gracias eferion:

Iba a editar el mensaje para decir que ya he leído el significado aqui:
http://www.cprogramming.com/c++11/c+...num-class.html

Pero gracias por tu explicación.
Bueno, pues seguimos estudiando tu código

Edito: Gracias eferion. Con alguna variación es eso lo que buscaba, y además he aprendido un montón con tu código.
Saludos!

[eferion]

Me alegro, en serio :)

Para cualquier duda que tengas, por aquí andamos

Un saludo.