Mensajes

Te da para unos 49 días.

En cualquier caso, puedes usar time(), que hasta el año 2038, te funcionará sin problema xD
Claro que tratarás con segundos, no milisegundos.

Igualmente, ¿vas a tener un programa corriendo durante 50 días? Son caso 2 meses. Sin parar. Contando milisegundos durante 2 meses, es algo bruto. Utiliza segundos, o, si insistes, reinicia el programa cada X días (automaticamente, claro)

A todo esto, es recomendable que coloques algún sleep en el bucle, ya sea Sleep() de Windows, this_thread::sleep_for() de la estandar de C++11, o como veas.

Nah, nadie es bueno ni malo. Solo son puntos de vista

Bueno y malo son términos que deberían dejarse de usar xD
Podemos decir que malo es quien hace cosas contra el gobierno. Pero claro, luego salen grupos anti-goubernamentales a meter cizaña ._.

En ese método el que tiene la patente la puede vender simplemente prohibir que la compren los que no la van utilizar.

Sí, pero "los que no la van a utilizar" es un término muy inexacto ._.
El gobierno no va a tener peritos en cada empresa que haya comprado una patente. Por no decir, que una patente puede ser desde producir, hasta seguir investigando para posteriormente sacar partido.

Si comento yo, es difícil que no acabe así jajaja, pero hay que ser críticos e inconformistas,  la crítica es necesaria.

Críticos sí, inconformistas, no. Si vives conforme a lo que tienes, obtener algo mejor aumentará tu felicidad. Pura matemática.

Tener la patente de una tecnología ayuda a que no te roben su explotabilidad. Propiedad industrial, propiedad individual, ¿ahora también es eso malo? Además, tengo entendido que las patentes caducan a los ¿20? años de ser expedidas, con lo que la tecnología pasa a ser pública. Cualquiera que compre patentes para no explotarla, lo que consigue son una gran pérdida de dinero y 20 años con menos competencia, en caso de que eso sea lo que pretende.
Evidentemente, quien vende la patente, lo hace bajo su responsabilidad, y lo hace porque quiere. Ambas partes salen beneficiadas.

A parte, no hay post del foro libre donde no se acabe alguien metiendo con el gobierno...
.__.

A nivel práctico, el mutex es tan sencillo como lo dicho. Al llamar a lock(), se va a esperar hasta que se llame unlock, y sea su turno (puede haber varios hilos habiendo llamado al lock). No es más que eso. Ahora ya, impleméntalo como quieras.

Pero como he dicho, es atroz recorrer un array con un índice sabiendo que el array puede cambiar de tamaño en cualquier momento.

Mira tú. Ha hecho como hacen muchos hackers: buscar vulnerabilidades en la seguridad xD

Y lo ha hecho ya, ¿2 veces? Evidentemente tonto el tío no es, y si no como a un héroe, es digno de ser un ídolo entre los 'escapistas' xD

Y bueno, Al Capone también fue famoso, y no eran tan diferentes.
Cada uno que se dedique a su oficio jaja

Bueno, así estaríais obligando al que creó un producto a muchas veces no poder venderlo, lo que prácticamente es obligarle a explotarlo. Obligar a trabajar en un producto, que siquiera tiene por qué tener un gran futuro. ¿Sure?

Código (cpp) [Seleccionar] Expandir

Sleep(2000);

Eso sobraría. Una vez hecho el unlock, si el otro hilo ha invocado lock(), se meterá. No necesitas esperar.

En cualquier caso, recorrer el vector con un índice es muy inapropiado. Podría el otro hilo eliminar una direccion, y entonces tu índice se podría saltar algún elemento.

Lo que deberías hacer, es copiar el vector, y liberar el mutex.

No hay cabidad a la suerte en la programación...

Si les compran las patentes, entonces es culpa del que la vende xD

Código [Seleccionar] Expandir

¿cómo se debería de comportar el otro proceso que estaría recorriendo en ese momento los elementos del vector?

Cualquier operación de vector, incluyendo recorrerlo, ha de ser envuelta por el mutex.

Código (cpp) [Seleccionar] Expandir

#ifndef MUTEX_TYPE
#define MUTEX_TYPE

#include <mutex>

template<class T>
class MutexType{
    T _value;
    std::mutex _m;

public:
    MutexType(){}
    MutexType(T newValue):_value(newValue){}
    MutexType(const MutexType&)=delete;

    T& lock(){
        _m.lock();
        return _value;
    }

    void unlock(){
        _m.unlock();
    }
};

#endif // MUTEX_TYPE

Esta clase para envolver cualquier tipo en mutex, te puede ayudar. Claro que esta implementación basa su fiabilidad en el programador que la utilice, pues puedes hacer lock() y luego unlock() y seguir usando el objeto.

También puedes hacer funciones para trabajar con un objeto privado:

Código (cpp) [Seleccionar] Expandir

template<class T>
class Mutexvector{
    std::mutex _m;
    std::vector<T> _v;

public:
    void push_back(T value){
        _m.lock();
        _v.push_back(value);
        _m.unlock();
    }
    /* ... */

};

Uses mutex, uses variables, uses lo que quieras usar, simplemente tienes que entender que acceder a contenido dinámico y modificarlo desde varios hilos (o ya incluso contenido estático), puede dar muchos problemas.