Visualizzazione dei risultati da 1 a 4 su 4
  1. #1
    Utente di HTML.it
    Registrato dal
    Feb 2008
    Messaggi
    11

    [c] alcune domande "teoriche"

    Salve a tutti.
    Non sono riuscito a trovare molto su internet, e la maggior parte dei documenti è in inglese, dove arranco parecchio.
    Se avete qualche sito in particolare che mi può illuminare vi ringrazio.

    (le domande si riferscono al c, con un compilatore gcc e sistema linux)

    1-memoria dinamica: Quando creo "qualcosa" dinamicamente (array struct ecc...), questo alla terminazione del processo che lo ha creato viene liberato automaticamente dalla memoria?
    E se è all'interno di una funzione, all'uscita della funzione viene mantenuto in memoria?

    2-liberare memoria: Quando è necessario? (questo non l'ho ben capito, se mi fate due esempi vi rignrazio)

    3-come liberare memoria:
    Es:
    ho un array:
    int * array_di_int;

    va bene se lo libero cosi?:

    for(i=0;i<lunghezza_array;i++)
    free(array_di_int[i]);

    mentre come procedo se ho un:
    int ** array_di_int;

    4-proprietà processi creati con fork:
    Allora, quando creo dei processi con la fork, da quel che ho capito, si viene a creare un processo padre e uno figlio.
    Il figlio è la "copia" del padre, cioè ha lo stesso codice e la stessa "memoria" che ha il padre fino a quel momento. Condividono anche la tabella dei file aperti.
    Quindi sono praticamente lo stesso programma che si sdoppia? (correggete pure gli eventuali errori nella definizione sopra)

    5- gestione segnali.
    Se devo "passare" delle variabili alla funzione (da me definita) per gestire un certo segnale, come faccio? posso unicamente con le variabili globali?

    grazie a tutti.

  2. #2
    Moderatore di Programmazione L'avatar di alka
    Registrato dal
    Oct 2001
    residenza
    Reggio Emilia
    Messaggi
    24,288

    Moderazione

    In futuro, è meglio destinare una discussione separata a ciascuna domanda, senza accorpare in un'intera discussione più problematiche, generando ovviamente confusione.
    MARCO BREVEGLIERI
    Software and Web Developer, Teacher and Consultant

    Home | Blog | Delphi Podcast | Twitch | Altro...

  3. #3

    Re: [c] alcune domande "teoriche"

    Originariamente inviato da weo
    Salve a tutti.
    Non sono riuscito a trovare molto su internet, e la maggior parte dei documenti è in inglese, dove arranco parecchio.
    Se avete qualche sito in particolare che mi può illuminare vi ringrazio.

    (le domande si riferscono al c, con un compilatore gcc e sistema linux)

    1-memoria dinamica: Quando creo "qualcosa" dinamicamente (array struct ecc...), questo alla terminazione del processo che lo ha creato viene liberato automaticamente dalla memoria?
    Sì.
    E se è all'interno di una funzione, all'uscita della funzione viene mantenuto in memoria?
    Certo.
    2-liberare memoria: Quando è necessario? (questo non l'ho ben capito, se mi fate due esempi vi rignrazio)
    Quando non ti serve più della memoria che hai allocato dinamicamente. Un paio di esempi:
    codice:
    char * stringa = malloc(500); /* alloco nell'heap una stringa di 500 caratteri */
    /* uso la stringa */
    /* ... */
    /* ho finito di usarla e non mi serve più */
    free(stringa); /* la dealloco */
    stringa = NULL /* questo non è strettamente necessario, ma in questo modo sono sicuro di non utilizzare più il puntatore alla memoria che avevo allocato, che ora punta a memoria non allocata */
    codice:
    char stringa[500]; /* alloco sullo stack una stringa di 500 caratteri */
    /* uso la stringa */
    /* ... */
    /* ho finito di usarla e non mi serve più, ma, visto che è allocata sullo stack, non c'è bisogno di deallocarla, verrà deallocata automaticamente all'uscita dalla funzione */
    3-come liberare memoria:
    Es:
    ho un array:
    int * array_di_int;

    va bene se lo libero cosi?:

    for(i=0;i<lunghezza_array;i++)
    free(array_di_int[i]);
    No; devi fare così:
    codice:
    int * array_di_int;
    array_di_int = malloc(50 * sizeof(int)); /* alloco l'array in modo che contenga 50 interi */
    /* uso l'array */
    /* ... */
    /* lo dealloco */
    free(array_di_int);
    .
    In generale ricorda che ad ogni malloc corrisponde una free, non di più.
    mentre come procedo se ho un:
    int ** array_di_int;
    Be', dipende da come lo allochi e come lo utilizzi...
    4-proprietà processi creati con fork:
    Allora, quando creo dei processi con la fork, da quel che ho capito, si viene a creare un processo padre e uno figlio.
    Il figlio è la "copia" del padre, cioè ha lo stesso codice e la stessa "memoria" che ha il padre fino a quel momento. Condividono anche la tabella dei file aperti.
    Quindi sono praticamente lo stesso programma che si sdoppia? (correggete pure gli eventuali errori nella definizione sopra)
    Più o meno... tranne che la fork restituisce 0 al processo figlio e il PID del figlio al processo padre.
    Occhio però che, se non ricordo male, i due processi non condividono la stessa tabella dei file aperti, ognuno ne ha una differente con copie dei descrittori ai file (ma su questo non ci giurerei, aspetta risposte più autorevoli).
    Amaro C++, il gusto pieno dell'undefined behavior.

  4. #4
    Utente di HTML.it
    Registrato dal
    Mar 2004
    Messaggi
    81
    Occhio però che, se non ricordo male, i due processi non condividono la stessa tabella dei file aperti, ognuno ne ha una differente con copie dei descrittori ai file (ma su questo non ci giurerei, aspetta risposte più autorevoli).
    Padre e figlio hanno una tabella dei descrittori di file diverse (una copia) mentre la tabella dei file aperti è condivisa (e quindi anche il puntatore di I/O al prossimo dato da leggere e/o scrivere)

    Se devo "passare" delle variabili alla funzione (da me definita) per gestire un certo segnale, come faccio? posso unicamente con le variabili globali?
    Si, oppure l'handler per il segnale (quello che imposti con una chiamata a sigaction(...)) accetta come parametro un intero che assume sempre il valore del segnale intercettato.
    Fai attenzione che se accedi a variabili globali all'interno di un signal handler sarebbe meglio dichiararle di tipo volatile sig_atomic_t

    Spero di essere stato d'aiuto...Ciao!

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.