Buenos d'ias.
Pues veran estoy implementando 2 programas, para demostrar el uso de la Memoria compartida en lenguje C.
P1.C crea la zona de memoria a compartir y escribe en ella. Se muestra por consola lo escrito
P2.C va a la memoria y lee lo que hay escrito en ella. se muestra por consola lo leido.

Pero tengo un pequeño problema que no he podido solucionar en el archivo P2.C; lo que pasa es que no me ubica la zona de memoria especifica, y pues obviamente si no puede ubicar esta zona, no podra leer nada. Tengo entendido que la zona de memoria comprtida cuenta con una clave y un Id y debe de ser las misma para ambos Programas. Al imprimir las claves por pantalla me di cuenta de que son las mismas, pero en P2.C no me reconoce el id sociado a la clave comun.
Este es el codigo que tengo. Les dejare ambos archivos fuete. Por favor espero me ayuden y si en algo estoy mal, pues leo sus correciones. Gracias.

//
//	p1.c
#include <sys/shm.h>
#include <stdio.h>
#include <unistd.h>
 
void main()
{
	key_t Clave;
	int Id_Memoria;
	int *Memoria = NULL;
	int i,j;
 
	//
	//	Conseguimos una clave para la memoria compartida. Todos los
	//	procesos que quieran compartir la memoria, deben obtener la misma
	//	clave. Esta se puede conseguir por medio de la función ftok.
	//	A esta función se le pasa un fichero cualquiera que exista y esté
	//	accesible (todos los procesos deben pasar el mismo fichero) y un
	//	entero cualquiera (todos los procesos el mismo entero).
	//
	Clave = ftok ("/bin/ls", 33);
	if (Clave == -1)
	{
		printf("No consigo clave para memoria compartida\n");
		exit(0);
	}
	printf("la clave de la memoria compartida es: %d\n", Clave);
 
	//
	//	Creamos la memoria con la clave recién conseguida. Para ello llamamos
	//	a la función shmget pasándole la clave, el tamaño de memoria que
	//	queremos reservar (100 enteros en nuestro caso) y unos flags.
	//	Los flags son  los permisos de lectura/escritura/ejecucion 
	//	para propietario, grupo y otros (es el 777 en octal) y el 
	//	flag IPC_CREAT para indicar que cree la memoria.
	//	La función nos devuelve un identificador para la memoria recién
	//	creada.
	//	 
	Id_Memoria = shmget (Clave, sizeof(int)*100, 0777 | IPC_CREAT);
	if (Id_Memoria == -1)
	{
		printf("No consigo ID para memoria compartida\n");
		exit (0);
	}
	printf("el ID de la memoria compartida es: %i\n", Id_Memoria);
 
	//
	//	Una vez creada la memoria, hacemos que uno de nuestros punteros
	//	apunte a la zona de memoria recién creada. Para ello llamamos a
	//	shmat, pasándole el identificador obtenido anteriormente y un
	//	par de parámetros extraños, que con ceros vale.
	//
	Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
	if (Memoria == NULL)
	{
		printf("No consigo memoria compartida\n");
		exit (0);
	}
 
	//
	//	Ya podemos utilizar la memoria.
	//	Escribimos cosas en la memoria. Los números de 1 a 10 esperando
	//	un segundo entre ellos. Estos datos serán los que lea el otro
	//	proceso.
	//
	for (i=0; i<10; i++)
	{
		for (j=0; j<100; j++)
		{
			Memoria[j] = i;
		}
		printf("Escrito: %d\n",i);;
 
		sleep (1);
	}
 
	//
	//	Terminada de usar la memoria compartida, la liberamos.
	//
	shmdt ((char *)Memoria);
	shmctl (Id_Memoria, IPC_RMID, (struct shmid_ds *)NULL);
}
 

// p2.c Aca hay un problema, no me reconoce la zona de memoria que he creado en p1.c
//
#include <sys/shm.h>
#include <stdio.h>
#include <unistd.h>
void main()
{
	key_t Clave;
	int Id_Memoria;
	int *Memoria = NULL;
	int i,j;
 
	//
	//	Igual que en p1.c, obtenemos una clave para la memoria compartida
	//
	Clave = ftok ("/bin/ls", 33);
	if (Clave == -1)
	{
		printf("No consigo clave para memoria compartida\n");
		exit(0);
	}
	printf("la clave de la memoria compartida es: %d\n", Clave);
	//
	//	Igual que en p1.cc, obtenemos el id de la memoria. Al no poner
	//	el flag IPC_CREAT, estamos suponiendo que dicha memoria ya está
	//	creada. LA VERDAD CREO QUE ESTO NO FUNCIONA. PERO LEI QUE DEBERIA DE FUNCIONAR
	//
	Id_Memoria = shmget (Clave, sizeof(int)*100, 0777);
	if (Id_Memoria == -1)
	{
		printf("No consigo ID para memoria compartida\n");
		exit (0);
	}
	printf("el ID de la memoria compartida es: %i\n", Id_Memoria);
	//
	//	Igual que en p1.c, obtenemos un puntero a la memoria compartida
	//
	Memoria = (int *)shmat (Id_Memoria, (char *)0, 0);
	if (Memoria == NULL)
	{
		printf("No consigo memoria compartida\n");
		exit (0);
	}
 
	//
	//	Vamos leyendo el valor de la memoria con esperas de un segundo
	//	y mostramos en pantalla dicho valor. Debería ir cambiando según
	//	p1 lo va modificando.
	//
	for (i=0; i<10; i++)
	{
		printf("Leido: %d\n",Memoria[0]);
		sleep (1);
	}
 
 
	//
	//	Desasociamos nuestro puntero de la memoria compartida. Suponemos
	//	que p1 (el proceso que la ha creado), la liberará.
	//
	if (Id_Memoria != -1)
	{
		shmdt ((char *)Memoria);
	}
}
 

OK Me pondré a ello. Luego les cuento como me fue. En fin de todas formas gracias. Luego pongo el codigo hecho

Hola pues no soy muy bueno para usar punteros. Veran tengo que realizar un programa que me conste de tres tareas:

La tarea 1 genera los primeros 500 numeros pares.(0,2,4,6,...1000)
La tarea 2 genera los primeros 500 numeros impares.(1,3,5,7,...999)
La tarea 3 imprime los numeros generados por las dos tareas anterioresen orden (0,1,2,3,4,5...1000).

Mi idea es usar punteros, pues lo que se es que una funcion en C no puede retornar un array, sino un puntero. Hasta ahora tengo esto

---

Esto es lo que tengo hasta ahora. Se supone que tarea_A y tarea_B me generan dos punteros.
Luego, en que estoy mal????

#include <stdio.h>
 
int* tarea_A()
{
	int i;
	int j;
	int pares[500];
	for(i=0; i<=500; i++)
	{
		pares[i]=i*2;
 
	}
 
 
}
 
int* tarea_B()
{
	int i;
	int j;
	int impares[500];
	for(i=1; i<=500; i++)
	{
		impares[i]=(i*2)-1;
 
	}
 
}
 
 
void tarea_C()
{
	int* ptr_A = 0;
	int* ptr_B = 0;
 
	ptr_A = tarea_A();
	ptr_B = tarea_B();
 
	printf("OK %d \n ", *ptr_A);/*se supone que me debe de imprimir un numero-\*/		
	/*Aca estoy probando a ver si puedo imprimir los numeros*/
}
 
int main()
{
	tarea_C();		
}