Un dispositivo que use RFID, para controlar E/S...El SW debe permitir la gestion d elos usuarios quye van a entrar y salir con su respectiva Tarjeta RFID, debe permitir la asignación de la tarjeta al usuario, también la asignación de otra tarjeta al mismo usaurio en caso de perdida de la misma. gestion de horarios de entrada y de salida, el sistema debe marcar la hora de entrada y la hora de salida. calcular el tiempo entre una entrada de usaurio y su salida.

Aquí te presento un ejemplo de cómo podrías implementar un sistema de control de acceso con RFID en C++:

**Requisitos**

* Un dispositivo RFID que emita un código único para cada tarjeta.
* Un sistema de gestión de usuarios que permita asignar tarjetas a usuarios y gestionar horarios de entrada y salida.

**Estructuras de datos**

* `Usuario`: estructura que almacena la información de un usuario, incluyendo su nombre, apellidos y la tarjeta RFID asignada.
* `Tarjeta`: estructura que almacena la información de una tarjeta RFID, incluyendo su código único y el usuario al que está asignada.
* `Registro`: estructura que almacena la información de un registro de entrada o salida, incluyendo la fecha y hora de acceso, el usuario que accedió y el tipo de acceso (entrada o salida).

**Clases**

* `RFIDController`: clase que se encarga de leer y escribir en la tarjeta RFID.
* `UsuarioManager`: clase que se encarga de gestionar la información de los usuarios y sus tarjetas.
* `RegistroManager`: clase que se encarga de gestionar la información de los registros de entrada y salida.

**Código**

```cpp
#include <iostream>
#include <string>
#include <map>
#include <ctime>

// Estructura de datos para la tarjeta RFID
struct Tarjeta {
    std::string codigo;
    Usuario* usuario;
};

// Estructura de datos para el usuario
struct Usuario {
    std::string nombre;
    std::string apellidos;
    Tarjeta* tarjeta;
};

// Estructura de datos para el registro de acceso
struct Registro {
    time_t fecha;
    Usuario* usuario;
    bool entrada;
};

// Clase para controlar la tarjeta RFID
class RFIDController {
public:
    RFIDController() {}
    ~RFIDController() {}

    // Leer el código de la tarjeta RFID
    std::string leerTarjeta() {
        // Implementación de la lectura de la tarjeta RFID
        // (por ejemplo, utilizando un módulo RFID)
        return "1234567890";
    }

    // Escribir en la tarjeta RFID
    void escribirTarjeta(const std::string& codigo) {
        // Implementación de la escritura en la tarjeta RFID
        // (por ejemplo, utilizando un módulo RFID)
    }
};

// Clase para gestionar la información de los usuarios
class UsuarioManager {
public:
    UsuarioManager() {}
    ~UsuarioManager() {}

    // Agregar un usuario
    void agregarUsuario(const std::string& nombre, const std::string& apellidos) {
        Usuario* usuario = new Usuario();
        usuario->nombre = nombre;
        usuario->apellidos = apellidos;
        usuarios[nombre + " " + apellidos] = usuario;
    }

    // Asignar una tarjeta a un usuario
    void asignarTarjeta(const std::string& nombre, const std::string& apellidos, const std::string& codigo) {
        Usuario* usuario = usuarios[nombre + " " + apellidos];
        Tarjeta* tarjeta = new Tarjeta();
        tarjeta->codigo = codigo;
        usuario->tarjeta = tarjeta;
    }

    // Gestionar la pérdida de una tarjeta
    void perderTarjeta(const std::string& nombre, const std::string& apellidos) {
        Usuario* usuario = usuarios[nombre + " " + apellidos];
        delete usuario->tarjeta;
        usuario->tarjeta = nullptr;
    }

private:
    std::map<std::string, Usuario*> usuarios;
};

// Clase para gestionar la información de los registros de acceso
class RegistroManager {
public:
    RegistroManager() {}
    ~RegistroManager() {}

    // Registrar un acceso
    void registrarAcceso(const Usuario* usuario, bool entrada) {
        Registro* registro = new Registro();
        registro->fecha = time(nullptr);
        registro->usuario = usuario;
        registro->entrada = entrada;
        registros.push_back(registro);
    }

    // Calcular el tiempo de estancia
    double calcularTiempoEstancia(const Usuario* usuario) {
        Registro* registroEntrada = nullptr;
        Registro* registroSalida = nullptr;
        for (auto it = registros.begin(); it != registros.end(); ++it) {
            if (it->usuario == usuario && it->entrada) {
                registroEntrada = it;
            } else if (it->usuario == usuario && !it->entrada) {
                registroSalida = it;
                break;
            }
        }
        if (registroEntrada == nullptr || registroSalida == nullptr) {
            return 0.0;
        }
        return difftime(registroSalida->fecha, registroEntrada->fecha) / 60.0;
    }

private:
    std::vector<Registro*> registros;
};

int main() {
    RFIDController rfidController;
    UsuarioManager usuarioManager;
    RegistroManager registroManager;

    // Agregar un usuario
    usuarioManager.agregarUsuario("Juan", "Pérez");

    // Asignar una tarjeta al usuario
    usuarioManager.asignarTarjeta("Juan", "Pérez", rfidController.leerTarjeta());

    // Registrar un acceso
    registroManager.registrarAcceso(usuarioManager.usuarios["Juan Pérez"], true);

    // Calcular el tiempo de estancia
    double tiempoEstancia = registroManager.calcularTiempoEstancia(usuarioManager.usuarios["Juan Pérez"]);
    std::cout << "Tiempo de estancia: " << tiempoEstancia << " minutos" << std::endl;

    return 0;
}
```

**Nota**: Este código es solo un ejemplo y no es una implementación real. La lectura y escritura en la tarjeta RFID se han implementado de manera ficticia y no se ha utilizado un módulo RFID real. Además, la gestión de la pérdida de una tarjeta se ha implementado de manera sencilla y no se ha utilizado una base de datos para almacenar la información de los usuarios y sus tarjetas.