[Alhazred]

Originariamente inviato da LoryOne
...
Come faccio a distinguere la prima istanza dalla seconda ?

La stesura del codice non può essere diversa per le due istanze, quindi ciò che cambia è il flusso delle istruzioni all'interno del programma stesso.
E' quindi assolutamente necessario definire una sorta di flag che acquisti due valori differenti in base all'istanza attiva in quel momento e che comandi l'esecuzione della porzione di codice corretta.

E' da tener presente che qualunque struttura tu decida di adibire allo scambio dei dati, questa DEVE necessariamente riportare il valore di tale flag.

Pensavo di usare gli ID dei processi.

Poichè è sempre lo stesso codice che opera sullo stesso PC (anche se in due istanze distinte), il programma dovrà necessariamente essere impostato sia per la ricezione sia per il trasferimento dei dati ma il punto principale è che solo quando entrambi i giocatori avranno disposto le navi sulla griglia si potrà dare avvio al gioco.

Già ma come ?
A chi toccherà fare la prima mossa ?
Supponendo che A sia il primo giocatore a sferrarre l'attacco (prima istanza) e quindi in trasmissione dati,B (seconda istanza) dovrà per forza essere in ricezione ma attenzione:
A e B non sono due programmi differenti bensì due istanze dello stesso programma.

E' su questo che sto sbattendo la testa da stamattina, "come faccio a dire all'avversario: tocca a te?"

...
Beh, la creazione della memoria condivisa è una di quei punti legati al flag a cui accennavo prima in quanto deve essere creata una sola volta ma accessibile più volte sia in lettura che in scrittura.
Perchè in lettura-scrittura ?
Perchè quando toccherà ad A fare una mossa, la memoria condivisa dovrà contenere le dislocazioni della flotta avversaria. A leggerà le coordinate di B, la confronterà con le sue coordinate comunicherà a B l'esito del colpo ed infine riempirà la memoria condivisa con le sue dislocazioni.
Poi sarà la volta di B e via di seguito finchè uno dei due non si sarà stancato o avrà vinto.

Sto scrivendo ora il pezzo di codice che dovrà chiedere all'inizio il posizionamento delle navi, ho pensato di memorizzarle in un array composto da tante posizioni quante sono le navi da piazzare, ogni posizione dell'array è un tipo strutturato a 2 campi (riga e colonna).
Ogniuno di questi array è visibile solo all'istanza che lo ha creato

Per creare una sola volta la memoria condivisa, la primissima cosa da fare sarà:
-p1 Controllare che non vi sia in memoria una prima istanza del programma
-p1a Se p1=0 (sono io la prima istanza) vado a p1b altrimenti ad p1c
-p1b Creo la memoria condivisa
-p1c procedo col resto del programma

questa l'ho implementata così:

if(argc == 1) { /*Se è vera vuol dire che questa è la prima istanza,
					  setto campo = griglia, creo la memoria condivisa e il semaforo*/
		for(i=1; i<11; i++)
			for(j=1; j<11; j++)
				griglia[i][j] = ' ';
		for(i=1; i<11; i++)
			for(j=1;j<11;j++)
				campo[i][j] = griglia[i][j];

		//Creazione memoria condivisa
		mapping = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,0,"shared_mem");
		if(mapping == INVALID_HANDLE_VALUE)Errore_("Errore nella creazione della memoria condivisa");

		//Creazione semaforo
		sem = CreateSemaphore(NULL,1,1,"semaforo");
		if(sem == INVALID_HANDLE_VALUE)Errore_("Errore nella creazione del semaforo");
	}
	else { //Altrimenti è la seconda e setto campo = griglia2, il semaforo già esiste
		for(i=1; i<11; i++)
			for(j=1; j<11; j++)
				griglia2[i][j] = ' ';
		for(i=1; i<11; i++)
			for(j=1;j<11;j++)
				campo[i][j] = griglia2[i][j];
	}