Mensajes

Chicos, inmensamente agradecido, gracias a todos sus datos entendí que me hacía falta en mi código y ahora todo funciona. Muchas gracias!!!

Creo amigo que tienes una confunción entre muchos conceptos.

1º Una página web se divide en 2 tipos de tecnologías las que llamamos por un lado Front-end y por el otro back-end.

Front-end: todo lo que tu ves por tu pantalla al momento de cargar la página web (formas, colores, efectos de movimiento,etc).

En el front-end (lado del cliente), las herramientas más importantes son:

- HTML: Las etiquetas que permiten dar estructura a tu página y crear formularios.

- CSS: Hojas de estilos en cascada (nombre rebuscado pero oficial). De lo que se encargan este tipo de archivos es dar color (ej: del fondo de una página o parte de ella),tamaño (ej: imagenes) y formato (ej tipo de letra como times new roman u otros). Todas estas cosas y muchas más las hace CSS sobre alguna etiqueta que tu crees en un archivo html.

- javascript: Se encarga de permitir que las etiquetas tengan efectos visuales y de que la información que tu escribas en la página web viaje al back-end.

Ahora hablemos del back-end (lado del servidor):

Back-end: Hace refencia a todo lo que maneja la información que tu enviaste desde la página web. Por ejemplo cuando escribiste datos en un formulario para registrarte en la página que estas visitando y apretaste el botón "Registrarte", javascript envía la información al back-end y la recive otro tipo de tecnologías las cuales son:

- PHP: Lenguaje del lado del servidor que se encarga de recibir información de una página y decirle al SQL que se encargue de guardarla, eliminarla, modificarla o actualizarla en la base de datos según corresponda. Es PHP quien analiza los datos guardados en la base de datos y los ordena, compara, calcula algún dato de tu interes o lo que sea que el código le indique para devolverlo al Front-end.

-SQL: el lenguaje que se encarga de manejar las bases de datos (como ya se dijo anterioremente).

- Apache: este es el ambiente en donde deben estar instaladas las herramientas de manipulación de datos del back-end (PHP y SQL).  Apache es una herramienta que permite que el servidor (back-end) pueda hacer su trabajo con las herramientas antes mencionadas.

Esta es una estructura básica para entender cómo funcionan las páginas web

Asi que para hacer todo lo que quieres,primero debes saber manejar cada una de esas herramientas.

Saludos!

Hola Estimados/as. Junto con saludar me gustaría recurrir a su experiencia en inyección de bases de datos sql. Resulta que tengo que impedir que se pueda realizar una inyección SQL en una base de datos SQLite. Me piden ocupar específicamente el uso de prepared
statements.

Ejemplo:

Código (sql) [Seleccionar] Expandir


"SELECT * FROM Alumno WHERE rut = ​:rut​"


El código que tengo (que funciona por cierto) es:

Código (sql) [Seleccionar] Expandir


define("SQLITE_DB_PATH", "navegadorcito.db");

$connection = new SQLite3(SQLITE_DB_PATH) or die("No se pudo Conectar con la base de Datos");

$sqlStr = "SELECT * FROM Alumno WHERE rut = " . $_GET["rut"];
   echo $sqlStr;
   $connection->query($sqlStr);
   $query = $connection->query($sqlStr);
   while($fila = $query->fetchArray()) {
       print_r($fila);
       echo "<br/>";
   }



Me imprime por pantalla los datos del rut ingresado por medio del link del navegador. Pero como sabrán los más experimentados, a este código facilmente se le puede poner una inyección sql.

He encontrado código como el siguiente:

Código (sql) [Seleccionar] Expandir



//Connect this creates a new PDO object
$db = new PDO('sqlite:/path/to/database.sdb');

//Build your sql query with parameters :field
$sql = "SELECT * FROM sometable WHERE someCol=:field";
//Prepare the above query
$statement = $db->prepare($sql);
//Bind the value received from the form or such with the parameter place holder
$statement->bindParam(':field', $_POST['someVal']);
//Execute the prepared query
$statement->execute();
//Fetch the result
$result = $statement->fetchAll(PDO::FETCH_ASSOC);


//Treat the result as a pure array
foreach ($result as $row){
   //do something
}

El cual ocupa el método de prepare statements para evitar la injección SQL en una base de datos SQLite, pero no puedo adaptarlo al código que yo tengo. Cada cambio que le hago me lanza un error por pantalla.

Hasta el momento mi principal duda es qué pongo dentro del PDO en ---new PDO('sqlite:/path/to/database.sdb');---

Si bien la base de datos que ocupo se llama navegadorcito.db, cada vez que pongo ese nombre ahí salta un error al cargar el archivo en el navegador.


Ojala me pudieran dar una mano para entender qué pasa.

Agradecido de antemano por leer esto, me despido.

podrias vaciar todos los demas elementos a un nuevo array

Tienes toda la razón, que idiota fui. Bueno, tal vez haya sido producto de la presión mientras estaba realizando el certamen (pues eran muchas cosas) y luego de eso me segué en que no sabía.

Muchas gracias bro.

De todas formas acá dejo el código para quien no le hayan funcionado las neuronas como yo:

Código (java) [Seleccionar] Expandir


public static void main (String []args){

int bus[] = new int [10];

for (int i = 0; i <bus.length-2; i++){

bus[i]=i*2;
}
int cont =0;
int prac[] = new int [10];
int variableEliminar=8;
for (int i = 0; i<bus.length-2; i++){

if(bus[i]!=variableEliminar){

prac[cont]=bus[i];
cont++;
}
}

System.out.println();

for (int i = 0; i <bus.length; i++){

System.out.println(bus[i]);
}

System.out.println();

    for (int i = 0; i <prac.length; i++){

System.out.println(prac[i]);
}
   
    bus=prac;
   
    System.out.println();

for (int i = 0; i <bus.length; i++){

System.out.println(bus[i]);
}
   
}



Tira por pantalla lo siguiente:

0
2
4
6
8
10
12
14
0
0

0
2
4
6
10
12
14
0
0
0

0
2
4
6
10
12
14
0
0
0

Hola que tal estimados. Muchas gracias por ingresar a leer esta pregunta que me tiene algo confuso.

Verán, resulta que vi un ejercicio en un certamen en donde se debía eliminar un elemento de un vector y correr los elementos de las otras posiciones para que así no se perdiera espacio.

Ejemplo de lo que digo:

Código (java) [Seleccionar] Expandir



public static void main (String []args){

int bus[] = new int [10];

for (int i = 0; i <bus.length-2; i++){

bus[i]=i*2;
}

                bus[0]=1;

System.out.println();

    for (int i = 0; i <bus.length; i++){

System.out.println(bus[i]);
}
   
}





El código de arriaba es sumamente burdo. Simplemente llené las posiciones de un vector dejando las ultimas 2 vacías.

Lo que lanza por pantalla es lo siguiente:

1
2
4
6
8
10
12
14
0
0


Mi pregunta es, imaginándome que yo quiero borrar el numero 8 de ese vector, ¿cómo lo borro y muevo los otros números para que el vector aproveche esa posición eliminada?


Estoy practicando para una evaluación de fin de semestre y me topé con este ejercicio en donde te obligan a trabajar con vectores. Espero me puedan ayudar. De antemano muchas gracias!

Hola chicos! que tal les va? espero que bien. Bueno, les cuento, estoy realizando ejercicios del libro silverchatz de Sistemas Operativos para prepararme para mi evaluación de fin de año. En fin, resulta que uno de los ejercicios que hice era crear un programa en C (linux) que ejemplificara una impresora a la cual le iban llegando diversos trabajos (documentos) a una cola de impresión y estos los debe ir imprimiendo según la prioridad que tengan dichos documentos. Bueno el programa ya lo hice, pero me dejó intrigado la pregunta teórica que viene después de realizar el código:

Que consideraciones hay que tomar si existen varias impresoras disponibles?

En el libro no hay solucionario para esta pregunta y en lo personal, no llego a una respuesta que me convenza. me podrían dar su opinión de cual es la respuesta más acertada?

Acá dejo el código en caso de que no se haya atendido lo anterior.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#define Max_Trabajo 60 // El número máximo de hebras Trabajos.


// Prototipos de funciones...

void *Trabajos(void *num);
void *servidor(void *);
void rango_espera(int secs);



//Se definen los semaforos.
//El semaforo colaimpresion pone el limite del numero de Trabajos que se permiten ingresar al cuarto de espera en un tiempo determinado.
sem_t colaimpresion;
// Ocupar_servidor asegura la mutua exclusividad en el acceso al uso del servidor.
sem_t Ocupar_servidor;
// DescansaServidor es usada para permitir que el servidor descanse hasta que llegue el Trabajo.
sem_t DescansaServidor;
// MantenerTrabajo es usada para hacer que el Trabajo espere hasta que el servidor haya imprimido el documento.
sem_t MantenerTrabajo;
// Bandera para la hebra del servidor cuando todos los Trabajos han sido atentidos.
int Todohecho = 0;
int TrabajosEsperandoServidor=0;
int numEspacios=1;

int main(int argc, char *argv[])
{
    int i;
    pthread_t btid;
    pthread_t tid[Max_Trabajo];
    int numTrabajos;
    int Numero[Max_Trabajo];
    printf("El ńumero maximo de Trabajos es 60. Ingresa el numero de Trabajos.\n");

    do{
    scanf("%d",&numTrabajos);

    if(numTrabajos > Max_Trabajo)printf("El nº de Trabajos debe ser menor a %d, ingrese nº de Trabajos.\n",Max_Trabajo);

   }while(numTrabajos>Max_Trabajo);

    if (numTrabajos > Max_Trabajo) {
       printf("El Maximo numero de Trabajos es %d.\n", Max_Trabajo);
       /******system("PAUSE");*****************/
       getchar();
       getchar();

       return 0;
    }
    printf("Tenemos un servidor que imprime documentos.\n");
    for (i = 0; i < Max_Trabajo; i++) {
        Numero[i] = i;
    }
    // Se inicializa el semaforo con valores iniciales...
    sem_init(&colaimpresion, 0, numEspacios);
    sem_init(&Ocupar_servidor, 0, 1);
    sem_init(&DescansaServidor, 0, 0);
    sem_init(&MantenerTrabajo, 0, 0);

    // Se Crea el servidor.
    pthread_create(&btid, NULL, servidor, NULL);

    // Se Crea el Trabajo.
    for (i = 0; i < numTrabajos; i++) {
        pthread_create(&tid[i], NULL, Trabajos, (void *)&Numero[i]);
    }
    // Se juntan las hebras a esperar que las otras terminen.
    for (i = 0; i < numTrabajos; i++) {
        pthread_join(tid[i],NULL);
    }
    // Cuando todos los Trabajos hayan terminado, se elimina la hebra servidor.
    Todohecho = 1;
    sem_post(&DescansaServidor); // Se despierta al servidor en la salida.
    pthread_join(btid,NULL);
    getchar();
    getchar();
    return 0;
}

void *Trabajos(void *Numero) {
     int num = *(int *)Numero; // periodo de tiempo aleatorio para llegar.
     printf("hebra %d creada\n", num);
     rango_espera(5);
     if(numEspacios+1==TrabajosEsperandoServidor)printf("Trabajo %d intenta ingresar a la cola de impresion\nEl Trabajo desiste de ingresar a la cola porque hay muchos trabajos\n", num); // Espere hasta que sea prudente ingresar a la cola de impresion...
     sem_wait(&colaimpresion);
    printf("Trabajo %d intenta ingresar a la cola de impresion \nTrabajo %d entra a la cola de impresion.\n************************************Hay %d Trabajos esperando a ocupar el servidor \n", num, num,++TrabajosEsperandoServidor); // Esperar a que el servidor este libre..
     
     //printf("*****************************************\n");
    // printf("**Hay %d Trabajos en la cola de impresion      **\n",TrabajosEsperandoServidor);
    // printf("*****************************************\n");
     sleep(10);
     sem_wait(&Ocupar_servidor); // Si el servidor está libre entonces un trabajo aprovecha.
     sem_post(&colaimpresion); // Despierta el servidor...
     printf("Trabajo %d ocupa el servidor.\n", num);
     sem_post(&DescansaServidor); // Espera a que el servidor termine de imprimir el trabajo.
     sem_wait(&MantenerTrabajo); // Deja de ocupar el servidor.
     sem_post(&Ocupar_servidor);
   printf("Trabajo %d deja de ocupar el servidor.\n************************************Hay %d Trabajos intentando ocupar el servidor\n", num,--TrabajosEsperandoServidor);
     
    // printf("*****************************************\n");
    // printf("**Hay %d Trabajos en la cola de impresion **\n",TrabajosEsperandoServidor);
     //printf("*****************************************\n");
     sleep(10);
}

void *servidor(void *junk)
{
// Mientras todavía hayan Trabajos que atender... El servidor es omniciente y puede decir si hay Trabajos aún en el camino a su tienda.

  while (!Todohecho) { // Esperar hasta que alguien llegue y te despierte..
    if( TrabajosEsperandoServidor==0 ) printf("el servidor esta esperando\n");
    sem_wait(&DescansaServidor); // Omitir todo esto al final...
    if (!Todohecho)
    { // Tomar un monto aleatorio de tiempo para imprimir el Trabajo..
     printf("el servidor esta imprimiendo el documento\n");
     rango_espera(3);
     printf("el servidor ha terminado de imprimir el documento.\n"); // Se libera al Trabajo cuando se haya imprimido el documento...
     sem_post(&MantenerTrabajo);
    }
    else {
         printf("El servidor ha terminado con la cola de impresion.\n");
    }
   }
}

void rango_espera(int secs) {
     int len = 1; // Se genera un numero arbitrario...
     sleep(len);
}



Gracias de Antemano!

Ya lo solucioné. Recordé que el modo en el cual se compila cuando se usan hebras y semáforos es diferente. Por eso me daba error a cada rato.

Acá dejo la solución para quien tenga un problema similar al mio:

https://foro.elhacker.net/programacion_cc/consulta_referencia_a_pthreadcreate_sin_definir-t389918.0.html

Que tal chicos. muchas gracias de antemano por darse el tiempo de leer esto. Verán, quiero ejecutar un programa que hice hace 1 año (y que en ese tiempo funcionaba correctamente). Ahora cuando lo intento compilar me salen los siguentes errores (todos por lo visto haciendo referencia a lo mismo):

referencia a "sem_init" sin definir
referencia a "sem_post" sin definir
referencia a "pthread_create" sin definir
referencia a "pthread_join" sin definir
referencia a "sem_wait" sin definir

Esos son. Se repiten varias veces. Soy muy amateur en el tema y no se por qué ahora (en comparación al año pasado) no puedo compilarlo y no se qué debo hacer para ejecutarlo. Por cierto, estoy trabajando en Ubuntu.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#define Max_Clientes 25 // El número máximo de hebras clientes.


// Prototipos de funciones...

void *clientes(void *num);
void *barbero(void *);
void rango_espera(int secs);

//Se definen los semaforos.
//El curto_espera pone el limite del numero de clientes que se permiten ingresar al cuarto de espera en un tiempo determinado.
sem_t cuartoespera;
// La SillaBarbero asegura la mutua exclusividad en el acceso a la silla del barbero.
sem_t SillaBarbero;
// AlmohadaBarbero es usada para permitir que el barbero descanse hasta que llegue el cliente.
sem_t AlmohadaBarbero;
// CinturonAsiento es usada para hacer que el cliente espere hasta que el barbero haya cortado su cabello.
sem_t CinturonAsiento;
// Bandera que para la hebra del barbero cuando todos los clientes han sido atentidos.
int Todohecho = 0;
int clientesBarberia=0;
int numSillas;

int main(int argc, char *argv[])
{
   int i;
   pthread_t btid;
   pthread_t tid[Max_Clientes];
   int numClientes;
   int Numero[Max_Clientes];
   printf("El ńumero maximo de clientes es 25. Ingresa el numero de clientes y sillas.\n");

   do{
   scanf("%d",&numClientes);
   scanf("%d",&numSillas);

   if(numClientes > Max_Clientes)printf("El nº de clientes debe ser menor a %d, ingrese nº de clientes y sillas nuevamente.\n",Max_Clientes);

  }while(numClientes>Max_Clientes);

   if (numClientes > Max_Clientes) {
      printf("El Maximo numero de Clientes es %d.\n", Max_Clientes);
      /******system("PAUSE");*****************/
      getchar();
      getchar();

      return 0;
   }
   printf("Una solucion al problema del barbero dormilon usando semaforos.\n");
   for (i = 0; i < Max_Clientes; i++) {
       Numero[i] = i;
   }
   // Se inicializa el semaforo con valores iniciales...
   sem_init(&cuartoespera, 0, numSillas);
   sem_init(&SillaBarbero, 0, 1);
   sem_init(&AlmohadaBarbero, 0, 0);
   sem_init(&CinturonAsiento, 0, 0);

   // Se Crea el Barbero.
   pthread_create(&btid, NULL, barbero, NULL);

   // Se Crea el Cliente.
   for (i = 0; i < numClientes; i++) {
       pthread_create(&tid[i], NULL, clientes, (void *)&Numero[i]);
   }
   // Se juntan las hebras a esperar que las otras terminen.
   for (i = 0; i < numClientes; i++) {
       pthread_join(tid[i],NULL);
   }
   // Cuando todos los clientes hayan terminado, se elimina la hebra barbero.
   Todohecho = 1;
   sem_post(&AlmohadaBarbero); // Se despierta al barbero en la salida.
   pthread_join(btid,NULL);
   getchar();
   getchar();
   return 0;
}

void *clientes(void *Numero) {
    int num = *(int *)Numero; // Sale de la tienda y toma algún periodo de tiempo aleatorio para llegar.
    printf("hebra %d creada\n", num);
    rango_espera(5);
    if(numSillas+1==clientesBarberia)printf("cliente %d llega a la barberia\nEl cliente abandona la barberia porque esta llena\n", num); // Espere hasta que haya espacio para abrir en la sala de espera...
    sem_wait(&cuartoespera);
   printf("cliente %d llega a la barberia \ncliente %d entra a la sala de espera.\n************************************Hay %d clientes en la barberia \n", num, num,++clientesBarberia); // Esperar a que la silla del barbero este libre..
   
    //printf("*****************************************\n");
   // printf("**Hay %d clientes en la barberia       **\n",clientesBarberia);
   // printf("*****************************************\n");
    sleep(10);
    sem_wait(&SillaBarbero); // Si la silla esta libre entonces abandona su lugar en la sala de espera..
    sem_post(&cuartoespera); // Despierta el Barbero...
    printf("cliente %d llama al barbero.\n", num);
    sem_post(&AlmohadaBarbero); // Espera a que el barbero termine de cortar su pelo.
    sem_wait(&CinturonAsiento); // Deja la silla.
    sem_post(&SillaBarbero);
  printf("cliente %d deja la barberia.\n************************************Hay %d clientes en la barberia\n", num,--clientesBarberia);
   
   // printf("*****************************************\n");
   // printf("**Hay %d clientes en la barberia **\n",clientesBarberia);
    //printf("*****************************************\n");
    sleep(10);
}

void *barbero(void *junk)
{
// Mientras todavía hayan clientes que atender... El barbero es omniciente y puede decir si hay clientes aún en el camino a su tienda.

 while (!Todohecho) { // Esperar hasta que alguien llegue y te despierte..
   if( clientesBarberia==0 ) printf("el barbero esta jugando\n");
   sem_wait(&AlmohadaBarbero); // Omitir todo esto al final...
   if (!Todohecho)
   { // Tomar un monto aleatorio de tiempo para cortar el cabello del cliente..
    printf("el barbero esta cortando el cabello\n");
    rango_espera(3);
    printf("el barbero ha terminado de cortar el cabello.\n"); // Se libera al cliente cuando ya se le haya cortado el pelo...
    sem_post(&CinturonAsiento);
   }
   else {
        printf("El barbero ha terminado por el dia.\n");
   }
  }
}

void rango_espera(int secs) {
    int len = 1; // Se genera un numero arbitrario...
    sleep(len);
}


Esa es mi duda, de antemano muchas gracias!

Hola chicos/as que tal? espero que estén bien. Vine nuevamente aquí porque uds siempre me sacan las dudas precisas que tengo, y debo aclarar que les estoy muy agradecido. Ahora bien necesito que por favor alguien me explique (si es posible con manzanitas o dibujitos xd) por qué ésta función de invertir lista funciona tan bien:

Código (c) [Seleccionar] Expandir



typedef struct NODO{

char *nombre;
struct NODO *sgte;

}nodo;

void invertirlista(nodo **inicio){

nodo *aux,*next;

aux=*inicio;
*inicio=NULL;

while(aux!=NULL){

next=aux->sgte;
aux->sgte=*inicio;
*inicio=aux;
aux=next;

}
}

El typedef lo coloqué por si alguien siente necesario saber como fue hecha la lista (aunque verdaderamente no creo que importe para la pregunta que estoy haciendo).Sé como crear,mostrar y eliminar listas y nodos, he intentado esquematizar ésta función tan corta pero no he podido aclararle a mi cabeza como funciona. De antemano muchas gracias por su ayuda  

Bueno, me parece que usted sabe de lo que habla aun que no entiendo exactamente cual es su objectivo final, pero eso es como hacer el codigo para que compila bien. Eso imprima hasta 32.

La proxima vez, deberia poner su error de compilicaion y decir que quiere hacer "un array de int dentro de un array de struct" : ) suerte

Código [Seleccionar] Expandir


typedef struct Humano
{
   int* Trabajos;          
} HUMANO, *PHUMANO;    
   
int main ()
{
      int CantidadDeTrabajos = 4; //
      int CantidadDePersonas = 8;    // personas
      int Cont = 0;
     
      // declarar espacio por un array de struct
      PHUMANO Primera = (PHUMANO)malloc(sizeof(HUMANO) * CantidadDePersonas);
     
      // por cada persona, declara un array dentro el struct
      for (int i = 0; i < CantidadDePersonas; i++)
          Primera[i].Trabajos = (int*)malloc(sizeof(int) * CantidadDeTrabajos);
     
      for (int i = 0; i < CantidadDePersonas; i++)
      {
          for (int j = 0; j < CantidadDeTrabajos; j++)
          {
              Cont += 1;
                 
              Primera[i].Trabajos[j] = Cont;
          }    
      }
     
      for (int i = 0; i < CantidadDePersonas; i++)
          for (int j = 0; j < CantidadDeTrabajos; j++)
              printf("Trabajo#%i\n", Primera[i].Trabajos[j]);
             
             
      //Primera[0].Trabajos[0] = 248;

      //printf("Primera->Trabajos = %i\n", Primera[0].Trabajos[0]);
     
     
      for (int i = 0; i < CantidadDePersonas; i++)
          free((int*)Primera[i].Trabajos);
     
      free(Primera);
      _getch ();
      return 0;
}



Modificacion - Al respecto a 1 - no estamos trabajando con los vectores, estos son arrayes (son parecidos pero hay diferencias). Todavia si estariamos trabajando con vectores, la alocacion dinamica no seria necesario por ese codigo. Tambien, los vectores son de C++, asi que si quiere usar vectores - seria mejor usar new/delete en vez de malloc/free (eso no va a cambiar el comportamiento de su programa, solo para notar la diferencia entre C y C++ y por que no es mejor practica a mezclarlos).

Generalmente, la alocacion dinamica es necesario solo cuando acepta algun tipo de input, sea de un archivo, stdin, socket, etc. Cuando hace un inicilizacion estatica (int i = 0), esa secion de memoria (los 4 bytes) SIEMPRE va a ser libre para manipular, si o si. 

Hermano, no sabes como te lo hipermegacontramuchoAGRADESCO!!! gracias a lo que hiciste entendí perfectamente que era lo que me hacía falta. Adapte lo que tu hiciste a mi código y mi error fundamental salió a la luz!! lo dejo aquí para que quien tenga éste problema pueda solucinarlo:

Mi código modificado según las apreciaciones de plataplomo2948 es éste:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct humano{

int *trabajos;

}persona;

int main(){

int i,j,cont=1;
int cantidad_personas=8;
int cantidad_trabajos=4;
persona *primera;
primera=(persona *)malloc(sizeof(persona)*cantidad_personas);


for (i=0; i < cantidad_personas; i++){
primera[i].trabajos=(int *)malloc(sizeof(int)*cantidad_trabajos);
}


for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

primera[i].trabajos[j]=cont;
cont++;
}
}

for (i = 0; i < cantidad_personas; i++){
for (j = 0; j < cantidad_trabajos; j++){

printf("%d ",primera[i].trabajos[j]);
}
printf("\n");
}

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

free((int *) primera[i].trabajos);
}

free(primera);

return 0;
}

Y él error fundamental que me permite ver toda la lógica de ésto era en ésta parte:

Código (c) [Seleccionar] Expandir

for (i=0; i < cantidad_personas; i++){
primera[i].trabajos=(int *)malloc(sizeof(int)*cantidad_trabajos);
}

Al momento de dimensionar esa parte nunca se me ocurrió hacerlo dentro de un for, y bajo lo que ahora al fin entendí (corrijame plataplomo2948 si estoy equivocado) es obligación dimensionar cada espacio de primera en consideración a la cantidad de trabajos que haya.

El código compila perfectamente y puedo dar por solucionada mi duda. Enserio  plataplomo2948 infinitas gracias, ahora puedo hacer lo que realmente quiero .

Por último si me permites molestarte, en la parte donde liberas memoria:

Código (c) [Seleccionar] Expandir

for (int i = 0; i < CantidadDePersonas; i++)
           free((int*)Primera[i].Trabajos);

por qué se pone (int *) dentro del free y no sólo

Código (c) [Seleccionar] Expandir

free(Primera[i].trabajos)?

Sólo esa pequeña duda me quedó, pero de antemano muchas gracias por todo bro, eres un crack!