En memoria, un array es un conjunto de elementos colocados uno delante de otro.
Al hacer "array[ x ]", accedes a la posición X en memoria. Ese X es un entero, que puede ser una constante, una variable, o el retorno de una función, mientras sea un entero.

También puedes crear un array de tamaño dinámico así:

int *array = (int*)malloc(sizeof(int)*5);

Como dato:

int array[5];
*(array + 2*sizeof(int)) == array[2];

Visto lo anterior, verás que, al acceder a una posición de memoria inexistente, 1 de 2: o da error, o muestra/sobreescribe memoria que tendrá valores teóricamente desconocidos.

http://www.minidosis.org/
C++, uno de los lenguajes que más te servirán.

El código es incorrecto. Le tienes que pasar el bool como referencia, sinó tendrá un valor inmutable.

thread ok(trabaja, &on, a);
 
trabaja(bool *on, string a)

o

thread ok(trabaja, ref(on), a);
 
trabaja(bool &on, string a)

"ok.get()"? "ok.join()"

Si te refieres a "vector" dentro del lenguaje, es de C++.

El problema de ese código, es que creas el array, pero no lo usas.

Lo importante de un array, es que se puede iterar por él. Se puede acceder a sus elementos en un bucle, cosa que con variables diferentes no puedes:

int i, array[10];
for(i=0; i<10; i++)
    printf("%i", array[i]);

Si quieres implementar un array en ese código, haz un bucle que encuentre el número más grande.

El problema de "cin<<", es que deja saltos de linea en el buffer de entrada sin leer. Cuando tratas de usar getline, coge esos saltos de linea, y no te deja meter datos. Con "cin.ignore()", eliminas esos saltos de linea.

Para leer en consola, te recomiendo usar siempre, salvo casos especiales:

string line;
getline(cin, line);

De ese modo, siempre obtendrás una cadena, y el buffer será limpiado correctamente.

Ahora bien, en caso por ejemplo, de que quieras interpretar la cadena como un entero, tienes las funciones:

int i = stoi(line); // String to int
unsigned long ul = stoul(line); // String to int
long long ll = stoll(line); // String to long long
float f = stof(line); // String to float
double d = stod(line); // String to double
long double ld = stod(line); // String to long double

Son de la librería <string>. Aquí puedes verlas todas: http://www.cplusplus.com/reference/string/

De este modo, utilizas siempre getline, y evitas utilizar cin<< y cin.ignore.

Lo ideal es que hagas eso para enviarlo, y luego, puedes utilizar Float.intBitsToFloat(int bits)

Esa función transforma un entero de 4 bytes (la cadena de bytes), a float.
Tendrías que transformar los 4 bytes que recibes en Java a un int.
Esto último lo puedes hacer rápido con ByteBuffer:

ByteBuffer bb = ByteBuffer.wrap(array); // array = 4 bytes float
// bb.order(ByteOrder.LITTLE_ENDIAN);
int n = bb.getInt();

"Little endian" y "big endian" son las formas de las que se guarda en memoria los datos, sin ir más lejos.

La linea comentada "order()", depende de si utilizas LITTLE_ENDIAN o BIG_ENDIAN. Por ejemplo, Windows utiliza little-endian. Bueno, solo puede ser LITTLE_ENDIAN y BIG_ENDIAN, en el peor de los casos, prueba y averigua cual es xD

En cuanto multiplicas un float, puede perder precisión, o puede perder valores en caso de que se salga del máximo.

Pero, ¿para qué multiplicarlo?
¿Qué quieres hacer con ese float?
Si haces:

float fl = 4.56;
char * floatBytes = &fl;

Tendrás en "floatBytes" un arreglo de 4 chars, que serán los valores del float en memoria. Luego ya si quieres, los copias o haces lo que quieras con ellos.

Pero... ¿Qué pretendes hacer?

new int(2)

Eso es para crear 1 int inicializado a 2.

new int[2]

Así es.


Y bueno, del segundo código comentar, que no aseguras de ningún modo que la variable 'c' seguirá existiendo cuando el thread acceda a ella.

Lo mejor que puedes hacer es no combinar el operador "<<" con "getline".
Utilizar siempre getline es la mejor solución.

Podría estar bien pero, no se ven muchas preguntas sobre matemáticas...