Categoria: Linguaggio C

Pubblicato il

Thread Join in linguaggio C

Di seguito viene mostrato un esempio di codice che crea un thread nel cui codice viene generato un numero casuale da 1 a 6, simulando il lancio di un dado.

#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>

int parametroOUT;
void* codice(void *arg){
	srand(time(NULL));
	parametroOUT = (rand() % 6)+1;
	pthread_exit((void*) &parametroOUT);
}

int main(){
	int *risultato;
	pthread_t t1;
	pthread_create(&t1, NULL, codice, NULL);
	pthread_join(t1, (void*) &risultato);
	printf("dado estratto: %d\n", *risultato);
	return 0;
}
Pubblicato il

Fork Join in linguaggio C

Di seguito si mostra un esempio del costrutto Fork Join utilizzando le funzioni fork() e wait() del linguaggio C. In particolare sia il processo padre che il processo figlio eseguiranno in parallelo dei calcoli ed in fine il processo padre sommerà i risultati dei calcoli paralleli.

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

int potenza(int n, int e){
	int k=n;
	int i;
	printf("1.1 elab. parallela processo figlio\n");
	for(i=1;i<e;i++) k=k*n;
	return k;
}

int fattoriale(int n){
	int k=n;
	int i;
	printf("1 elab. parallela processo del padre\n");
	for(i=n-1;i>0;i--) k=k*i;
	return k;
}

int somma(int a, int b){
	int k;
	printf("2 elab. finale padre \n");
	k=(a+b);
	return k;
}

int main(){
	int x, y, z, retv;
	pid_t pid;
	pid=fork();				//inizio elaborazione parallela
	if(pid == 0){
		x=potenza(3,3);		//esecuzione parallela calcoli figlio
		exit(x);			//termina processo figlio
	}
	else{
		y=fattoriale(4);	//esecuzione parallela calcoli padre
	}
	printf(".. join: padre aspetta \n");
	wait(&retv);			//join: il padre aspetta il figlio
	x = WEXITSTATUS(retv);	//prende il risultato del figlio
	z = somma(x,y);			//esegue gli ultimi calcoli
	printf("-> risultato finale z = %d \n", z);
}
Pubblicato il

Utilizzare gli array, il ciclo for, i numeri random e la funzione potenza nel linguaggio C

Scrivere un programma in C che popola un array di grandezza DIM_ARRAY con un ciclo for inserendo un valore casuale tra 1 e 100.
Successivamente copiare la potenza di 2 di ogni valore dell’array A in un nuovo array B ma con ordine inverso.

#include <stdio.h>
#include <stdlib.h>
#include <time.h> //questa libreria mi serve per richiamare la funzione time(0)
#include <math.h> //pow(n,e);  n=numero e=esponente es: pow(5,2) = 25
 
#define DIM_ARRAY 10

void main() {
	int A[DIM_ARRAY];
	int B[DIM_ARRAY];
	int i;
	srand(time(0));	//inizializiamo il generatore su time(0) per avere valori sempre diversi
	printf("Inizializzo e stampo Array A\n");
	for(i=0;i<DIM_ARRAY;i++){
		A[i]=1+rand()%100; //inserisco nell'array un numero casuale tra 1 e 100
		printf("A[%d]: %d",i,A[i]);
		printf("\n");
	}
	printf("Inizializzo e stampo Array B\n");
	int j=0;
	for(i=DIM_ARRAY-1;i>=0;i--){
		B[i]=pow(A[j],2);
		j++;
		printf("B[%d]: %d",i,B[i]);
		printf("\n");
	}
}
Pubblicato il

Codifica da sistema decimale a binario oppure ottale usando la ricorsione

Abbiamo già visto un esempio di programma per la conversione dal sistema decimale a quello binario, in questa occasione invece vorrei proporvi una modifica sostanziale del codice già visto per poter codificare anche da decimale a ottale, evitando di usare gli array, quest’ultima peculiarità è stata possibile introducendo il concetto di ricorsione. Spiegherò brevemente cos’è un algoritmo ricorsivo ma vi esorto ad approfondire su Wikipedia.

Leggi tutto “Codifica da sistema decimale a binario oppure ottale usando la ricorsione”