Como se abre 2 terminales en un programa [windows]?

esa no es la idea, lo que quiero es poder manejar 2 terminales una para recibir datos y otra para enviar...

xDD

Eso serviría si supiera como poner la terminal que abro, como la que se ejecuta al compilar que recibe datos de cout .

Creo que ahora me puedes a ver entendido mejor.

Gracias Avesudra  voy a mirar la info pasada.

EDIT: LOL que engorroso es...

Voy a aclarar las cosas porque yo me creía que con las pipes podía manejar cualquier proceso y no es así. Las pipes sirven para comunicar dos procesos, uno de ellos es el cliente, y otro el servidor. Lo que pasa es que hay que crear dos programas uno que mande datos por un pipe(servidor) y otro que lea datos por ese pipe y los muestre ( el cliente,una especie de stdout personalizado). Y para el de la entrada pues lo mismo. Por lo tanto los programas deben tener esto:

Servidor

---

• Llamar a CreateNamedPipe(..) para crear una instancia de un pipe con nombre.
• LLamar a ConnectNamedPipe(..) para conectar con el cliente.
• LLamar a WriteFile(..) para enviar datos por el pipe.
• LLamar a CloseHandle(..) para desconectar y cerrar la instancia del pipe.

Cliente

---

• Llamar a CreateFile(..) para conectar el pipe.
• Llamar ReadFile(..) para leer datos del pipe.
• Mostrar los datos por la pantalla.
• LLamar a CloseHandle(..) para desconectarse del pipe.

---

Así que ya sabes lo que tienes que hacer, no sé si hay una manera más fácil pero bueno no está mal aprender esto. Aquí te dejo un ejemplo de servidor y cliente:
Servidor:

///// SERVER PROGRAM /////
 
#include <iostream>
#include <windows.h>
using namespace std;
 
int main(int argc, const char **argv)
{
	wcout << "Creating an instance of a named pipe..." << endl;
 
	// Create a pipe to send data
	HANDLE pipe = CreateNamedPipe(
		L"\\\\.\\pipe\\my_pipe", // name of the pipe
		PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
		PIPE_TYPE_BYTE, // send data as a byte stream
		1, // only allow 1 instance of this pipe
		0, // no outbound buffer
		0, // no inbound buffer
		0, // use default wait time
		NULL // use default security attributes
	);
 
	if (pipe == NULL || pipe == INVALID_HANDLE_VALUE) {
		wcout << "Failed to create outbound pipe instance.";
		// look up error code here using GetLastError()
		system("pause");
		return 1;
	}
 
	wcout << "Waiting for a client to connect to the pipe..." << endl;
 
	// This call blocks until a client process connects to the pipe
	BOOL result = ConnectNamedPipe(pipe, NULL);
	if (!result) {
		wcout << "Failed to make connection on named pipe." << endl;
		// look up error code here using GetLastError()
		CloseHandle(pipe); // close the pipe
		system("pause");
		return 1;
	}
 
	wcout << "Sending data to pipe..." << endl;
 
	// This call blocks until a client process reads all the data
	const wchar_t *data = L"*** Hello Pipe World ***";
	DWORD numBytesWritten = 0;
	result = WriteFile(
		pipe, // handle to our outbound pipe
		data, // data to send
		wcslen(data) * sizeof(wchar_t), // length of data to send (bytes)
		&numBytesWritten, // will store actual amount of data sent
		NULL // not using overlapped IO
	);
 
 
	if (result) {
		wcout << "Number of bytes sent: " << numBytesWritten << endl;
	} else {
		wcout << "Failed to send data." << endl;
		// look up error code here using GetLastError()
	}
 
	// Close the pipe (automatically disconnects client too)
	CloseHandle(pipe);
 
	wcout << "Done." << endl;
 
	system("pause");
	return 0;
}

Cliente:

///// CLIENT PROGRAM /////
 
#include <iostream>
#include <windows.h>
using namespace std;
 
int main(int argc, const char **argv)
{
	wcout << "Connecting to pipe..." << endl;
 
	// Open the named pipe
	// Most of these parameters aren't very relevant for pipes.
	HANDLE pipe = CreateFile(
		L"\\\\.\\pipe\\my_pipe",
		GENERIC_READ, // only need read access
		FILE_SHARE_READ | FILE_SHARE_WRITE,
		NULL,
		OPEN_EXISTING,
		FILE_ATTRIBUTE_NORMAL,
		NULL
	);
 
	if (pipe == INVALID_HANDLE_VALUE) {
		wcout << "Failed to connect to pipe." << endl;
		// look up error code here using GetLastError()
		system("pause");
		return 1;
	}
 
	wcout << "Reading data from pipe..." << endl;
 
	// The read operation will block until there is data to read
	wchar_t buffer[128];
	DWORD numBytesRead = 0;
	BOOL result = ReadFile(
		pipe,
		buffer, // the data from the pipe will be put here
		127 * sizeof(wchar_t), // number of bytes allocated
		&numBytesRead, // this will store number of bytes actually read
		NULL // not using overlapped IO
	);
 
	if (result) {
		buffer[numBytesRead / sizeof(wchar_t)] = '\0'; // null terminate the string
		wcout << "Number of bytes read: " << numBytesRead << endl;
		wcout << "Message: " << buffer << endl;
	} else {
		wcout << "Failed to read data from the pipe." << endl;
	}
 
	// Close our pipe handle
	CloseHandle(pipe);
 
	wcout << "Done." << endl;
 
	system("pause");
	return 0;
}

Este código y la info la he sacado de http://avid-insight.co.uk/joomla/component/k2/item/589-introduction-to-win32-named-pipes-cpp

P.D: Creo que estoy en lo cierto, si algún usuario cree que no que lo diga.