En C++, el uso de punteros ya no es tan necesario. Para modificar variables y tal, prefiero mil veces las referencias.

El único uso que le veo a los punteros en C++ es para el polimorfismo. Para todo lo demás tienes las STL y las referencias:

unique_ptr<int> MemoriaDinamica(new int);
 
array<int,10> MemoriaDinamicaArray;
 
vector<int> MemoriaDinamicaVector(10);

Los punteros son suceptibles a los memoryleaks, las STL no ^^

Esos no son punteros crudos al viejo C xD

Yo los situaría como las referencias de C++ (aunque estas se pueden modificar).

A mí por lo menos no me compila.

Son detalles de la implementación de la librería (no es como una llamada a función, es más complejo...). En tal caso, usa ref para pasarlos parametros por referencia en la clase thread. Además el código queda bastante autoexplicativo (se ve que paramétros son por valor y cuales por referencia).

Y cada vez que tengas que adceder, con el * y los -> de marras. Quita, quita.

Los punteros son del pasado ^^

Vamos a ver, me lees cuando escribo o que?

De todas formas, también puedes hacerlo con join(). Te haces un array de threads (al principio, vacios) y cuando sepas que un hilo se ha cerrado haces join (además de hacer join antes de cerrar el programa).

Hay varios errores ahí.

El primero esque no asignas ningun identificador para el objeto thread:

thread unHilo(newClient,socket_s,socket_c,client);

Mejor asi, no te olvides después hacer un join() antes de terminar.

Por cierto, los argumentos con referencia deben de indicarse con ref. De modo que debería ser así:

thread unHilo(newClient,ref(socket_s),ref(socket_c),ref(client));

La idea es la perfecta sincronización, si vas a salir del programa tendrás que esperar a que terminen el resto de los hilos. De lo contrario podría tener efectos adversos.

La clase thread presupone que harás join en algún momento (al final del programa/funcion normalmente), si tu idea es dejar el hilo a tu aire tienes que usar detach():

thread t(hilo);
t.detach();

Pero pocos son los casos que es necesario tirar por ahí.

¿Sin usar join?

No, a no ser que te pongas un booleano de control en el hilo... Lo más natural sería el uso de condiction_variables.

No, una vez que haz hecho join no puedes ejecutar otra funcion.

Aunque si puedes aprovecharte del move-constructor y crear otro objeto thread:

thread t(hilo);
t.join();
 
t = thread(hilo2); // move contructor

No hay ningún problema ahí, nadie te garantiza que un thread van a ir al mismo tiempo (depende de los núcleos físicos que tengas, la carga del sistema...).

Si quieres un orden fijo, tendrás que sincronizar los threads con los mecanismos correspondientes.

---

Vale lo acabo de revisar y efectivamente has metido la gamba xD.

El problema está aquí:

thread test(hilo,1);
test.join();
thread test2(hilo,2);
test2.join();

Ponlo así:

thread test(hilo,1);
thread test2(hilo,2);
test.join();
test2.join();

El join no es para iniciar el thread, sino para esperar a que acabe xD

Funciones inlines  y optimizaciones del compilador activadas al máximo. Las macros son propensas a errores...

Si tienes un compilador moderno y tienes las optimizaciones activadas, el compilador hará las funciones inline cuando sea necesario.

¿Cuando no hará las funciones inline? Cuando por ejemplo, sea una función recursiva que el compilador no pueda "desenrollar" y convertir en un bucle.

No tienes permisos, por ello falla.

No puedes creartelo en la misma carpeta donde compiles? Asi solo tienes que introducir el nombre del archivo.