[C] consigli per la struttura delle funzioni

[standard]

Ciao a tutti,
devo lavorare ad una serie di funzioni che "cronometrino" il tempo
di calcolo di un grosso programma. Siccome da poco ho ripreso il C, volevo sapere se questa impostazione poteva funzionare:

/*****************************    INCLUDE    *****************************/

#include <stdio.h>
#include <time.h>

/*****************************   STRUTTURE   *****************************/

struct cronometro{
	// time_t === long (misura di tempo, definita in time.h)
	time_t ti; //istante iniziale dell'elaborazione (effettiva) [ti === tempo iniziale]
	time_t tf; //istante finale e d'appoggio per i vari calcoli [tf === tempo finale]
	time_t t_iter; //tempo impiegato da un'iterazione
};

struct cronometro timer = {0,0,0};

/*****************************   PROTOTIPI   *****************************/
					
time_t inizializzaT();
time_t diffT();
time_t diffTStampa();
//time_t stimaT();
time_t niente();
time_t crono();

/*****************************   FUNZIONI    *****************************/

time_t inizializzaT(){return time(&timer.ti);}
time_t diffT(){return timer.ti?(time_t)difftime(time(&timer.tf),timer.ti):0;}

time_t diffTStampa(){
	time_t d = diffT();
	time_t o[3] ={d?d/3600:0,d?d/60:0,d?d%60:0};
	return d?(printf("\n[%2d:%2d:%2d] (ore:min:sec)\n",o[0],o[1],o[2]),1):0;
}

//time_t stimaT(){}
time_t niente(){return 0;}


time_t crono(int opzione){
	// "motore" per tutte le operazioni legate al calcolo del tempo
	// di elaborazione.
	// Funziona distribuendo il controllo alle varie funzioni a seconda
	// del parametro opzione.
	// Nel dettaglio, delega il puntatore a funzione fpt ad assumere il
	// ruolo giusto in funzione del parametro.
	time_t (*fpt)();

	timer.tf = time((!timer.ti?&timer.ti:NULL));
	fpt =	opzione==0?inizializzaT:
		opzione==1?diffT:
		opzione==2?diffTStampa:
		niente;
	return fpt();
}


/*****************************    MAIN    ********************************/

int main(){
	char c;

	crono(0);
	
	printf("attendi qualche secondo prima di premere <INVIO>\n");
	c = getchar();

	printf("\n%d\n",crono(1));
	crono(2);

}

che ne pensate?
ovviamente dove c'è il getchar ci sarà il programma vero e proprio, ma è per capirci.
Ho pensato che così facendo potevo espandere le funzionalità di questo cronometro aggiungendo nuove funzioni e aggiornando il puntatore fpt.
Sto andando bene?

[gdipietro]

Non vorrei dire una ca****ata
--
timer.tf = time((!timer.ti?&timer.ti:NULL));
fpt = opzione==0?inizializzaT:
opzione==1?diffT:
opzione==2?diffTStampa:
niente;
--

ma non dovresti aggiungere le parentesi durante
le chiamate alle funzioni ??

Poi per il resto credo sia ok, anche se personalmente
passerei da input un parametro per attivare o meno la stampa
del tempo di esecuzione delle funzioni che mi interessano.

[standard]

innanzitutto grazie per l'attenzione,
ma io avevo messo le parentesi proprio per evitare qualunque problema, visto che usavo l'operatore ternario.
Non so...ma non mi sembra una pratica pericolosa, non vorrei
sbagliare...ma ad esempio, mi capita (per compattezza nel codice)
si usare l'operatore virgola nella chiamata alle funzioni tipo:

f((espressione1,espressiones,ecc,ultima))

per passare come parametro (ultima) un valore che dipende dalle espressioni precedenti. Mi pare sia una cosa lecita.

Poi stavo pensando, non è possibile creare una sorta di metodi per
il timer? non so se sia possibile in C...io pensavo una cosa del genere:

struct cronometro{
tipo (*metodo)(parametri);
}

struct cronometro timer;

timer.metodo = nomefunzione;

è possibile?
intanto provo.
ciauz

[standard]

ok
funziona, in questo modo ho creato una specie di metodo per timer,
percui posso usare la sintassi:

timer.metodo(parametri)

ora, un'altra domanduccia.
Vorrei metter il file (senza main ovviamente) in un file .h
C'è un modo per rendere accessibili solo alcune funzioni all'esterno del file?
o solo certe variabili?

penso di no.

qualcuno che confermi? (o smentisca magari)

ciauz

[TheGreatWorld]

Dovresti spiegare un po più precisamente cosa intendi con rendere accessibili.. se vuoi che lo scope sia 'solo' limitato ad un file o visibile da tutto il programma etc. etc. Cmq complimenti hai appena scoperto come implementare una funzione membro in una struttura. Chiunque abbia nozioni di C++ anche non strepitose lo avrà fatto almeno una volta..

bye

[standard]

Originariamente inviato da TheGreatWorld
Dovresti spiegare un po più precisamente cosa intendi con rendere accessibili.. se vuoi che lo scope sia 'solo' limitato ad un file o visibile da tutto il programma etc. etc. Cmq complimenti hai appena scoperto come implementare una funzione membro in una struttura. Chiunque abbia nozioni di C++ anche non strepitose lo avrà fatto almeno una volta..

bye

non ho capito se i complimenti erano sarcastici...
ma li accetto cmq (ehehehe) non fa mai male un po' di incoraggimento
Allora, mi servirebbe che lo scope sia limitato al solo file .h...ma non per ogni cosa,
nel senso che l'obiettivo finale sarebbe quello di usare timer e i suoi "metodi" ovunque,
ma mi piacerebbe impedire (all'esterno di timer.h) l'uso "diretto" delle funzioni puntate da dentro
la struttura timer.
Per capirci, supponendo che abbia fatto questo:

timer.metodo = funzione

vorrei poter usare questo all'esterno del file .h:

timer.metodo(parametri)

ma non questo

funzione(parametri)

Non ricordo se una cosa del genere sia possibile...sono un po' arrugginito....
All'inizio pensavo di usare le dichiarazioni extern solo
per alcune funzioni e per la struttura timer...ma non credo centrino nulla....

Mi potresti illuminare su questi aspetti?
grazie.

ciauz

[TheGreatWorld]

Il tuo modo di ragionare sembra essere fatto a posta per il C++ (funzioni membro prima, protezione dei dati poi, etc. etc.) ma purtroppo usi il C e col C non è possibile proteggere i tuoi dati in modo cosi efficace.

bye