Mensajes

Hola a todos.
He estado leyendo acerca de para que sirve este keyword (volatile). Lo que he entendido es que sirve para que el compilador no haga ciertas optimizaciones de tipo "ignorar variables que no van a cambiar". Por ej. si tenemos:

Código [Seleccionar] Expandir


bool aux=false;
while(!aux){
  //Hacer cosas sin usar aux.
}


Lo que he entendido es que el compilador detecta que con 'aux' ya no se hace nada más y deja de hacer comparaciones con aux, o bien se da cuenta de que va ha hacer muchas comparaciones y lo mete en un registro de la CPU.

De tal manera que si tenemos el bucle anterior ejecutado por un hilo A  en background y otro hilo B pone 'aux' a cierto, el hilo A no "se entera" porque el compilador ha optimizado código para que deje de hacer comparaciones. (O si lo hace otro proceso, hardware ... )

Esta situación es la que soluciona el modificador "volatile".

Sin embargo lo he probado y ese problema anteriormente mencionado no ocurre, entonces ¿para qué sirve "volatile"?

Esta es la prueba que he hecho:

Código [Seleccionar] Expandir


#include <thread>
#include <mutex>
#include <iostream>

using namespace std;

bool shouldStop;

void pr1();

int main(){
thread th(pr1);
th.detach();
this_thread::sleep_for(chrono::milliseconds(3000));
shouldStop = true;
char *c;
cin >> c;
return 0;
}

void pr1(){
int i = 0;
while (!shouldStop){
cout<<"HOLA "<<i<<endl;
i++;
this_thread::sleep_for(chrono::milliseconds(1000));
}
}


Gracias y saludos.

Hace poco estuve googleando en busca de alguna keyword similar al "synchronized" de java pero para variables, y pregunté en algún foro (no recuerdo si en este también).
El caso es que en principio parecía que no, pero encontré una manera un tanto farragosa de hacer algo similar, la aporto y de paso pido correcciones si no es correcto algo de lo que digo:

Lo hago mediante propertys, simplemente declaro un objeto extra en mi clase (de tipo Object por ej., llamado 'lock'), y luego declaro la variable que quiero "synchronized" como si fuera property, y defino sus métodos get y set haciendo Monitor::Enter/Exit(lock); (obviamente usando una variable auxiliar para no caer en recursividad infinita). Se ve perfectamente con un ejemplo:

Código [Seleccionar] Expandir


//fichero de cabecera (.h)

ref class prPrty
{
public:
prPrty();

Thread^ thMethod();
void thAux();
int getA();

private:

property int a{
int get(){
Monitor::Enter(lock);
Thread::Sleep(3000);
return __a;
Monitor::Exit(lock);
}

void set(int _a){
Console::WriteLine("sin lock");
Monitor::Enter(lock);
Console::WriteLine("con lock");
Thread::Sleep(3000);
__a = _a;
Monitor::Exit(lock);
}
}

int __a;

Object ^lock;
};

/*********************************/

//Fichero fuente (.cpp)

#include "prPrty.h"


prPrty::prPrty(){
this->lock = gcnew Object();
}

Thread^ prPrty::thMethod(){
Thread ^th = gcnew Thread(gcnew ThreadStart(this, &prPrty::thAux));
th->Start();
return th;
}

void prPrty::thAux(){
this->a = 20;
}

int prPrty::getA(){
int aux;
Console::WriteLine("\tEsperando para el lock...");
Monitor::Enter(lock);
Console::WriteLine("\tlock obtenido");
aux = a;
Monitor::Exit(lock);
return aux;
}

/*********************************/

//main (.cpp)

int main(){
prPrty ^a = gcnew prPrty();
Thread ^th=a->thMethod();
Thread::Sleep(500);
Console::WriteLine("\t\t"+a->getA());
th->Join();
Console::ReadLine();
return 0;
}


Espero que le sirva a alguien de algo, saludos.

Gracias por la respuesta.

Si, la referencia de cpp ya le estuve mirando, y varias páginas más, ejemplos, en stackoverflow... pero no se por qué mi visual studio 2012 no reconoce esa excepción.

Y si que reconoce (que yo sepa) todas las características de c++11, por ej. la libería thread.

No se que pasa, igual es por ser el VS 2012 en lugar de 2013.

Seguiré buscando.

Saludos.

Hola a todos.

Estoy intentando implementar un método que en un determinado caso debería lanzar una excepción de tipo ios_base::failure pero mi visual studio no reconoce esa excepcion, aunque sí la ios_base.

Tampoco me deja lanzar una ios_base porque es un "tipo incompleto".

¿Alguien sabe como hacerlo? Gracias.

Ok, gracias por la respuesta.

Ye he visto que lo que quería hacer requiere, mas que nada, un SO en tiempo real.

No obstante he podido solucionarlo de manera que no tengo que ser tan preciso con el tiempo, la solución que he encontrado es hacer digamos hacer operaciones "extra" (sin tener que frenar el thread durante ese tiempo) y luego eliminar las operaciones realizadas sobrantes.

Saludos.

Hola a todos.

Mi pregunta es si es necesario o conveniente declarar e implementar destructores en clases administradas de C++/CLI (ref class) en caso de usar punteros nativos en éstas.

También me gustaría saber si el destructor de una clase administrada es llamado automáticamente al finalizar el main.

Gracias y saludos.

Ok gracias a todos por las respuestas.

Pero lo he solucionado de otra forma, eh conseguido usar una API mas moderna (que hasta ahora no había sido capaz de hacer funcionar por ciertos motivos) que tiene ejemplos mucho mejores y sobre todo una función getFrame() que permite mediante un parámetro pillar frames "nuevos". Es decir, le das a getFrame() y el programa se queda ahí esperando hasta que la cámarra le dice que ya tiene un frame nuevo, de tal manera que ya no pillo frames replicados. Intentaré seguir por ese camino.

Gracias de nuevo a todos, saludos.

OK, gracias por la respuesta.

Por preciso no me refiero a números altos, si no a muy bajos, a décimas de milisegundo.

¿Lo más apropiado para eso es stopWath?

Gracias y saludos.

Con "isCapturing()"? No se como calcular el tiempo con eso, una vez le das a startCapture() ya no para hasta que le das a stopCapture().

Lo único que me permite la cámara es "preguntarle" si está capturando (isCampturing()), pero saber cuando echa cada foto que yo vea no.

Hay otro método en la api que se llama captureImage() pero que en lugar de darme una imagen de 320*256*2 bytes me da solo 6, y todo ceros.

Sigo en ello...