Mensajes

Si no está en el formato que pides, está mal la entrada, ¿no?
En caso de que quieras aceptar esos códigos más largos... ¿Sabrías obtener loas 13 cifras que te interesan manualmente? Si es así, de la misma forma que lo haces manualmente, lo puedes hacer con el programa.

Si lo quieres multiplataforma, una opción es javascript, web.

Sinó, pues puedes probar con OpenAL. Aunque si nunca tocaste OpenGL ni OpenAL, puede ser una opción algo complicada.

http://www.fssnip.net/9s/title/Serial-Port-Reader

Ahí tienes un programa que usa en esencia lo que tú necesitas. Además, te sirve para conocer la sintaxis de F#.

También tienes aquí referencias concretas: https://msdn.microsoft.com/es-es/library/dd233181(v=vs.110).aspx


No conozco tutoriales de F#, y menos en Español. Esto e stodo.

Puedes guardar en una variable, que estará fuera de la función, la cantidad de intentos que  has hecho hasta ahora. Cada vez que fallas, la incrementas en 1. Si es igual a 3, muestras el mensaje y no le permites probar.

Mm te dejoe ste link que encontré con un ejemplo: http://www.morethantechnical.com/2013/11/09/vertex-array-objects-with-shaders-on-opengl-2-1-glsl-1-2-wcode/

El primer argumento de glVertexAttribPointer es el índice en el que almacenará el VBO. Luego, en el vertex shader, se asignará los valores del VBO a los attribute en las posiciones que mandaste en el primer argumento. (Todo esto lo ves mejor con el código de la web esa, los 2 primeros bloques de código)

No conozco documentación en español sobre hilos. Sin embargo, tras ver este tema, se me ocurrió retomar mi blog, e hice una entrada sobre threads, que quizás te sirva para comenzar en temas de threads (suponiendoq eu no los hayas usado nunca): https://code0x66.blogspot.com.es/2017/01/c-threads-hilos.html

Si ya tienes algo de experiencia con threads, comenta qué parte de ellos es de la que quieres información, y quizás sirva con una breve instrucción (?)

Ops, mal-leí **ddx.

Bien, solo 2 detalles:

iv. *dx es de tipo: Entero ( ¿valor de x? )

Sí

vi. **dx es de tipo: Este ya no estoy seguro.., no sé, si es una errata del ejercicio

No es error. **dx es el valor de x.
dx apunta a x. ddx apunta a dx. Por tanto, al poner *ddx, estás dirigiendote a la variable dx. Al poner otro *, estás dirigiendote a lo que apunta la variable dx.
**ddx es lo mismo que poner *(*ddx). *ddx es dx, así que eso "se convierte" en *(dx).

i. V + 3: v[3]

v. p+3: v[3]

dirección del cuarto elemento del vector, no v[3]. v[3] no es la dirección del cuarto elemento, ES el cuarto elemento.
Lo mismo para la otra.

[Entero]

Según las declaraciones int *dx = &x, **ddx = &dx;
i. x es de tipo: Entero
ii. dx es de tipo: Entero
iii. ddx es de tipo: Entero
iv. *dx es de tipo: Puntero a Entero
v. *ddx es de tipo: Puntero de Entero
vi. **dx es de tipo: Puntero a Puntero a Entero

Dadas las siguientes declaraciones int v[4] = 1, 3, 4, 5, *p; Qué valor
contiene:
i. V + 3: 5
ii. p después de la asignación p = &v[0]: 1
iii. *(p+3): 5
iv. p después de la asignación p = v: 1
v. p+3: 5

Aquí expongo las posibles respuestas, os agradezco que me corrigieseis, gracias.

Ahora, primera parte:
Para saber el tipo de una variable, normalmente te servirá con ver su declaración. Por ejemplo:

Código (c) [Seleccionar] Expandir

int *dx = &x;
No es int, es int*. Es un putnero a int, una dirección que apunta a un entero. Por esa razón se le asigna un valor con &x. x es un entero, así que &x es la dirección de un entero (int*).

Fuera de la declaración, cuando haces "*dx" no estás diciendo que es un putnero. Al revés, estamos accediendo al valor que apunta. *(int*) -> int.
Así, por ejemplo, *dx sería un entero (con el valor de x). Al poner * antes d euna variable (salvo en la declaración), digamos que "bajas" un nivel. Al poner &, "subes" un nivel. &x -> int*.
El resto te las dejo revisar :p

Y la segunda parte:
El valor de V+3 no es 5. El valor de *(V+3) SÍ es 5. Pero si no pone el *, entonces es una dirección. Es la dirección de ese 5, pero no es ese 5. *(p+3) sí que es ese 5, por ejemplo, proque tiene el *.
p = &v[0], lo mismo. No es 1, es la dirección de 1 (es decir, es igual a V): p = v es lo mismo que p = &v[0] (Poner [_] también "baja" un nivel, ya que, al fin y al cabo, es como poner un *)
*(p+3) == p[3]

Bueno, no ibas desencaminado. Solo tener cuidado con diferenciar la dirección de X con X. Y recordar que el significado de * y & en una declaración no es el mismo que fuera de ella.

Supongo que podrás responder a la mayoría. Hazlo, y dí qué parte del resto no sabes responder.

En cualquier caso, si no controlas aun los punteros, mira algún tutorial, comko: http://arco.esi.uclm.es/~david.villa/pensar_en_C++/vol1/ch03s04s04.html