Ahora mismo pasa porque no es necesario limpiar el buffer, dado que no hay basura en stdin, es una de las buenas cosas que tiene fgets... Úsalo solo cuando veas que se salta un scanf o algo.

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.

Con fgets no debería salirte. El prototipo de fgets es este:

char * fgets ( char * str, int num, FILE * stream );

Donde str es un puntero donde se van a copiar num-1 carácteres , desde el archivo que le indiques, en este caso es el estándar de entrada.

Sí si te he entendido perfectamente ahora, pues lo que se me ocurre es que crees dos procesos con CreateProcess y mediante Pipes te comuniques con el stdout de una terminal y el stdin de otra. Te dejo unos enlaces:

http://msdn.microsoft.com/en-us/library/ms682512%28v=vs.85%29.aspx
http://msdn.microsoft.com/en-us/library/windows/desktop/aa365603%28v=vs.85%29.aspx

Otro enlace que tiene mejor pinta:

http://tenouk.com/cpluscodesnippet/pipeandchildprocess.html

Un código para abrir una cmd nueva, ya solo nos falta comunicarnos por ella mediante Pipes:

#include <windows.h>
#include <tchar.h>
 
int _tmain(int argc, _TCHAR* argv[])
{
    printf("Window A\n");
 
    STARTUPINFO          si = { sizeof(si) };
    PROCESS_INFORMATION  pi;
    TCHAR               szExe[] = _T("cmd.exe"); // <-- Could be any program
 
    if(CreateProcess(0, szExe, 0, 0, FALSE, CREATE_NEW_CONSOLE, 0, 0, &si, &pi))
    {
        // optionally wait for process to finish
        //WaitForSingleObject(pi.hProcess, INFINITE);
 
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
    }
    return 0;
}

¿Porqué dices que no puedes usar scanf directamente? Es exactamente lo mismo:

#include<stdio.h>
struct contacto
{
    char nombre[40],direccion[80];
    int edad;
    long telefono;
};
typedef struct contacto cont;
int main (void)
{
    cont c1;
    printf("Ingrese el nombre\n");
    scanf("%s",c1.nombre);
    printf("%s\n",c1.nombre);
    return 0;
}

En cuanto al gets , no deberías usarlo ya que lee una línea, que puede desbordar el array que le pasas como parámetro, al leer más caracteres de la cuenta de los que puede tener el array, así que para este caso, mi humilde opinión es usar fgets:

#include<stdio.h>
struct contacto
{
    char nombre[40],direccion[80];
    int edad;
    long telefono;
};
typedef struct contacto cont;
int main (void)
{
    cont c1;
    printf("Ingrese el nombre\n");
    fgets(c1.nombre,40,stdin);
    printf("%s\n",c1.nombre);
    return 0;
}

A esto me refiero con respecto al gets:

Llevas muchísima razón, lo mejor en ese código hubiese sido esto(utilizando variables locales en las funciones):

#include <stdio.h>
#include <stdlib.h>
 
void metrosAPies();
void piesAMetros();
 
int main ()
{
 
    int eleccion = 0;
    printf("CONVERSOR METROS-PIES\n");
    printf("---------------------------\n");
    printf("1. Metros a pies.\n");
    printf("2. Pies a metros.\n");
    printf("\nSelecciona numero: ");
    scanf("%d",&eleccion);
 
    if(eleccion == 1)
    {
        metrosAPies();
    }
    else if(eleccion == 2)
    {
        piesAMetros();
    }
    else
    {
        printf("\nNo ha seleccionado una opcion correcta.");
    }
    getchar();
    return 0;
}
 
void metrosAPies()
{
    float metros    = 0;
    float pies      = 0;
    printf("\nIntroduzca los metros a convertir: ");
    scanf("%f",&metros);
    pies = metros / 0.3048;
    printf ("\n%.2f pies son: %.2f metres\n",pies,metros);
}
void piesAMetros()
{
    float metros    = 0;
    float pies      = 0;
    printf("\nIntroduzca los pies a convertir: ");
    scanf("%f",&pies);
    metros = pies * 0.3048;
    printf("\n%.2f metros son: %.2f pies\n",metros,pies);
}

De nada, las funciones son sencillas, nada del otro mundo, lo más complicado que puedes ver ahí es la recursividad y el número variable de argumentos pero poco más . . .  ¡Que fallo! lo corrijo ahora mismo, es que hace poco he desactivado los avisos del compilador para que no me de el coñazo con algunos avisos innecesarios y se me ha olvidado activarlo.

Sí, cuando el programa va aumentando el valor en memoria de las variables, llega un momento según su cantidad en bits(8,16,32,64) en el cual estas llegan al punto de partida y vuelven a ser 0(o no, en este caso coincide ya que podría no coincidir si multiplicas en vez de aumentar), entonces cuando la variable numerodos sea 0, el resultado será 0 y todo se pondrá a 0.Puedes comprobarlo con este mismo código:

#include <iostream>
using std::cout;
using std::endl;
 
int main()
{
    int numerouno;
    int numerodos;
    int resultado;
 
    numerouno = 2;
    numerodos = 1;
    resultado = 0;
 
 
    while (numerodos != 0 )
    {
        resultado = numerouno *  numerodos;
        numerodos = resultado;
        cout << resultado << endl;
    }
 
    return 0;
}

Lo que pasa es que llega a ese valor tan rápido que solo ves 0 y no ves los valores que ves con este programa.

Has creado un proyecto WIN32 y al estar intentando buscar la función principal(es la misma que el main pero cuando se va a hacer un programa de ventanas con la API de Windows):

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd);

No la encuentra y te lanza un error, crea un proyecto de tipo consola y pega el mismo código, verás como funciona.

Bien pues vamos por partes al no poder usar funciones con parámetros vamos a ser chicos malos y usaremos variables globales, a las que podremos acceder durante todo el programa. Por lo tanto lo primero que tenemos que decirle al usuario es que si quiere convertir de metros a pies o de pies a metros, luego pedirle cuantos pies o cuantos metros desea convertir y luego cuando ya tengamos la entrada, pues decidir en base a eso y llamar a las funciones:

#include <stdio.h>
#include <stdlib.h>
 
float metros    = 0;
float pies      = 0;
 
void metrosAPies();
void piesAMetros();
 
int main ()
{
 
    int eleccion = 0;
    printf("CONVERSOR METROS-PIES\n");
    printf("---------------------------\n");
    printf("1. Metros a pies.\n");
    printf("2. Pies a metros.\n");
    printf("\nSelecciona numero: ");
    scanf("%d",&eleccion);
 
    if(eleccion == 1)
    {
        printf("\nIntroduzca los metros a convertir: ");
        scanf("%f",&metros);
        metrosAPies();
        printf ("\n%.2f pies son: %.2f metres\n",pies,metros);
    }
    else if(eleccion == 2)
    {
        printf("\nIntroduzca los pies a convertir: ");
        scanf("%f",&pies);
        piesAMetros();
        printf("\n%.2f metros son: %.2f pies\n",metros,pies);
    }
    else
    {
        printf("\nNo ha seleccionado una opcion correcta.");
    }
    getchar();
    return 0;
}
 
void metrosAPies()
{
    pies = metros / 0.3048;
}
void piesAMetros()
{
    metros = pies * 0.3048;
}

Durasno de todas maneras no ingresaba ni los metros ni los pies por lo tanto siempre iba a darle 0 de salida.

¡Un saludo!

---

kayron8 en tu código el principal problema es que no sabías como decidir lo que el usuario quería, además debías ingresar los metros o pies que querías. Tal y como posteaste el programa pies casi nunca sería igual que 1 dado que pies casi nunca sería 'p' y entonces al pasar al bloque de sentencias del else , al ser metros 0, 0/0.3048 = 0, por lo tanto a pies se le asignaba el valor 0 y por eso todo daba 0.