mylab

repo: controlAviao

aviao:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo

#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex

#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes

typedef struct _MSG_AEROPORTO {
    TCHAR szMessagem[MSGTEXT_SZ];
    int pidMessagemControl; //aviao
    int pidMessagemAviao; //areoporto
    int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;

typedef struct _ControlData { //tipo de estrutura de dados de controlo
    HANDLE hSemBouncer; //semáforo
    //para o mutex
    HANDLE hMapFile, hRWMutex;
    Shared_MSG* shared; // ponteiro para memoria partilhada
    HANDLE newmsg; //ponteiro para o evento
    int continuar; // vairvel para terminar as threads
} CData;

//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
    Shared_MSG msg; //estrutura local


    while (pcd->continuar)
    {
        msg.pidMessagemAviao = GetCurrentProcessId();

        if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0 || (pcd->shared->pidMessagemAviao == GetCurrentProcessId() && pcd->shared->comando == 2))
        {
            _tprintf(TEXT("\ndone.."));
            break;
        }
        _tprintf(TEXT("\n[aviao: %d]Escreve mensagem (fim para sair)"), msg.pidMessagemAviao);
        wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
        //_tprintf(TEXT("%s\n"), msg.szMessagem);

        msg.comando = 1;
        WaitForSingleObject(pcd->hRWMutex, INFINITE);
        CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        //assinlar que há nova mensagem
        SetEvent(pcd->newmsg);
        //esperar que mensagem seja lida por outros processos
        Sleep(MSG_DELAY);
        //desativar evento
        ResetEvent(pcd->newmsg);
    }
    pcd->continuar = 0;
    _tprintf(TEXT("\nPrograma vai terminar"));
    //para desbloquear a outra thread e sair de imediato
    SetEvent(pcd->newmsg);
}

DWORD WINAPI recebe_msg(LPVOID p)
{
    CData* pcd = (CData*)p;
    Shared_MSG msg;

    while (1)
    {
        WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
        if (!pcd->continuar)
        {
            break;
        }
        WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
        CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        if (msg.pidMessagemAviao == GetCurrentProcessId()) {
            _tprintf(TEXT("\nProblemas com o nome do aeroporto"));
            msg.comando = 1;
        }
        else
        {
            _tprintf(TEXT("\n.."));
            //_tprintf(TEXT("\nRecebi: %s do %d"), msg.szMessagem, msg.pidMessagemControl);
        }

        Sleep(MSG_DELAY * 2);
    }
    //no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
    ResetEvent(pcd->newmsg);
    return 0;
}

BOOL comunicaAeroporto(BOOL valor)
{
    HANDLE sem; // Handle do semáforo
    CData cdata; //estrutura de dados de controlo
    DWORD tid; //estrutura de dados de controlo

#ifdef UNICODE 
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    cdata.hSemBouncer = CreateSemaphore(
        NULL, //atributo de segurança
        MAXUSERS, //começa o programa logo com o max users
        MAXUSERS, //limite de users
        SEM_BOUNCER_NAME //nome do semaforo
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nerro a criar semaforo"));
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("Semáforo criado\n"));
    }

    cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
        SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
        FALSE,
        SEM_BOUNCER_NAME
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("Semáforo aberto.\n"));
    }

    _tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
    WaitForSingleObject(cdata.hSemBouncer, INFINITE);

    //criar a zona de memória 
    cdata.hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        sizeof(Shared_MSG),
        SHM_NAME
    );

    if (cdata.hMapFile == NULL)
    {
        _tprintf(TEXT("Problema em criar zona de memoria (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada zona de memoria."));
    }

    //criar a zona de memória - a vista
    cdata.shared = (Shared_MSG*)MapViewOfFile(
        cdata.hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0, //vista sobre a memoria inteira
        sizeof(Shared_MSG)
    );

    if (cdata.shared == NULL)
    {
        _tprintf(TEXT("Problema em criar a vista (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada a vista."));
    }

    //criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
    cdata.hRWMutex = CreateMutex(
        NULL,
        FALSE,
        MUTEX_NAME
    );

    if (cdata.hRWMutex == NULL)
    {
        _tprintf(TEXT("Problema em criar o mutex (%d),\n"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nmutex criado."));
    }

    cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
    cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));

    if (cdata.newmsg == NULL)
    {
        _tprintf(TEXT("Erro ao criar evento %s (%d).\n"), TEXT("Evento"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nEvento lançado com sucesso"));
    }

    _tprintf(TEXT("Lançar a thread para ouvir o que se passa\n"));
    cdata.continuar = 1;
    sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
    le_envia(&cdata);

    _tprintf(TEXT("Este cliente vai fechar\n"));
    WaitForSingleObject(sem, INFINITE);
    _tprintf(TEXT("Thread ouvinte encerrada\n"));

    ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);

    UnmapViewOfFile(cdata.shared); //memoria partilhada
    CloseHandle(cdata.hMapFile);
    CloseHandle(cdata.newmsg);
    CloseHandle(cdata.hSemBouncer);

    valor = TRUE;
    return valor;
}


int _tmain(int argc, TCHAR* argv[]) {
    BOOL entra = FALSE;



    while (entra == FALSE)
    {
        entra = comunicaAeroporto(FALSE);
    }
    _tprintf(TEXT("\ntou feliz... cara#######"));
    return 0;
}

control:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>

#define SEM_BOUNCER_NAME TEXT("SEMBOUNCER") //nome do semáforo
#define MAXUSERS 3 //numero de processo que vão passar no semáforo

#define SHM_NAME TEXT("fmMsgSpace") //nome da memória
#define MUTEX_NAME TEXT("RWMUTEX") //nome do mutex

#define MSGTEXT_SZ 100 //tamanho máximo das mensagens
#define MSG_DELAY 500 //intervalo para leitura das mensagens pelos clientes

typedef struct _MSG_AEROPORTO {
    TCHAR szMessagem[MSGTEXT_SZ];
    int pidMessagemControl; //aviao
    int pidMessagemAviao; //areoporto
    int comando; //0, semResposta, 1 pedido de aeroporto, 2, ok aeroporto, -1 , erro aeroporto
} Shared_MSG;

typedef struct _ControlData { //tipo de estrutura de dados de controlo
    HANDLE hSemBouncer; //semáforo
    //para o mutex
    HANDLE hMapFile, hRWMutex;
    Shared_MSG* shared; // ponteiro para memoria partilhada
    HANDLE newmsg; //ponteiro para o evento
    int continuar; // vairvel para terminar as threads
} CData;

//função que lê do teclado e envia para memoria partilhada
void le_envia(CData* pcd)
{
    Shared_MSG msg; //estrutura local

    while (pcd->continuar)
    {
        msg.pidMessagemControl = GetCurrentProcessId();
        _tprintf(TEXT("\n[control: %d] Escreve mensagem (fim para sair)"), msg.pidMessagemControl);
        wscanf_s(TEXT("%s"), msg.szMessagem, (unsigned)_countof(msg.szMessagem));
        //_tprintf(TEXT("%s\n"), msg.szMessagem);


        if (_tcscmp(msg.szMessagem, TEXT("fim")) == 0)
        {
            break;
        }

        WaitForSingleObject(pcd->hRWMutex, INFINITE);
        CopyMemory(pcd->shared, &msg, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        //assinlar que há nova mensagem
        SetEvent(pcd->newmsg);
        //esperar que mensagem seja lida por outros processos
        Sleep(MSG_DELAY);
        //desativar evento
        ResetEvent(pcd->newmsg);
    }
    pcd->continuar = 0;
    _tprintf(TEXT("\nPrograma vai terminar"));
    //para desbloquear a outra thread e sair de imediato
    SetEvent(pcd->newmsg);
}

DWORD WINAPI recebe_msg(LPVOID p)
{
    CData* pcd = (CData*)p;
    Shared_MSG msg;
    TCHAR nome[MSGTEXT_SZ];
    _tcscpy_s(nome, _countof(nome), _T("coimbra"));

    while (1)
    {
        WaitForSingleObject(pcd->newmsg, INFINITE); //aguardar evento
        if (!pcd->continuar)
        {
            break;
        }
        WaitForSingleObject(pcd->hRWMutex, INFINITE); //obter mutex
        CopyMemory(&msg, pcd->shared, sizeof(Shared_MSG)); //dest , source
        ReleaseMutex(pcd->hRWMutex);

        if (msg.comando == 1) {
            _tprintf(TEXT("\nRecebi: %s do %d\n"), msg.szMessagem, msg.pidMessagemAviao);
            if (wcscmp(msg.szMessagem, _T("coimbra")) == 0)
            {
                _tprintf(TEXT("\nSenhor aviao existe esse aeroporto.. volte sempre %d!"), msg.pidMessagemAviao);
                pcd->shared->pidMessagemAviao = msg.pidMessagemAviao;
                pcd->shared->comando = 2;
                //Sleep(MSG_DELAY);
            }
            else
            {
                pcd->shared->comando = -1;
            }
        }
        else
        {
            _tprintf(TEXT("\nAguardo por um pedido formal"));
            pcd->shared->comando = -1;
        }
        Sleep(MSG_DELAY * 2);
        pcd->shared->comando = -1;
    }
    //no cao de haver outras thread, evento não fica ativo para elas quando esta thread termina
    ResetEvent(pcd->newmsg);
    return 0;
}
BOOL comunicaAeroporto(BOOL valor)
{
    HANDLE sem; // Handle do semáforo
    CData cdata; //estrutura de dados de controlo
    DWORD tid; //estrutura de dados de controlo

#ifdef UNICODE 
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    cdata.hSemBouncer = CreateSemaphore(
        NULL, //atributo de segurança
        MAXUSERS, //começa o programa logo com o max users
        MAXUSERS, //limite de users
        SEM_BOUNCER_NAME //nome do semaforo
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nerro a criar semaforo"));
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nSemáforo criado"));
    }

    cdata.hSemBouncer = OpenSemaphore( //abrir o semaforo
        SYNCHRONIZE | SEMAPHORE_MODIFY_STATE,
        FALSE,
        SEM_BOUNCER_NAME
    );

    if (cdata.hSemBouncer == NULL)
    {
        _tprintf(TEXT("\nProblema na aberura do Semáforo (%d)"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nSemáforo aberto."));
    }

    _tprintf(TEXT("\nVou agurdar no semáforo para entrar"));
    WaitForSingleObject(cdata.hSemBouncer, INFINITE);

    //criar a zona de memória 
    cdata.hMapFile = CreateFileMapping(
        INVALID_HANDLE_VALUE,
        NULL,
        PAGE_READWRITE,
        0,
        sizeof(Shared_MSG),
        SHM_NAME
    );

    if (cdata.hMapFile == NULL)
    {
        _tprintf(TEXT("\nProblema em criar zona de memoria (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada zona de memoria."));
    }

    //criar a zona de memória - a vista
    cdata.shared = (Shared_MSG*)MapViewOfFile(
        cdata.hMapFile,
        FILE_MAP_ALL_ACCESS,
        0,
        0, //vista sobre a memoria inteira
        sizeof(Shared_MSG)
    );

    if (cdata.shared == NULL)
    {
        _tprintf(TEXT("\nProblema em criar a vista (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\ncriada a vista."));
    }

    //criar a zona de memória - o mutex (com um nome conhecido para todos os processos)
    cdata.hRWMutex = CreateMutex(
        NULL,
        FALSE,
        MUTEX_NAME
    );

    if (cdata.hRWMutex == NULL)
    {
        _tprintf(TEXT("\nProblema em criar o mutex (%d),"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nmutex criado."));
    }

    cdata.newmsg = CreateEvent(NULL, TRUE, FALSE, TEXT("Evento"));
    cdata.newmsg = OpenEvent(SYNCHRONIZE | EVENT_MODIFY_STATE, TRUE, TEXT("Evento"));

    if (cdata.newmsg == NULL)
    {
        _tprintf(TEXT("\nErro ao criar evento %s (%d)."), TEXT("Evento"), GetLastError());
        return FALSE;
    }
    else
    {
        _tprintf(TEXT("\nEvento lançado com sucesso"));
    }

    _tprintf(TEXT("\nLançar a thread para ouvir o que se passa"));
    cdata.continuar = 1;
    sem = CreateThread(NULL, 0, recebe_msg, &cdata, 0, &tid);
    le_envia(&cdata);

    _tprintf(TEXT("\nEste cliente vai fechar"));
    WaitForSingleObject(sem, INFINITE);
    _tprintf(TEXT("\nThread ouvinte encerrada"));

    ReleaseSemaphore(cdata.hSemBouncer, 1, NULL);

    UnmapViewOfFile(cdata.shared); //memoria partilhada
    CloseHandle(cdata.hMapFile);
    CloseHandle(cdata.newmsg);
    CloseHandle(cdata.hSemBouncer);

    valor = TRUE;
    return valor;
}


int _tmain(int argc, TCHAR* argv[]) {
    BOOL entra = FALSE;

    while (entra == FALSE)
    {
        entra = comunicaAeroporto(FALSE);
    }
}

repo: messageWINAPI

#include <windows.h>
#include <tchar.h>
/* ===================================================== */
/* Programa base (esqueleto) para aplicações Windows     */
/* ===================================================== */
// Cria uma janela de nome "Janela Principal" e pinta fundo de branco
// Modelo para programas Windows:
//  Composto por 2 funções: 
//	WinMain()     = Ponto de entrada dos programas windows
//			1) Define, cria e mostra a janela
//			2) Loop de recepção de mensagens provenientes do Windows
//     TrataEventos()= Processamentos da janela (pode ter outro nome)
//			1) É chamada pelo Windows (callback) 
//			2) Executa código em função da mensagem recebida

LRESULT CALLBACK TrataEventos(HWND, UINT, WPARAM, LPARAM);

// Nome da classe da janela (para programas de uma só janela, normalmente este nome é 
// igual ao do próprio programa) "szprogName" é usado mais abaixo na definição das 
// propriedades do objecto janela
TCHAR szProgName[] = TEXT("Base");

// ============================================================================
// FUNÇÃO DE INÍCIO DO PROGRAMA: WinMain()
// ============================================================================
// Em Windows, o programa começa sempre a sua execução na função WinMain()que desempenha
// o papel da função main() do C em modo consola WINAPI indica o "tipo da função" (WINAPI
// para todas as declaradas nos headers do Windows e CALLBACK para as funções de
// processamento da janela)
// Parâmetros:
//   hInst: Gerado pelo Windows, é o handle (número) da instância deste programa 
//   hPrevInst: Gerado pelo Windows, é sempre NULL para o NT (era usado no Windows 3.1)
//   lpCmdLine: Gerado pelo Windows, é um ponteiro para uma string terminada por 0
//              destinada a conter parâmetros para o programa 
//   nCmdShow:  Parâmetro que especifica o modo de exibição da janela (usado em  
//        	   ShowWindow()

typedef struct {
	int valor;
	TCHAR nome[80];
}DATA;
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow) {
	HWND hWnd;		// hWnd é o handler da janela, gerado mais abaixo por CreateWindow()
	MSG lpMsg;		// MSG é uma estrutura definida no Windows para as mensagens
	WNDCLASSEX wcApp;	// WNDCLASSEX é uma estrutura cujos membros servem para 
			  // definir as características da classe da janela

	DATA data = {10, _T("pedro")};

	// ============================================================================
	// 1. Definição das características da janela "wcApp" 
	//    (Valores dos elementos da estrutura "wcApp" do tipo WNDCLASSEX)
	// ============================================================================
	wcApp.cbSize = sizeof(WNDCLASSEX);      // Tamanho da estrutura WNDCLASSEX
	wcApp.hInstance = hInst;		         // Instância da janela actualmente exibida 
								   // ("hInst" é parâmetro de WinMain e vem 
										 // inicializada daí)
	wcApp.lpszClassName = szProgName;       // Nome da janela (neste caso = nome do programa)
	wcApp.lpfnWndProc = TrataEventos;       // Endereço da função de processamento da janela
											// ("TrataEventos" foi declarada no início e
											// encontra-se mais abaixo)
	wcApp.style = CS_HREDRAW | CS_VREDRAW;  // Estilo da janela: Fazer o redraw se for
											// modificada horizontal ou verticalmente

	wcApp.hIcon = LoadIcon(NULL, IDI_APPLICATION);   // "hIcon" = handler do ícon normal
										   // "NULL" = Icon definido no Windows
										   // "IDI_AP..." Ícone "aplicação"
	wcApp.hIconSm = LoadIcon(NULL, IDI_INFORMATION); // "hIconSm" = handler do ícon pequeno
										   // "NULL" = Icon definido no Windows
										   // "IDI_INF..." Ícon de informação
	wcApp.hCursor = LoadCursor(NULL, IDC_ARROW);	// "hCursor" = handler do cursor (rato) 
							  // "NULL" = Forma definida no Windows
							  // "IDC_ARROW" Aspecto "seta" 
	wcApp.lpszMenuName = NULL;			// Classe do menu que a janela pode ter
							  // (NULL = não tem menu)
	wcApp.cbClsExtra = 0;				// Livre, para uso particular
	wcApp.cbWndExtra = sizeof(DATA*);				// Livre, para uso particular
	wcApp.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
	// "hbrBackground" = handler para "brush" de pintura do fundo da janela. Devolvido por
	// "GetStockObject".Neste caso o fundo será branco

	// ============================================================================
	// 2. Registar a classe "wcApp" no Windows
	// ============================================================================
	if (!RegisterClassEx(&wcApp))
		return(0);

	// ============================================================================
	// 3. Criar a janela
	// ============================================================================
	hWnd = CreateWindow(
		szProgName,			// Nome da janela (programa) definido acima
		TEXT("Exemplo de Janela Principal em C"),// Texto que figura na barra do título
		WS_OVERLAPPEDWINDOW,	// Estilo da janela (WS_OVERLAPPED= normal)
		CW_USEDEFAULT,		// Posição x pixels (default=à direita da última)
		CW_USEDEFAULT,		// Posição y pixels (default=abaixo da última)
		CW_USEDEFAULT,		// Largura da janela (em pixels)
		CW_USEDEFAULT,		// Altura da janela (em pixels)
		(HWND)HWND_DESKTOP,	// handle da janela pai (se se criar uma a partir de
						// outra) ou HWND_DESKTOP se a janela for a primeira, 
						// criada a partir do "desktop"
		(HMENU)NULL,			// handle do menu da janela (se tiver menu)
		(HINSTANCE)hInst,		// handle da instância do programa actual ("hInst" é 
						// passado num dos parâmetros de WinMain()
		0);				// Não há parâmetros adicionais para a janela
	  // ============================================================================
	  // 4. Mostrar a janela
	  // ============================================================================
	SetWindowLongPtr(hWnd, 0, (LONG_PTR)&data);
	ShowWindow(hWnd, nCmdShow);	// "hWnd"= handler da janela, devolvido por 
					  // "CreateWindow"; "nCmdShow"= modo de exibição (p.e. 
					  // normal/modal); é passado como parâmetro de WinMain()
	UpdateWindow(hWnd);		// Refrescar a janela (Windows envia à janela uma 
					  // mensagem para pintar, mostrar dados, (refrescar)… 
	// ============================================================================
	// 5. Loop de Mensagens
	// ============================================================================
	// O Windows envia mensagens às janelas (programas). Estas mensagens ficam numa fila de
	// espera até que GetMessage(...) possa ler "a mensagem seguinte"	
	// Parâmetros de "getMessage":
	// 1)"&lpMsg"=Endereço de uma estrutura do tipo MSG ("MSG lpMsg" ja foi declarada no  
	//   início de WinMain()):
	//			HWND hwnd		handler da janela a que se destina a mensagem
	//			UINT message		Identificador da mensagem
	//			WPARAM wParam		Parâmetro, p.e. código da tecla premida
	//			LPARAM lParam		Parâmetro, p.e. se ALT também estava premida
	//			DWORD time		Hora a que a mensagem foi enviada pelo Windows
	//			POINT pt		Localização do mouse (x, y) 
	// 2)handle da window para a qual se pretendem receber mensagens (=NULL se se pretendem
	//   receber as mensagens para todas as
	// janelas pertencentes à thread actual)
	// 3)Código limite inferior das mensagens que se pretendem receber
	// 4)Código limite superior das mensagens que se pretendem receber

	// NOTA: GetMessage() devolve 0 quando for recebida a mensagem de fecho da janela,
	// 	  terminando então o loop de recepção de mensagens, e o programa 

	while (GetMessage(&lpMsg, NULL, 0, 0)) {
		TranslateMessage(&lpMsg);	// Pré-processamento da mensagem (p.e. obter código 
					   // ASCII da tecla premida)
		DispatchMessage(&lpMsg);	// Enviar a mensagem traduzida de volta ao Windows, que
					   // aguarda até que a possa reenviar à função de 
					   // tratamento da janela, CALLBACK TrataEventos (abaixo)
	}

	// ============================================================================
	// 6. Fim do programa
	// ============================================================================
	return((int)lpMsg.wParam);	// Retorna sempre o parâmetro wParam da estrutura lpMsg
}

// ============================================================================
// FUNÇÃO DE PROCESSAMENTO DA JANELA
// Esta função pode ter um nome qualquer: Apenas é necesário que na inicialização da
// estrutura "wcApp", feita no início de // WinMain(), se identifique essa função. Neste
// caso "wcApp.lpfnWndProc = WndProc"
//
// WndProc recebe as mensagens enviadas pelo Windows (depois de lidas e pré-processadas
// no loop "while" da função WinMain()
// Parâmetros:
//		hWnd	O handler da janela, obtido no CreateWindow()
//		messg	Ponteiro para a estrutura mensagem (ver estrutura em 5. Loop...
//		wParam	O parâmetro wParam da estrutura messg (a mensagem)
//		lParam	O parâmetro lParam desta mesma estrutura
//
// NOTA:Estes parâmetros estão aqui acessíveis o que simplifica o acesso aos seus valores
//
// A função EndProc é sempre do tipo "switch..." com "cases" que descriminam a mensagem
// recebida e a tratar.
// Estas mensagens são identificadas por constantes (p.e. 
// WM_DESTROY, WM_CHAR, WM_KEYDOWN, WM_PAINT...) definidas em windows.h
// ============================================================================

LRESULT CALLBACK TrataEventos(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam) {
	DATA* pData=(DATA*)GetWindowLongPtr(hWnd, 0);

	switch (messg) {
	case WM_CHAR:
		if (wParam == 'a') {
			MessageBox(hWnd, pData->nome, TEXT("informa"), MB_OK);
		}
		break;
	case WM_DESTROY:	// Destruir a janela e terminar o programa 
						// "PostQuitMessage(Exit Status)"		

		PostQuitMessage(0);
		break;
	default:
		// Neste exemplo, para qualquer outra mensagem (p.e. "minimizar","maximizar","restaurar")
		// não é efectuado nenhum processamento, apenas se segue o "default" do Windows
		return(DefWindowProc(hWnd, messg, wParam, lParam));
		break;  // break tecnicamente desnecessário por causa do return
	}
	return(0);
}

repo: namedPipes (variosLeitores OverLappedIO) outra versão

escritor:

#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")
#define N 3

// estrutura do named pipe
typedef struct {
	HANDLE hPipe; // handle do pipe
	OVERLAPPED overlap;
	BOOL activo; //representa se a instancia do named pipe esta ou nao ativa, se ja tem um cliente ou nao

} PipeDados;

typedef struct {
	PipeDados hPipes[N];
	HANDLE hEvents[N];
	HANDLE hMutex;
	int terminar;
}ThreadDados;

//envia mensagem para todos os leitores que estão disponiveis
DWORD WINAPI ThreadMensagens(LPVOID param) {
	ThreadDados* dados = (ThreadDados*)param;
	TCHAR buf[256];
	DWORD n;
	int i;
	BOOL ret;

	do {
		_tprintf(TEXT("[ESCRITOR] Frase: "));
		_fgetts(buf, 256, stdin);
		buf[_tcslen(buf) - 1] = '\0';
		
		for (i = 0; i < N; i++) {
			// este named pipe está ativo? se sim vou escrever nele
			if (dados->hPipes[i].activo == TRUE) {
				if (!WriteFile(dados->hPipes[i].hPipe, buf, (DWORD)_tcslen(buf) * sizeof(TCHAR), &n, NULL)) {
					_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
				}
				WaitForSingleObject(dados->hMutex, INFINITE);
				ret=ReadFile(dados->hPipes[i].hPipe, buf, sizeof(TCHAR), &n, NULL);
				ReleaseMutex(dados->hMutex);
				//termina corretamente a string
				buf[n / sizeof(TCHAR)] = '\0';
				_tprintf(TEXT("[ESCRITOR] Recebi %d bytes [%s]... \n"), n, buf);
			}
			//libertamos o mutex

		}
		

		_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);

	} while (_tcscmp(buf, TEXT("fim")));
	dados->terminar = 1;

	//vou assinalar todos os eventos para que nao fique bloqueado na main
	for (i = 0; i < N; i++)
		SetEvent(dados->hEvents[i]);

	return 0;
}

int _tmain(int argc, LPTSTR argv[]) {

	HANDLE hPipe, hThread, hEventTemp;
	ThreadDados dados;
	int i, numClientes = 0;
	DWORD offset, nBytes;

#ifdef UNICODE
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
#endif

	dados.terminar = 0;
	dados.hMutex = CreateMutex(NULL, FALSE, NULL); //Criação do mutex

	if (dados.hMutex == NULL) {
		_tprintf(TEXT("[Erro] ao criar mutex!\n"));
		return -1;
	}


	for (i = 0; i < N; i++) {

		// aqui passamos a constante FILE_FLAG_OVERLAPPED para o named pipe aceitar comunicações assincronas
		hPipe = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
			PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
			N,
			256 * sizeof(TCHAR),
			256 * sizeof(TCHAR),
			1000,
			NULL);

		if (hPipe == INVALID_HANDLE_VALUE) {
			_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
			exit(-1);
		}

		// criar evento que vai ser associado à esturtura overlaped
		// os eventos aqui tem de ter sempre reset manual e nao automático porque temos de delegar essas responsabilidades ao sistema operativo
		hEventTemp = CreateEvent(NULL, TRUE, FALSE, NULL);

		if (hEventTemp == NULL) {
			_tprintf(TEXT("[ERRO] ao criar evento\n"));
			return -1;
		}

		dados.hPipes[i].hPipe = hPipe;
		dados.hPipes[i].activo = FALSE;
		//temos de garantir que a estrutura overlap está limpa
		ZeroMemory(&dados.hPipes[i].overlap, sizeof(dados.hPipes[i].overlap));
		//preenchemos agora o evento
		dados.hPipes[i].overlap.hEvent = hEventTemp;
		dados.hEvents[i] = hEventTemp;

		_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor... (ConnectNamedPipe)\n"));

		// aqui passamos um ponteiro para a estrutura overlap
		ConnectNamedPipe(hPipe, &dados.hPipes[i].overlap);
	}

	//criacao da thread
	hThread = CreateThread(NULL, 0, ThreadMensagens, &dados, 0, NULL);
	if (hThread == NULL) {
		_tprintf(TEXT("[Erro] ao criar thread!\n"));
		return -1;
	}

	while (!dados.terminar && numClientes < N) {
		//permite estar bloqueado , à espera que 1 evento do array de enventos seja assinalado
		offset = WaitForMultipleObjects(N, dados.hEvents, FALSE, INFINITE);
		i = offset - WAIT_OBJECT_0; // devolve o indice da instancia do named pipe que está ativa, aqui sabemos em que indice o cliente se ligou

		// se é um indice válido ...
		if (i >= 0 && i < N) {

			_tprintf(TEXT("[ESCRITOR] Leitor %d chegou\n"), i);
			if (GetOverlappedResult(dados.hPipes[i].hPipe, &dados.hPipes[i].overlap, &nBytes, FALSE)) {
				// se entrarmos aqui significa que a funcao correu tudo bem
				// fazemos reset do evento porque queremos que o WaitForMultipleObject desbloqueio com base noutro evento e nao neste
				ResetEvent(dados.hEvents[i]);

				//vamos esperar que o mutex esteja livre
				WaitForSingleObject(dados.hMutex, INFINITE);
				dados.hPipes[i].activo = TRUE; // dizemos que esta instancia do named pipe está ativa
				ReleaseMutex(dados.hMutex);

				numClientes++;
			}
		}
	}


	//esperar que a thread termine
	WaitForSingleObject(hThread, INFINITE);

	//desligamos todos os clientes que se ligaram
	for (int i = 0; i < N; i++) {
		_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));

		//desliga todas as instancias de named pipes
		if (!DisconnectNamedPipe(dados.hPipes[i].hPipe)) {
			_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
			exit(-1);
		}
	}


	exit(0);
}

leitor:

#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>

// ...
#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

int _tmain(int argc, LPTSTR argv[]) {
	TCHAR buf[256];
	HANDLE hPipe;
	int i = 0;
	BOOL ret;
	DWORD n;

#ifdef UNICODE
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
#endif

	_tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"), PIPE_NAME);

	//espera que exista um named pipe para ler do mesmo
	//bloqueia aqui
	if (!WaitNamedPipe(PIPE_NAME, NMPWAIT_WAIT_FOREVER)) {
		_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
		exit(-1);
	}

	_tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));

	//ligamo-nos ao named pipe que ja existe nesta altura
	//1º nome do named pipe, 2ºpermissoes (têm de ser iguais ao CreateNamedPipe do servidor), 3ºshared mode 0 aqui,
	//4º security atributes, 5ºflags de criação OPEN_EXISTING, 6º o default é FILE_ATTRIBUTE_NORMAL e o 7º é o template é NULL
	hPipe = CreateFile(PIPE_NAME, PIPE_ACCESS_DUPLEX, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	if (hPipe == NULL) {
		_tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
		exit(-1);
	}

	_tprintf(TEXT("[LEITOR] Liguei-me...\n"));

	while (1) {
		//le as mensagens enviadas pelo servidor
		ret = ReadFile(hPipe, buf, sizeof(TCHAR), &n, NULL);
		 
		//termina corretamente a string
		buf[n /sizeof(TCHAR)] = '\0';

		if (!ret || !n) {
			_tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
			break;
		}

		_tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);

		for (int i = 0; i < (int)n; i++) {
			if (!WriteFile(hPipe, buf, (DWORD)_tcslen(buf) * sizeof(TCHAR), &n, NULL)) {
				_tprintf(TEXT("[ERRO] escrever no pipe\n"));
			}
			else {
				_tprintf(TEXT("[LEITOR] enviei %d butes ao escritor\n"), n);
			}
		}

	}
	CloseHandle(hPipe);
	Sleep(200);

	return 0;
}

repo: namedPipes (variosLeitores OverLappedIO)

escritor:

//escritor || servidor 
//comunicação assincrona (overlapped)
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

#define N 10 //numero de clientes

typedef struct {
	HANDLE hPipe;
	OVERLAPPED overlapped; //estrutura overlapped
	BOOL activo; //se já tem um cliente (pipe) activo ou nao
}PipeDados;


typedef struct {
	PipeDados hPipeDados[N];
	HANDLE hEvents[N];
	int numeroLeitores; //saber em tempo real a quantidade de leitores
	HANDLE hMutex;//sincronização: acesso sincronizado ao array
	int terminar; //controlar o fim da thread
}ThreadDados;

//thread auxiliar, para enviar para um conjunto de handles mensagens
DWORD WINAPI TheadMensagens(LPVOID param) {
	DWORD n;
	TCHAR buf[256];

	ThreadDados* dados = (ThreadDados*)param;
	int i;

	do {
		_tprintf(TEXT("[ESCRITOR] Frase: "));
		_fgetts(buf, 256, stdin);
		buf[_tcslen(buf) - 1] = '\0';

		WaitForSingleObject(dados->hMutex, INFINITE); 
		//região critica este ciclo do for
		for (i = 0; i < dados->numeroLeitores; i++) {
			//overlapped
			if(dados->hPipeDados[i].activo){

			if (!WriteFile(
				dados->hPipeDados[i].hPipe,
				buf, //a string
				(DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
				&n, //qt de informação que foi escrita
				NULL
			)) {
				_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
				exit(-1);
			}
			_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);
			}
		}
		ReleaseMutex(dados->hMutex);

	} while (_tcscmp(buf, TEXT("fim")));

	dados->terminar = 1;

	for(i=0; i<dados->numeroLeitores; i++)
	{
		SetEvent(dados->hEvents[i]);
	}

	return 0;
}


int _tmain(int argc, LPTSTR argv[]) {
	HANDLE hPipe;
	TCHAR buf[256]; //ou 256 * sizeof(TCHAR)

	ThreadDados dados;


	

#ifdef UNICODE
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif

	dados.numeroLeitores = 0;
	dados.terminar = 0;
	dados.hMutex = CreateMutex(
		NULL,
		FALSE,
		NULL
	);
	if (dados.hMutex == NULL) {
		_tprintf(TEXT("[ERRO] CreateMutex! (CreateMutex)"));
		exit(-1);
	}
	HANDLE hThreadMain;


	hThreadMain = CreateThread(NULL, 0, TheadMensagens, &dados, 0, NULL);
	if (hThreadMain == NULL) {
		_tprintf(TEXT("[ERRO] CreateThread! (CreateThread)"));
		exit(-1);
	}

	while (dados.terminar == 0) {

		_tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);

		hPipe = CreateNamedPipe(
			PIPE_NAME, //nome
			PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
			PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
			N, //numero maximo de instancias
			sizeof(buf), // tamnho do buffer de entrada
			sizeof(buf), // tamnho do buffer de saida
			1000, // default timeout, tempo de espera de um cliente
			NULL //atributos de segurança
		);

		if (hPipe == INVALID_HANDLE_VALUE) {
			_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
			exit(-1);
		}

		_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));

		if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
			hPipe, //namepiped
			NULL // overlaped
		)) {
			//devolve 0 se correr mal
			_tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
			exit(-1);
		}

		//novos clientes, e reigão critica
		WaitForSingleObject(dados.hMutex, INFINITE);
		dados.hPipeDados[dados.numeroLeitores].hPipe = hPipe;
		//dados.hPipeDados[dados.numeroLeitores].overlapped;
		dados.numeroLeitores++;
		ReleaseMutex(dados.hMutex);
	}
	//esperar que a thread termine
	WaitForSingleObject(hThreadMain, INFINITE);

	for (int i = 0; i < dados.numeroLeitores; i++) {
		_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));

		if (!DisconnectNamedPipe(dados.hEvents[i])) {
			_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
			exit(-1);
		}
	}

	//  Sleep(2000);
	//    CloseHandle(hPipe);
	return 0;
}

leitor:

//leitor || cliente 
//comunicação assincrona (overlapped)
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

int _tmain(int argc, LPTSTR argv[]) {
    TCHAR buf[256];
    HANDLE hPipe;
    int i = 0;
    BOOL ret;
    DWORD n;

#ifdef UNICODE
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    _tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
        PIPE_NAME);
    if (!WaitNamedPipe(
        PIPE_NAME, //string do nome do namedPipe
        NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
    )) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
    hPipe = CreateFile(
        PIPE_NAME, //nome do namedPipe
        GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
        0, //shared mode
        NULL, // security
        OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
        FILE_ATTRIBUTE_NORMAL, //flags
        NULL // template nao usamos
    );
    if (hPipe == NULL) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Liguei-me...\n"));

    while (1) {
        ret = ReadFile( //cliente é só de leitura
            hPipe, // handle do pipe
            buf,  //ponteiro onde escreve a informação lida
            sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
            &n, //ponteiro, a quantidade de bytes que foram escrito
            NULL //overlaped, nao interessa
        ); 

        buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes

        if (!ret || !n) {
            _tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
            break;
        }
        _tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
    }
    CloseHandle(hPipe);
    Sleep(200);
    return 0;
}

Comunicação assincrona (overlapped)
_operações que normamente bloqueiam até completarem (read, write) podem ser completadas em background pelo SO
_isto consegue-se passando um ponteiro não nulo para uma estrutura do tipo OVERLAPPED
_se na estrutura for passado um handle para um evento, esse evento é assinalado quando a operação for completada pelo SO

processo, faz:
pedido de operação overlapped (não bloqueante)
e operação feita em background pelo SO, faz:
evento (opcional)

a estrutura do tipo overlapped deve ser inicializada a zero
a estrutura pode levar o handle de evento, depois dele ser criado

OVERLAPPED overlap;
ZeroMemory(&overlap, sizeof(overlap));
hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); //criar evento
overlap.hEvent = hEvent;
ConnectNamedPipe(hPipe, &overlap);

É possivel determinar o resultado de uma operação assincrona com GetOverlappedResult

BOOL GetOverlappedResult(
HANDLE hFile, //ponteiro para pipe, ficheiro,
LPOVERLAPPED lpOverLapped, // ponteiro para estrutura do tipo OVERLAPPED
LPWORD lpNumberOfBytesTransferred, // variavel para receber n de bytes
BOOl bWait //TRUE = espera que operação termine
);

repo: namedPipes (variosLeitores)

escritor:

//escritor || servidor 
//(thread secundária para partilhar por todos os leitores em simultaneos)
//(mais do que um leitor ao mesmo tempo)
//(o acesso à informação de exclusão mutua)
//array com handles dos named pipes
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

#define N 10 //numero de clientes

typedef struct {
	HANDLE hPipes[N];
	int numeroLeitores; //saber em tempo real a quantidade de leitores
	HANDLE hMutex;//sincronização: acesso sincronizado ao array
	int terminar; //controlar o fim da thread
}ThreadDados;

//thread auxiliar, para enviar para um conjunto de handles mensagens
DWORD WINAPI TheadMensagens(LPVOID param) {
	DWORD n;
	TCHAR buf[256];

	ThreadDados* dados = (ThreadDados*)param;
	int i;

	do {
		_tprintf(TEXT("[ESCRITOR] Frase: "));
		_fgetts(buf, 256, stdin);
		buf[_tcslen(buf) - 1] = '\0';

		WaitForSingleObject(dados->hMutex, INFINITE);
		//região critica este ciclo do for
		for (i = 0; i < dados->numeroLeitores; i++) {
			if (!WriteFile(
				dados->hPipes[i],
				buf, //a string
				(DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
				&n, //qt de informação que foi escrita
				NULL
			)) {
				_tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
				exit(-1);
			}
			_tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor [%d]... (WriteFile)\n"), n, i);
		}
		ReleaseMutex(dados->hMutex);

	} while (_tcscmp(buf, TEXT("fim")));

	dados->terminar = 1;

	//extra e depois do dados->terminar = 1;
	//simular a entrada de um novo cliente para desbloquear o ConnectNamedPipe no _main
	CreateFile(PIPE_NAME, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

	return 0;
}


int _tmain(int argc, LPTSTR argv[]) {
	HANDLE hPipe;
	TCHAR buf[256]; //ou 256 * sizeof(TCHAR)

	ThreadDados dados;

#ifdef UNICODE
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif

	dados.numeroLeitores = 0;
	dados.terminar = 0;
	dados.hMutex = CreateMutex(
		NULL,
		FALSE,
		NULL
	);
	if (dados.hMutex == NULL) {
		_tprintf(TEXT("[ERRO] CreateMutex! (CreateMutex)"));
		exit(-1);
	}
	HANDLE hThreadMain;
	hThreadMain = CreateThread(NULL, 0, TheadMensagens, &dados, 0, NULL);
	if (hThreadMain == NULL) {
		_tprintf(TEXT("[ERRO] CreateThread! (CreateThread)"));
		exit(-1);
	}

	while (dados.terminar == 0) {

		_tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);

		hPipe = CreateNamedPipe(
			PIPE_NAME, //nome
			PIPE_ACCESS_OUTBOUND, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
			PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
			N, //numero maximo de instancias
			sizeof(buf), // tamnho do buffer de entrada
			sizeof(buf), // tamnho do buffer de saida
			1000, // default timeout, tempo de espera de um cliente
			NULL //atributos de segurança
		);

		if (hPipe == INVALID_HANDLE_VALUE) {
			_tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
			exit(-1);
		}

		_tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));

		//mas o fim nao funciona:
		//1ª solução correta para desbloquear isto
		//2ª solução simular que surge um cliente novo para desbloquear este ConnectNamedPipe quando é escrito fim
		if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
			hPipe, //namepiped
			NULL // overlaped
		)) {
			//devolve 0 se correr mal
			_tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
			exit(-1);
		}

		//novos clientes, e reigão critica
		WaitForSingleObject(dados.hMutex, INFINITE);
		dados.hPipes[dados.numeroLeitores] = hPipe;
		dados.numeroLeitores++;
		ReleaseMutex(dados.hMutex);
	}
	//esperar que a thread termine
	WaitForSingleObject(hThreadMain, INFINITE);

	for (int i = 0; i < dados.numeroLeitores; i++) {
		_tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));

		if (!DisconnectNamedPipe(dados.hPipes[i])) {
			_tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
			exit(-1);
		}
	}

	//  Sleep(2000);
	//    CloseHandle(hPipe);
	return 0;
}

leitor:

//leitor || cliente 
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

int _tmain(int argc, LPTSTR argv[]) {
    TCHAR buf[256];
    HANDLE hPipe;
    int i = 0;
    BOOL ret;
    DWORD n;

#ifdef UNICODE
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    _tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
        PIPE_NAME);
    if (!WaitNamedPipe(
        PIPE_NAME, //string do nome do namedPipe
        NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
    )) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
    hPipe = CreateFile(
        PIPE_NAME, //nome do namedPipe
        GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
        0, //shared mode
        NULL, // security
        OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
        FILE_ATTRIBUTE_NORMAL, //flags
        NULL // template nao usamos
    );
    if (hPipe == NULL) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Liguei-me...\n"));

    while (1) {
        ret = ReadFile( //cliente é só de leitura
            hPipe, // handle do pipe
            buf,  //ponteiro onde escreve a informação lida
            sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
            &n, //ponteiro, a quantidade de bytes que foram escrito
            NULL //overlaped, nao interessa
        ); 

        buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes

        if (!ret || !n) {
            _tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
            break;
        }
        _tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
    }
    CloseHandle(hPipe);
    Sleep(200);
    return 0;
}

repo: namedPipes

escritor:

//escritor || servidor
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

int _tmain(int argc, LPTSTR argv[]) {
    DWORD n;
    HANDLE hPipe;
    TCHAR buf[256];

#ifdef UNICODE
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    _tprintf(TEXT("[ESCRITOR] Criar uma cópia do pipe '%s' ... (CreateNamedPipe)\n"), PIPE_NAME);
    
    hPipe = CreateNamedPipe(
        PIPE_NAME, //nome
        PIPE_ACCESS_OUTBOUND, //modo de abertura do pipe: PIPE_ACCESS_OUTBOUND, o escritor/servidor envia para o cliente!! PIPE_ACCESS_INBOUND, se receber informacoes do cliente e pode ser duplex
        PIPE_WAIT | PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE, //modo do funcionamento do pipe. O PIPE_WAIT pipe bloqueante e é tratado como mensagem usando o _MESSAGE
        1, //numero maximo de instancias
        sizeof(buf), // tamnho do buffer de entrada
        sizeof(buf), // tamnho do buffer de saida
        1000, // default timeout, tempo de espera de um cliente
        NULL //atributos de segurança
    );
    if (hPipe == INVALID_HANDLE_VALUE) {
        _tprintf(TEXT("[ERRO] Criar Named Pipe! (CreateNamedPipe)"));
        exit(-1);
    }

    while (1) {
        _tprintf(TEXT("[ESCRITOR] Esperar ligação de um leitor...(ConnectNamedPipe)\n"));
        if (!ConnectNamedPipe( //bloqueante, espera que alguém se ligue
            hPipe, //namepiped
            NULL // overlaped
        )) {
            //devolve 0 se correr mal
            _tprintf(TEXT("[ERRO] Ligação ao leitor! (ConnectNamedPipe\n"));
            exit(-1); 
        }

        do {
            _tprintf(TEXT("[ESCRITOR] Frase: "));
            _fgetts(buf, 256, stdin);
            buf[_tcslen(buf) - 1] = '\0';

            if (!WriteFile(
                hPipe, 
                buf, //a string
                (DWORD)_tcslen(buf) * sizeof(TCHAR), //tamnho que se vai escrever: quantidade de caracteres * bytes que ocupa
                &n, //qt de informação que foi escrita
                NULL
            )) {
                _tprintf(TEXT("[ERRO] Escrever no pipe! (WriteFile)\n"));
                exit(-1);
            }
            _tprintf(TEXT("[ESCRITOR] Enviei %d bytes ao leitor... (WriteFile)\n"), n);
        } while (_tcscmp(buf, TEXT("fim")));

        _tprintf(TEXT("[ESCRITOR] Desligar o pipe (DisconnectNamedPipe)\n"));

        if (!DisconnectNamedPipe(hPipe)) {
            _tprintf(TEXT("[ERRO] Desligar o pipe! (DisconnectNamedPipe)"));
            exit(-1);
        }
    }
    Sleep(2000);
    CloseHandle(hPipe);
    return 0;
}

leitor:

//leitor || cliente
#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>

#define PIPE_NAME TEXT("\\\\.\\pipe\\teste")

int _tmain(int argc, LPTSTR argv[]) {
    TCHAR buf[256];
    HANDLE hPipe;
    int i = 0;
    BOOL ret;
    DWORD n;

#ifdef UNICODE
    _setmode(_fileno(stdin), _O_WTEXT);
    _setmode(_fileno(stdout), _O_WTEXT);
    _setmode(_fileno(stderr), _O_WTEXT);
#endif

    _tprintf(TEXT("[LEITOR] Esperar pelo pipe '%s' (WaitNamedPipe)\n"),
        PIPE_NAME);
    if (!WaitNamedPipe(
        PIPE_NAME, //string do nome do namedPipe
        NMPWAIT_WAIT_FOREVER //timeout para sempre NMPWAIT_WAIT_FOREVER, ou espera os 1000 NMPWAIT_USE_DEFAULT_WAIT
    )) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (WaitNamedPipe)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Ligação ao pipe do escritor... (CreateFile)\n"));
    hPipe = CreateFile(
        PIPE_NAME, //nome do namedPipe
        GENERIC_READ, //as permissões, ver PIPE_ACCESS_OUTBOUND, mas se fosse PIPE_ACCESS_INBOUND seria GENERIC_WRITE
        0, //shared mode
        NULL, // security
        OPEN_EXISTING, //flags de criação, é sempre OPEN_EXISTING
        FILE_ATTRIBUTE_NORMAL, //flags
        NULL // template nao usamos
    );
    if (hPipe == NULL) {
        _tprintf(TEXT("[ERRO] Ligar ao pipe '%s'! (CreateFile)\n"), PIPE_NAME);
        exit(-1);
    }
    _tprintf(TEXT("[LEITOR] Liguei-me...\n"));

    while (1) {
        ret = ReadFile( //cliente é só de leitura
            hPipe, // handle do pipe
            buf,  //ponteiro onde escreve a informação lida
            sizeof(buf), //qt máxima de informações que cabem, 256 caracteres
            &n, //ponteiro, a quantidade de bytes que foram escrito
            NULL //overlaped, nao interessa
        ); 

        buf[n / sizeof(TCHAR)] = '\0'; //tamanho de caracteres, 1 byte se for ascii ou de 2 bytes

        if (!ret || !n) {
            _tprintf(TEXT("[LEITOR] %d %d... (ReadFile)\n"), ret, n);
            break;
        }
        _tprintf(TEXT("[LEITOR] Recebi %d bytes: '%s'... (ReadFile)\n"), n, buf);
    }
    CloseHandle(hPipe);
    Sleep(200);
    return 0;
}

repo: graficoMenus

#include <windows.h>
#include <windowsx.h>
#include <tchar.h>
#include "resource.h"

#define NUM_CLIENTES 3
#define LIST_SIZE 8

TCHAR* LIST_ITENS[] = {
	TEXT("10€"),
	TEXT("20€"),
	TEXT("40€"),
	TEXT("60€"),
	TEXT("80€"),
	TEXT("100€"),
	TEXT("150€"),
	TEXT("200€")
};

LRESULT CALLBACK TrataEventos(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK TrataEventosLogin(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK TrataEventosLevantar(HWND, UINT, WPARAM, LPARAM);

TCHAR szProgName[] = TEXT("Ficha8");

typedef struct {
	unsigned int ID;
	TCHAR username[16];
	TCHAR password[16];
	unsigned int saldo;
} cliente;

typedef struct {
	unsigned int tipo; // 1 = depósito, 2 = levantamento
	unsigned int quantia;
	unsigned int ID;
} operacao;

typedef struct {
	cliente clientes[NUM_CLIENTES];
	operacao historico[200];
	unsigned int numOperacoes;
} dados;

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	MSG lpMsg;
	WNDCLASSEX wcApp;
	HANDLE hAccel;
	dados dadosPartilhados;

	wcApp.cbSize = sizeof(WNDCLASSEX);
	wcApp.hInstance = hInst;

	wcApp.lpszClassName = szProgName;
	wcApp.lpfnWndProc = TrataEventos;

	wcApp.style = CS_HREDRAW | CS_VREDRAW;

	wcApp.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
	wcApp.hIconSm = LoadIcon(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
	wcApp.hCursor = LoadCursor(hInst, MAKEINTRESOURCE(IDI_ICON_APP));
	wcApp.lpszMenuName = MAKEINTRESOURCE(IDR_MENU_PRINCIPAL);

	wcApp.cbClsExtra = sizeof(dados);
	wcApp.cbWndExtra = 0;
	wcApp.hbrBackground = CreateSolidBrush(RGB(220, 220, 220));

	if (!RegisterClassEx(&wcApp))
		return(0);

	hWnd = CreateWindow(
		szProgName,
		TEXT("SO2 - Ficha 8"),
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		CW_USEDEFAULT,
		300,
		150,
		(HWND)HWND_DESKTOP,
		(HMENU)NULL,
		(HINSTANCE)hInst,
		0);

	dadosPartilhados.numOperacoes = 5; // Apenas para testar...
	LONG_PTR x = SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)&dadosPartilhados);

	ShowWindow(hWnd, nCmdShow);

	hAccel = LoadAccelerators(NULL, MAKEINTRESOURCE(IDR_ACCELERATOR));

	while (GetMessage(&lpMsg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(hWnd, hAccel, &lpMsg))
		{
			TranslateMessage(&lpMsg);
			DispatchMessage(&lpMsg);
		}
	}

	return((int)lpMsg.wParam);
}

LRESULT CALLBACK TrataEventos(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
	TCHAR str1[512], str2[512];
	dados* dadosPartilhados;

	dadosPartilhados = (dados*)GetWindowLongPtr(hWnd, GWLP_USERDATA);

	switch (messg)
	{
	case WM_CREATE:
		EnableMenuItem(GetMenu(hWnd), ID_CONSULTA, MF_DISABLED | MF_GRAYED);
		EnableMenuItem(GetMenu(hWnd), ID_LEVANTAMENTO, MF_DISABLED | MF_GRAYED);
		break;

	case WM_COMMAND:

		switch (LOWORD(wParam))
		{
		case ID_LOGIN:

			DialogBox(NULL, MAKEINTRESOURCE(IDD_DIALOG_LOGIN), hWnd, TrataEventosLogin);
			EnableMenuItem(GetMenu(hWnd), ID_CONSULTA, MF_ENABLED);
			EnableMenuItem(GetMenu(hWnd), ID_LEVANTAMENTO, MF_ENABLED);
			break;

		case ID_CONSULTA:
		case ID_ACCELERATOR_CONSULTA:

			LoadString(NULL, IDS_STR_CONSULTA, str1, 512);
			_stprintf_s(str2, 512, TEXT("%s (%d)"), str1, dadosPartilhados->numOperacoes);
			MessageBox(hWnd, str2, TEXT("String Table"), MB_OK | MB_ICONINFORMATION);
			break;

		case ID_ACCELERATOR_LEVANTAMENTO:
		case ID_LEVANTAMENTO:

			DialogBox(NULL, MAKEINTRESOURCE(IDD_DIALOG_LEVANTAMENTO), NULL, TrataEventosLevantar);
			break;

		}

		break;

	case WM_DESTROY:
		PostQuitMessage(0);
		break;

	default:
		return DefWindowProc(hWnd, messg, wParam, lParam);
		break;
	}

	return(0);
}

LRESULT CALLBACK TrataEventosLogin(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
	TCHAR username[16];

	switch (messg)
	{
	case WM_COMMAND:

		if (LOWORD(wParam) == IDOK)
		{
			GetDlgItemText(hWnd, IDC_EDIT_LOGIN, username, 16);
			MessageBox(hWnd, username, TEXT("Username"), MB_OK | MB_ICONINFORMATION);
		}
		else if (LOWORD(wParam) == IDCANCEL)
		{
			EndDialog(hWnd, 0);
			return TRUE;
		}

		break;

	case WM_CLOSE:

		EndDialog(hWnd, 0);
		return TRUE;
	}

	return FALSE;
}

LRESULT CALLBACK TrataEventosLevantar(HWND hWnd, UINT messg, WPARAM wParam, LPARAM lParam)
{
	int i;

	switch (messg)
	{
	case WM_INITDIALOG:

		HWND hwndList = GetDlgItem(hWnd, IDC_LIST_MONTANTES);
		SendMessage(hwndList, LB_RESETCONTENT, 0, 0);

		for (i = 0; i < LIST_SIZE; i++)
			SendMessage(hwndList, LB_ADDSTRING, 0, (LPARAM)LIST_ITENS[i]);

		break;

	case WM_COMMAND:

		if (LOWORD(wParam) == IDC_LIST_MONTANTES)
		{
			switch (HIWORD(wParam))
			{
			case LBN_DBLCLK:

				HWND hwndList = GetDlgItem(hWnd, IDC_LIST_MONTANTES);
				i = (int)SendMessage(hwndList, LB_GETCURSEL, 0, 0);
				MessageBox(hWnd, LIST_ITENS[i], TEXT("ListBox"), MB_OK | MB_ICONINFORMATION);

				break;
			}
		}

		break;

	case WM_CLOSE:

		EndDialog(hWnd, 0);
		return TRUE;
	}

	return FALSE;
}

e no resource.h

#define IDI_ICON_APP                    101
#define IDR_MENU_PRINCIPAL              102
#define IDR_ACCELERATOR                 107
#define IDD_DIALOG1                     108
#define IDC_LOGIN                       1001
#define IDC_PASSWORD                    1002
#define ID_CANCEL                       1003
#define IDC_LIST_MONTANTES              1004
#define IDC_EDIT1                       1006
#define IDS_STR_CONSULTA                1006
#define ID_OPERA40001                   40001
#define ID_OPERA40002                   40002
#define ID_LOGIN                        40003
#define IDD_DIALOG_LOGIN                40003
#define ID_CONSULTA                     40004
#define ID_LEVANTAMENTO                 40005
#define IDD_DIALOG_LEVANTAMENTO         40005
#define ID_ACCELERATOR_CONSULTA         40006
#define ID_ACCELERATOR_LEVANTAMENTO     40007

// Next default values for new objects
// 
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE        110
#define _APS_NEXT_COMMAND_VALUE         40009
#define _APS_NEXT_CONTROL_VALUE         1007
#define _APS_NEXT_SYMED_VALUE           101
#endif
#endif

repo: bufferCircular II

produtor:

//produtor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random


#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular


typedef struct {
	int id;
	int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular

typedef struct {
	int numeroProdutores;
	int numeroConsumidores;
	int proximaPosicaoEscrita; //controlar
	int proximaPosicaoLeitura; //controlar
	CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada


typedef struct {
	BufferCircular* memoriaPartilhada;
	HANDLE hSemaforoControlaEscrita;
	HANDLE hSemaforoControloLeitura;
	HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
	int controloDaThread; //flag, 1 sair, 0 caso contrário
	int idProdutor;
}DadosThreads;

//lidar com o random
int numero_aleatorio(int min, int max) {
	return rand() % (max - min + 1) + min; //valor entre min e max
}


//a trhead produtor
DWORD WINAPI ThreadEscritaProdutor(LPVOID param) {
	DadosThreads* dados = (DadosThreads*)param;
	CelulaBufferCircular celBC;  //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
	int contadorItensProduzidos = 0;

	while (dados->controloDaThread == 0) {
		celBC.id = dados->idProdutor;
		//produzir o item
		celBC.val = numero_aleatorio(10,99);

		//escrever no buffer circular, 
		WaitForSingleObject(
			dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
			INFINITE
		); 
		//temos a garantia que temos uma posicção de escrita
		WaitForSingleObject(
			dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que somos nos a escrever
		//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
		CopyMemory(
			&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
			&celBC, 
			sizeof(CelulaBufferCircular)
		);
		//a proxima posicao de escrita é incrementada
		dados->memoriaPartilhada->proximaPosicaoEscrita++;
		//cheguei ao limite volto à posicao 0
		if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
			dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
		}
		//libertar o mutex
		ReleaseMutex(dados->hMutexControloExclusaoMutua);
		//libtertar o semaforo de leitura
		//se ocupamos uma posição de escrita libertamos uma posição de leitura
		//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
		//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
		ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1

		contadorItensProduzidos++;
		_tprintf(TEXT("\nProdutor %d produziu valor %d "), dados->idProdutor, celBC.val);
		Sleep(numero_aleatorio(2, 4)*1000);
	}
	_tprintf(TEXT("\nProdutor %d produziu  %d itens"), dados->idProdutor, contadorItensProduzidos);
	return 0;
}


int _tmain(int argc, LPSTR argv[]) {
	HANDLE hFileMap;
	//mapeamento da memoria partilhada
	DadosThreads dados;
#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	//lidar com o random
	srand((unsigned int)time(NULL));

	//os semaforos
	dados.hSemaforoControlaEscrita = CreateSemaphore(
		NULL,
		TAM_BUFFER_CIRUCLAR,
		TAM_BUFFER_CIRUCLAR,
		TEXT("SO2_MEMORIA_ESCRITA")
	);
	if (dados.hSemaforoControlaEscrita == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
		return 1;
	}
	dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
		0, //quantidade de posições iniciais, não existe nada para ser lido
		TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
		TEXT("SO2_MEMORIA_LEITURA")
	);
	if (dados.hSemaforoControloLeitura == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
		return 1;
	}
	//exclusao mutua para os produtores
	dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_PRODUTOR"));
	if (dados.hMutexControloExclusaoMutua == NULL) {
		_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
		return 1;
	}

	hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
	int primeiroProcesso = FALSE;

	//se existir é aberto
	//se nao existe é nulo
	if (hFileMap == NULL) {
		//existe um problem é porque se calahar não existe
		//criar a memoria partilhada
		primeiroProcesso = TRUE;
		hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
			NULL,
			PAGE_READWRITE, //nivel de protecão: lieura e escrita); 
			0, //dimensões da memoria partilhada: mais significativa
			sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
			TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
		);
		if (hFileMap == NULL) {
			_tprintf(TEXT("\nerro no CreateFileMapping"));
			return 1;
		}
	}

	dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
		hFileMap,
		FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
		0, //offsets: onde é mapeada 
		0, //0 para mapear até ao final
		0 //0 para mapear até ao final
	);
	if (dados.memoriaPartilhada == NULL) {
		_tprintf(TEXT("\nerro no MapViewOfFile"));
		return 1;
	}

	//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
	if (primeiroProcesso == TRUE) {
		dados.memoriaPartilhada->numeroConsumidores = 0;
		dados.memoriaPartilhada->numeroProdutores = 0;
		dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
		dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
	}
	//criar a thread
	dados.controloDaThread = 0;
	
	//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
	WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
	//ir à memoria partilhada
	dados.memoriaPartilhada->numeroProdutores++;
	dados.idProdutor = dados.memoriaPartilhada->numeroProdutores;
	//liberta ro mutex
	ReleaseMutex(dados.hMutexControloExclusaoMutua);
	
	HANDLE hThread;
	TCHAR comando[100];
	hThread = CreateThread(NULL, 0, ThreadEscritaProdutor, &dados, 0, NULL);
	if (hThread != NULL) {
		_tprintf(TEXT("escreve qualquer coisa para sair"));
		_getts_s(comando, 100);
		dados.controloDaThread = 1;
		WaitForSingleObject(hThread, INFINITE);
	}

	UnmapViewOfFile(dados.memoriaPartilhada);
	//CloseHandle();


	return 0;
}

consumidor:

//consumidor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random

#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular

typedef struct {
	int id;
	int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular

typedef struct {
	int numeroProdutores;
	int numeroConsumidores;
	int proximaPosicaoEscrita; //controlar
	int proximaPosicaoLeitura; //controlar
	CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada


typedef struct {
	BufferCircular* memoriaPartilhada;
	HANDLE hSemaforoControlaEscrita;
	HANDLE hSemaforoControloLeitura;
	HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
	int controloDaThread; //flag, 1 sair, 0 caso contrário
	int idConsumidor;
}DadosThreads;


//a thread consumidor
DWORD WINAPI ThreadLeituraConsumidor(LPVOID param) {
	DadosThreads* dados = (DadosThreads*)param;
	CelulaBufferCircular celBC;  //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
	int contadorItensProduzidos = 0;
	int soma = 0;

	while (dados->controloDaThread == 0) {
		
		//ler no buffer circular, 
		WaitForSingleObject(
			dados->hSemaforoControloLeitura, //existe uma posição para ler
			INFINITE
		);
		//temos a garantia que temos uma posicção de escrita
		WaitForSingleObject(
			dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que somos nos a ler
		//os dois estão desbloqueados e vamos ser o unico consumdior que vai ler
		CopyMemory(
			&celBC, //copiar
			&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoLeitura], //destino
			sizeof(CelulaBufferCircular)
		);
		//a proxima posicao de escrita é incrementada
		dados->memoriaPartilhada->proximaPosicaoLeitura++;
		//cheguei ao limite volto à posicao 0
		if (dados->memoriaPartilhada->proximaPosicaoLeitura == TAM_BUFFER_CIRUCLAR) {
			dados->memoriaPartilhada->proximaPosicaoLeitura = 0;
		}
		//libertar o mutex quando terminamos a leitura
		ReleaseMutex(dados->hMutexControloExclusaoMutua);
		//libtertar o semaforo de escrita
		//se ocupamos uma posição de leitura libertamos uma posição de escrita
		//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
		ReleaseSemaphore(dados->hSemaforoControlaEscrita, 1, NULL); //apenas uma posição, 1

		contadorItensProduzidos++;
		soma = soma + celBC.val;
		_tprintf(TEXT("\nConsumidor %d consumiu valor %d "), dados->idConsumidor, celBC.val);
		//Sleep(numero_aleatorio(2, 4) * 1000);
	}
	_tprintf(TEXT("\nConsumidor %d consumiu  %d acumulado"), dados->idConsumidor, soma);
	return 0;
}

//a thread consumidor
DWORD WINAPI ThreadEscritaConsumidor(LPVOID param) {
	DadosThreads* dados = (DadosThreads*)param;
	CelulaBufferCircular celBC;  //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
	int contadorItensProduzidos = 0;

	while (dados->controloDaThread == 0) {
		celBC.id = dados->idConsumidor;
		//produzir o item
		celBC.val = numero_aleatorio(10, 99);

		//escrever no buffer circular, 
		WaitForSingleObject(
			dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que temos uma posicção de escrita
		WaitForSingleObject(
			dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que somos nos a escrever
		//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
		CopyMemory(
			&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
			&celBC,
			sizeof(CelulaBufferCircular)
		);
		//a proxima posicao de escrita é incrementada
		dados->memoriaPartilhada->proximaPosicaoEscrita++;
		//cheguei ao limite volto à posicao 0
		if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
			dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
		}
		//libertar o mutex
		ReleaseMutex(dados->hMutexControloExclusaoMutua);
		//libtertar o semaforo de leitura
		//se ocupamos uma posição de escrita libertamos uma posição de leitura
		//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
		//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
		ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1

		contadorItensProduzidos++;
		_tprintf(TEXT("\Consumdior %d produziu valor %d "), dados->idConsumidor, celBC.val);
		Sleep(numero_aleatorio(2, 4) * 1000);
	}
	_tprintf(TEXT("\Consumdior %d produziu  %d itens"), dados->idConsumidor, contadorItensProduzidos);
	return 0;
}


int _tmain(int argc, LPSTR argv[]) {
	HANDLE hFileMap;
	//mapeamento da memoria partilhada
	DadosThreads dados;
#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	//lidar com o random
	srand((unsigned int)time(NULL));

	//os semaforos
	dados.hSemaforoControlaEscrita = CreateSemaphore(
		NULL,
		TAM_BUFFER_CIRUCLAR,
		TAM_BUFFER_CIRUCLAR,
		TEXT("SO2_MEMORIA_ESCRITA")
	);
	if (dados.hSemaforoControlaEscrita == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
		return 1;
	}
	dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
		0, //quantidade de posições iniciais, não existe nada para ser lido
		TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
		TEXT("SO2_MEMORIA_LEITURA")
	);
	if (dados.hSemaforoControloLeitura == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
		return 1;
	}
	//exclusao mutua para os produtores
	dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_CONSUMIDOR"));
	if (dados.hMutexControloExclusaoMutua == NULL) {
		_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
		return 1;
	}

	hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
	int primeiroProcesso = FALSE;

	//se existir é aberto
	//se nao existe é nulo
	if (hFileMap == NULL) {
		//existe um problem é porque se calahar não existe
		//criar a memoria partilhada
		primeiroProcesso = TRUE;
		hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
			NULL,
			PAGE_READWRITE, //nivel de protecão: lieura e escrita); 
			0, //dimensões da memoria partilhada: mais significativa
			sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
			TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
		);
		if (hFileMap == NULL) {
			_tprintf(TEXT("\nerro no CreateFileMapping"));
			return 1;
		}
	}

	dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
		hFileMap,
		FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
		0, //offsets: onde é mapeada 
		0, //0 para mapear até ao final
		0 //0 para mapear até ao final
	);
	if (dados.memoriaPartilhada == NULL) {
		_tprintf(TEXT("\nerro no MapViewOfFile"));
		return 1;
	}

	//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
	if (primeiroProcesso == TRUE) {
		dados.memoriaPartilhada->numeroConsumidores = 0;
		dados.memoriaPartilhada->numeroProdutores = 0;
		dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
		dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
	}
	//criar a thread
	dados.controloDaThread = 0;

	//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
	WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
	//ir à memoria partilhada
	dados.memoriaPartilhada->numeroConsumidores++;
	dados.idConsumidor = dados.memoriaPartilhada->numeroConsumidores;
	//libertar o mutex
	ReleaseMutex(dados.hMutexControloExclusaoMutua);

	HANDLE hThreadArray[2];
	TCHAR comando[100];
	hThreadArray[0] = CreateThread(NULL, 0, ThreadLeituraConsumidor, &dados, 0, NULL);
	hThreadArray[1] = CreateThread(NULL, 0, ThreadEscritaConsumidor, &dados, 0, NULL);


	if (hThreadArray[0] == NULL || hThreadArray[1] == NULL)
	{
		_tprintf(TEXT("nada de threads"));
		ExitProcess(3);
	}
	WaitForMultipleObjects(2, hThreadArray, TRUE, INFINITE);

	UnmapViewOfFile(dados.memoriaPartilhada);
	//CloseHandle();


	return 0;
}

repo: bufferCircular

consumidor

//consumidor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random

#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular

typedef struct {
	int id;
	int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular

typedef struct {
	int numeroProdutores;
	int numeroConsumidores;
	int proximaPosicaoEscrita; //controlar
	int proximaPosicaoLeitura; //controlar
	CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada


typedef struct {
	BufferCircular* memoriaPartilhada;
	HANDLE hSemaforoControlaEscrita;
	HANDLE hSemaforoControloLeitura;
	HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
	int controloDaThread; //flag, 1 sair, 0 caso contrário
	int idConsumidor;
}DadosThreads;


//a thread consumidor
DWORD WINAPI ThreadConsumidor(LPVOID param) {
	DadosThreads* dados = (DadosThreads*)param;
	CelulaBufferCircular celBC;  //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
	int contadorItensProduzidos = 0;
	int soma = 0;

	while (dados->controloDaThread == 0) {
		
		//ler no buffer circular, 
		WaitForSingleObject(
			dados->hSemaforoControloLeitura, //existe uma posição para ler
			INFINITE
		);
		//temos a garantia que temos uma posicção de escrita
		WaitForSingleObject(
			dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que somos nos a ler
		//os dois estão desbloqueados e vamos ser o unico consumdior que vai ler
		CopyMemory(
			&celBC, //copiar
			&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoLeitura], //destino
			sizeof(CelulaBufferCircular)
		);
		//a proxima posicao de escrita é incrementada
		dados->memoriaPartilhada->proximaPosicaoLeitura++;
		//cheguei ao limite volto à posicao 0
		if (dados->memoriaPartilhada->proximaPosicaoLeitura == TAM_BUFFER_CIRUCLAR) {
			dados->memoriaPartilhada->proximaPosicaoLeitura = 0;
		}
		//libertar o mutex quando terminamos a leitura
		ReleaseMutex(dados->hMutexControloExclusaoMutua);
		//libtertar o semaforo de escrita
		//se ocupamos uma posição de leitura libertamos uma posição de escrita
		//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
		ReleaseSemaphore(dados->hSemaforoControlaEscrita, 1, NULL); //apenas uma posição, 1

		contadorItensProduzidos++;
		soma = soma + celBC.val;
		_tprintf(TEXT("\nConsumidor %d consumiu valor %d "), dados->idConsumidor, celBC.val);
		//Sleep(numero_aleatorio(2, 4) * 1000);
	}
	_tprintf(TEXT("\nConsumidor %d consumiu  %d acumulado"), dados->idConsumidor, soma);
	return 0;
}


int _tmain(int argc, LPSTR argv[]) {
	HANDLE hFileMap;
	//mapeamento da memoria partilhada
	DadosThreads dados;
#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	//lidar com o random
	srand((unsigned int)time(NULL));

	//os semaforos
	dados.hSemaforoControlaEscrita = CreateSemaphore(
		NULL,
		TAM_BUFFER_CIRUCLAR,
		TAM_BUFFER_CIRUCLAR,
		TEXT("SO2_MEMORIA_ESCRITA")
	);
	if (dados.hSemaforoControlaEscrita == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
		return 1;
	}
	dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
		0, //quantidade de posições iniciais, não existe nada para ser lido
		TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
		TEXT("SO2_MEMORIA_LEITURA")
	);
	if (dados.hSemaforoControloLeitura == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
		return 1;
	}
	//exclusao mutua para os produtores
	dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_CONSUMIDOR"));
	if (dados.hMutexControloExclusaoMutua == NULL) {
		_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
		return 1;
	}

	hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
	int primeiroProcesso = FALSE;

	//se existir é aberto
	//se nao existe é nulo
	if (hFileMap == NULL) {
		//existe um problem é porque se calahar não existe
		//criar a memoria partilhada
		primeiroProcesso = TRUE;
		hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
			NULL,
			PAGE_READWRITE, //nivel de protecão: lieura e escrita); 
			0, //dimensões da memoria partilhada: mais significativa
			sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
			TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
		);
		if (hFileMap == NULL) {
			_tprintf(TEXT("\nerro no CreateFileMapping"));
			return 1;
		}
	}

	dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
		hFileMap,
		FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
		0, //offsets: onde é mapeada 
		0, //0 para mapear até ao final
		0 //0 para mapear até ao final
	);
	if (dados.memoriaPartilhada == NULL) {
		_tprintf(TEXT("\nerro no MapViewOfFile"));
		return 1;
	}

	//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
	if (primeiroProcesso == TRUE) {
		dados.memoriaPartilhada->numeroConsumidores = 0;
		dados.memoriaPartilhada->numeroProdutores = 0;
		dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
		dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
	}
	//criar a thread
	dados.controloDaThread = 0;

	//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
	WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
	//ir à memoria partilhada
	dados.memoriaPartilhada->numeroConsumidores++;
	dados.idConsumidor = dados.memoriaPartilhada->numeroConsumidores;
	//libertar o mutex
	ReleaseMutex(dados.hMutexControloExclusaoMutua);

	HANDLE hThread;
	TCHAR comando[100];
	hThread = CreateThread(NULL, 0, ThreadConsumidor, &dados, 0, NULL);
	if (hThread != NULL) {
		_tprintf(TEXT("escreve qualquer coisa para sair"));
		_getts_s(comando, 100);
		dados.controloDaThread = 1;
		WaitForSingleObject(hThread, INFINITE);
	}

	UnmapViewOfFile(dados.memoriaPartilhada);
	//CloseHandle();


	return 0;
}

produtor

//produtor
#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h> //lidar com o random


#define TAM_BUFFER_CIRUCLAR 10 //importante para os semáforos, numero de posicoes do buffer circular


typedef struct {
	int id;
	int val;
} CelulaBufferCircular; //estrutura de cada célula do buffer circular

typedef struct {
	int numeroProdutores;
	int numeroConsumidores;
	int proximaPosicaoEscrita; //controlar
	int proximaPosicaoLeitura; //controlar
	CelulaBufferCircular buffer[TAM_BUFFER_CIRUCLAR];
} BufferCircular; //representação da memoria partilhada


typedef struct {
	BufferCircular* memoriaPartilhada;
	HANDLE hSemaforoControlaEscrita;
	HANDLE hSemaforoControloLeitura;
	HANDLE hMutexControloExclusaoMutua; //mutex: exclusivo e partilhado por todos os produtores
	int controloDaThread; //flag, 1 sair, 0 caso contrário
	int idProdutor;
}DadosThreads;

//lidar com o random
int numero_aleatorio(int min, int max) {
	return rand() % (max - min + 1) + min; //valor entre min e max
}


//a trhead produtor
DWORD WINAPI ThreadProdutor(LPVOID param) {
	DadosThreads* dados = (DadosThreads*)param;
	CelulaBufferCircular celBC;  //teriam que ser vários fosse o caso de enviar para vários consumidores a informação de todos os produtores
	int contadorItensProduzidos = 0;

	while (dados->controloDaThread == 0) {
		celBC.id = dados->idProdutor;
		//produzir o item
		celBC.val = numero_aleatorio(10,99);

		//escrever no buffer circular, 
		WaitForSingleObject(
			dados->hSemaforoControlaEscrita, //existe uma posição para escrevermos
			INFINITE
		); 
		//temos a garantia que temos uma posicção de escrita
		WaitForSingleObject(
			dados->hMutexControloExclusaoMutua, //existe uma posição para escrevermos
			INFINITE
		);
		//temos a garantia que somos nos a escrever
		//os dois estão desbloqueados e vamos ser o unico produtor que vai escrever
		CopyMemory(
			&dados->memoriaPartilhada->buffer[dados->memoriaPartilhada->proximaPosicaoEscrita], //destino, copiar
			&celBC, 
			sizeof(CelulaBufferCircular)
		);
		//a proxima posicao de escrita é incrementada
		dados->memoriaPartilhada->proximaPosicaoEscrita++;
		//cheguei ao limite volto à posicao 0
		if (dados->memoriaPartilhada->proximaPosicaoEscrita == TAM_BUFFER_CIRUCLAR) {
			dados->memoriaPartilhada->proximaPosicaoEscrita = 0;
		}
		//libertar o mutex
		ReleaseMutex(dados->hMutexControloExclusaoMutua);
		//libtertar o semaforo de leitura
		//se ocupamos uma posição de escrita libertamos uma posição de leitura
		//o produtor espera por uma posição de escrita e desbloqueia uma posição de leitura
		//e o consumidor espera por uma posição de leitura e desbloqueia uma posição de escrita
		ReleaseSemaphore(dados->hSemaforoControloLeitura, 1, NULL); //apenas uma posição, 1

		contadorItensProduzidos++;
		_tprintf(TEXT("\nProdutor %d produziu valor %d "), dados->idProdutor, celBC.val);
		Sleep(numero_aleatorio(2, 4)*1000);
	}
	_tprintf(TEXT("\nProdutor %d produziu  %d itens"), dados->idProdutor, contadorItensProduzidos);
	return 0;
}


int _tmain(int argc, LPSTR argv[]) {
	HANDLE hFileMap;
	//mapeamento da memoria partilhada
	DadosThreads dados;
#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	//lidar com o random
	srand((unsigned int)time(NULL));

	//os semaforos
	dados.hSemaforoControlaEscrita = CreateSemaphore(
		NULL,
		TAM_BUFFER_CIRUCLAR,
		TAM_BUFFER_CIRUCLAR,
		TEXT("SO2_MEMORIA_ESCRITA")
	);
	if (dados.hSemaforoControlaEscrita == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControlaEscrita"));
		return 1;
	}
	dados.hSemaforoControloLeitura = CreateSemaphore(NULL,
		0, //quantidade de posições iniciais, não existe nada para ser lido
		TAM_BUFFER_CIRUCLAR, //maximo de posições para serem lidas
		TEXT("SO2_MEMORIA_LEITURA")
	);
	if (dados.hSemaforoControloLeitura == NULL) {
		_tprintf(TEXT("\nerro no hSemaforoControloLeitura"));
		return 1;
	}
	//exclusao mutua para os produtores
	dados.hMutexControloExclusaoMutua = CreateMutex(NULL, FALSE, TEXT("SO2_MUTEX_PRODUTOR"));
	if (dados.hMutexControloExclusaoMutua == NULL) {
		_tprintf(TEXT("\nerro no hMutexControloExclusaoMutua"));
		return 1;
	}

	hFileMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, TEXT("SO2_MEMORIA_PARTILHADA"));
	int primeiroProcesso = FALSE;

	//se existir é aberto
	//se nao existe é nulo
	if (hFileMap == NULL) {
		//existe um problem é porque se calahar não existe
		//criar a memoria partilhada
		primeiroProcesso = TRUE;
		hFileMap = CreateFileMapping(INVALID_HANDLE_VALUE,//INVALID_HANDLE_VALUE ao inves de um ficheiro, faz o sistema isso
			NULL,
			PAGE_READWRITE, //nivel de protecão: lieura e escrita); 
			0, //dimensões da memoria partilhada: mais significativa
			sizeof(BufferCircular), //dimensões da memoria partilhada: menos significataiva
			TEXT("SO2_MEMORIA_PARTILHADA")//nome do file mapping: que vai ser criado e aberto pelos outros, nome em MACRO
		);
		if (hFileMap == NULL) {
			_tprintf(TEXT("\nerro no CreateFileMapping"));
			return 1;
		}
	}

	dados.memoriaPartilhada = (BufferCircular*)MapViewOfFile(
		hFileMap,
		FILE_MAP_ALL_ACCESS, //permissoes, de leitura e escrita
		0, //offsets: onde é mapeada 
		0, //0 para mapear até ao final
		0 //0 para mapear até ao final
	);
	if (dados.memoriaPartilhada == NULL) {
		_tprintf(TEXT("\nerro no MapViewOfFile"));
		return 1;
	}

	//inicialização: só deve ser feita quando a mem partilhada é criada, pois podemos ter N produtores.
	if (primeiroProcesso == TRUE) {
		dados.memoriaPartilhada->numeroConsumidores = 0;
		dados.memoriaPartilhada->numeroProdutores = 0;
		dados.memoriaPartilhada->proximaPosicaoEscrita = 0;
		dados.memoriaPartilhada->proximaPosicaoLeitura = 0;
	}
	//criar a thread
	dados.controloDaThread = 0;
	
	//exclusão mutua proque queremos aceder a algo que está em memoria partilhada
	WaitForSingleObject(dados.hMutexControloExclusaoMutua, INFINITE);
	//ir à memoria partilhada
	dados.memoriaPartilhada->numeroProdutores++;
	dados.idProdutor = dados.memoriaPartilhada->numeroProdutores;
	//liberta ro mutex
	ReleaseMutex(dados.hMutexControloExclusaoMutua);
	
	HANDLE hThread;
	TCHAR comando[100];
	hThread = CreateThread(NULL, 0, ThreadProdutor, &dados, 0, NULL);
	if (hThread != NULL) {
		_tprintf(TEXT("escreve qualquer coisa para sair"));
		_getts_s(comando, 100);
		dados.controloDaThread = 1;
		WaitForSingleObject(hThread, INFINITE);
	}

	UnmapViewOfFile(dados.memoriaPartilhada);
	//CloseHandle();


	return 0;
}

repo: atende cliente OverLappedIO

Cliente:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"


DWORD WINAPI leResposta(LPVOID lpData) {
	HANDLE hPipe = (HANDLE)lpData;
	TCHAR szStr[TAM];
	DWORD dwLidos, res;


	OVERLAPPED ov;
	HANDLE hEvento;
	hEvento = CreateEvent(NULL, TRUE, FALSE, NULL); //ultimo NULL evento local à thread não peciso de nome

	do {
		ZeroMemory(&ov, sizeof(ov));
		ov.hEvent = hEvento;
		//ResetEvent(hEvent);

		res = ReadFile(hPipe, szStr, TAM, &dwLidos, &ov); //nao fico à espera agora, fica agendada a operação
		if (res) {
			_tprintf(_T("foi realizada de imediato...\n"));
		}
		if (!res && GetLastError() == ERROR_IO_PENDING) { //proteção
			_tprintf(_T("a aguardar informação...\n"));
			/* .... */
			WaitForSingleObject(ov.hEvent, INFINITE);
			GetOverlappedResult(hPipe, &ov, &dwLidos, FALSE);
		}
		_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
	} while (_tcscmp(szStr, _T("SAIR")) != 0);
	
	return 0;
}


int _tmain(int argc, TCHAR* argv[]) {
	HANDLE hPipe;
	TCHAR szStr[TAM];
	DWORD dwEscritos;

#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif


	while (1) {
		//ligar ao servidor	
		hPipe = CreateFile(NOME_PIPE,
			GENERIC_READ | GENERIC_WRITE,
			0,
			NULL,
			OPEN_EXISTING,
			FILE_FLAG_OVERLAPPED,
			NULL);
		if (hPipe != INVALID_HANDLE_VALUE) {
			break;

		}
		if (!WaitNamedPipe(NOME_PIPE, 10000)) { //espera 10 segundos
			_tprintf(_T("[erro] named pipe nao existe "));
		}
	}

	//thread para ler resposta
	HANDLE hThread;
	DWORD dwTid;
	hThread = CreateThread(NULL, 0, leResposta, (LPVOID)hPipe, 0, &dwTid);

	OVERLAPPED ov;
	HANDLE hEvento;
	hEvento = CreateEvent(NULL, TRUE, FALSE, NULL);

	//thread inicial
	do {
		_tprintf(_T("TEXTO: "));
		if (_fgetts(szStr, TAM, stdin) == NULL) {
			break;
		}
		szStr[_tcslen(szStr) - 1] = _T('\0');

		ZeroMemory(&ov, sizeof(ov)); //limpar
		ov.hEvent = hEvento; //atribuir
		//ResetEvent(hEvent)//nao é necessário

		WriteFile(hPipe, szStr, ((DWORD)_tcslen(szStr) + 1) * sizeof(TCHAR), &dwEscritos, &ov); //envia info para o servidor, e não bloqueia. dwEscritos total de bytes escritos
		//devia verificar e
//true correu bem																								//true: correu bem
		//false: correu mal
		//getpasteerror, que a oepração foi agendada

		/* .. podemos fazer o que quiseremos não é tão critico.. */
		WaitForSingleObject(ov.hEvent, INFINITE);//esperar que o evento seja assinalado
		GetOverlappedResult(hPipe, &ov, &dwEscritos, FALSE); //esperar que o write foi concluido. dwEscritos verificar se o numero de bytes foram escritos
		_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
	} while (_tcscmp(szStr, _T("SAIR")) != 0);
	return 0;
}

Servidor:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"


DWORD WINAPI atendeCliente(LPVOID lpData) {
	HANDLE hPipe = (HANDLE)lpData;
	TCHAR szStr[TAM];
	DWORD dwLidos, dwEscritos;

	_tprintf(_T("Cliente ligado...\n"));
	while (1) {
		if (!ReadFile(hPipe, szStr, TAM, &dwLidos, NULL)) { //lê pedido..
			break;
		}
		_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos); 
		CharUpperBuff(szStr, dwLidos/sizeof(TCHAR)); //processa
		WriteFile(hPipe, szStr, dwLidos, &dwEscritos, NULL); //envia resposta
		_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
	}
	_tprintf(_T("O cliente desligou...\n"));
	FlushFileBuffers(hPipe);
	DisconnectNamedPipe(hPipe);
	CloseHandle(hPipe);
	return 0;
}

int _tmain(int argc, TCHAR* argv[]) {
	HANDLE hPipe;
	DWORD dwTid;

#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	
	while (1) {
		//cada vez que um cliente se ligar é criada uma nova thread
		hPipe = CreateNamedPipe(
			NOME_PIPE, 
			PIPE_ACCESS_DUPLEX,
			PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 
			PIPE_UNLIMITED_INSTANCES, 
			BUFFSIZE, 
			BUFFSIZE, 
			10000, 
			NULL);
		if (ConnectNamedPipe(hPipe, NULL)) {
			CreateThread(NULL, 0, atendeCliente, (LPVOID)hPipe, 0, &dwTid);
		}
	}
	return 0;
}

Util:

#define TAM 100
#define NOME_PIPE TEXT("\\\\.\\pipe\\teste")
#define BUFFSIZE 1024

repo: atende cliente

Cliente:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"


int _tmain(int argc, TCHAR* argv[]) {
	HANDLE hPipe;
	TCHAR szStr[TAM];
	DWORD dwLidos, dwEscritos;

#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif

	while (1) {
		//cada vez que um cliente se ligar é criada uma nova thread
		hPipe = CreateFile(NOME_PIPE, 
			GENERIC_READ | GENERIC_WRITE,
			0,
			NULL,
			OPEN_EXISTING,
			0,
			NULL);
		if (hPipe != INVALID_HANDLE_VALUE) {
			break;
			
		}
		WaitNamedPipe(NOME_PIPE, 10000); //espera 10 segundos
	}
	do{
		_tprintf(_T("TEXTO: "));
		if (_fgetts(szStr, TAM, stdin) == NULL) {
			break;
		}
		szStr[_tcslen(szStr) - 1] = _T('\0');
		WriteFile(hPipe, szStr, ((DWORD)_tcslen(szStr) + 1) * sizeof(TCHAR), &dwEscritos, NULL);
		_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
		ReadFile(hPipe, szStr, TAM, &dwLidos, NULL);
		_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos);
	} while (_tcscmp(szStr, _T("SAIR")) != 0);
	return 0;
}

Servidor:

#include <Windows.h>
#include <tchar.h>
#include <math.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <time.h>
#include "..\cliente\util.h"


DWORD WINAPI atendeCliente(LPVOID lpData) {
	HANDLE hPipe = (HANDLE)lpData;
	TCHAR szStr[TAM];
	DWORD dwLidos, dwEscritos;

	_tprintf(_T("Cliente ligado...\n"));
	while (1) {
		if (!ReadFile(hPipe, szStr, TAM, &dwLidos, NULL)) { //lê pedido..
			break;
		}
		_tprintf(_T("Recebi: %s (%d)\n"), szStr, dwLidos); 
		CharUpperBuff(szStr, dwLidos/sizeof(TCHAR)); //processa
		WriteFile(hPipe, szStr, dwLidos, &dwEscritos, NULL); //envia resposta
		_tprintf(_T("Enviei: %s (%d)\n"), szStr, dwEscritos);
	}
	_tprintf(_T("O cliente desligou...\n"));
	FlushFileBuffers(hPipe);
	DisconnectNamedPipe(hPipe);
	CloseHandle(hPipe);
	return 0;
}

int _tmain(int argc, TCHAR* argv[]) {
	HANDLE hPipe;
	DWORD dwTid;

#ifdef UNICODE 
	_setmode(_fileno(stdin), _O_WTEXT);
	_setmode(_fileno(stdout), _O_WTEXT);
	_setmode(_fileno(stderr), _O_WTEXT);
#endif
	
	while (1) {
		//cada vez que um cliente se ligar é criada uma nova thread
		hPipe = CreateNamedPipe(
			NOME_PIPE, 
			PIPE_ACCESS_DUPLEX,
			PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 
			PIPE_UNLIMITED_INSTANCES, 
			BUFFSIZE, 
			BUFFSIZE, 
			10000, 
			NULL);
		if (ConnectNamedPipe(hPipe, NULL)) {
			CreateThread(NULL, 0, atendeCliente, (LPVOID)hPipe, 0, &dwTid);
		}
	}
	return 0;
}

Util:

#define TAM 100
#define NOME_PIPE TEXT("\\\\.\\pipe\\teste")
#define BUFFSIZE 1024