mii-community/UsenetArchiveIT-conversations huggingface dataset:
Newsgroup: it.comp.lang.c
Titolo: Inclusione di file sorgente

#define  _FUNZGLOBALI_C
Premetto che ho già provato a scomporre il progetto in questo
modo,introducendo il solo file c per ogni modulo,e il compilatore non si
lamenta,però nella mia (scarna) esperienza in C sono stato abituato a
vedere la suddetta direttiva appplicata a file header,ed inoltre mi puzza
il vedere l'#include di un file c,ma potrebbe anche darsi che mi sto
facendo dei problemi per niente :)
Avete qualche consiglio?


Il metodo più consigliabile è IMO quello di suddividere il progetto in 
vari moduli compilabili (file di tipo .c) ed usare un solo header file 
per il progetto.  Se nel progetto sono comprese più aree funzionale 
può essere più conveniente che gli header files siano uno per area 
funzionale.
Non è vietato che un file .c sia incluso da altri file, ma certi 
compilatori non generano informazioni simboliche per i file inclusi. 
Tale comportamento nel caso che si voglia usare sistemi di debugging è 
penalizzante.
Le direttive:
#ifndef _STDIO_H
#define _STDIO_H
.....
#endif
è generalmente usata per gli header files globali che in progetti 
molto complessi potrebbero essere inclusi più volte e serve 
esclusivamente perché il file venga processato solo la prima volta che 
è incluso.  Nei files di codice (.c) non ha alcun senso.
Come esempio puoi guardare alcuni programmi che ho 
sviluppato/modificato seguendo le modalità che ho descritto, al 
seguente link.
http://giovanni.homelinux.net/development/index.html
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >
Newsgroup: it.comp.lang.c
Titolo: Tipo intero ad un byte

Ciao a tutti,
	domanda semplice (credo) devo eseguire:
Occ[*(&A[i]+k)]++;
dove:
char *A
sui primi n byte devo effettuare un'ordianemento
Al di là del casino con i puntatori, io vorrei riuscire a prendere il 
valore contenuto nel byte che sto puntando, usarlo come indice in un 
array e incrementarlo il valore dell'array.
Inoltre vorrei anche poter stampare il valore numerico di quel byte, 
come si fa???
grassieeeee sepro di essere stato chiaro
P.S.
	Per chi ha familiarità con la cosa devo implementare il RadixSort (per 
ora mi limito con codifica intera Little Endian poi vediamo ^_^)
-- 
Strahd
per stupire mezz'ora basta un libro di storia,
io cercai di imparare la Treccani a memoria... [F.d.A.]

 ora mi limito con codifica intera Little Endian poi vediamo ^_^)
Non e' l'algoritmo per ordinare in tempo lineare un array, a condizione che
l'array contenga elementi in una particolare relazione tra di loro?
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 l'array contenga elementi in una particolare relazione tra di loro?
dunque è un teta di n sì... però lo spreco di spazio è più del doppio di 
un algoritmo di tipo classico che ha complessità logaritmica
Nella implementazione che ho scelto io la sua complessità è 4(2N+256)
però si perde nel dover spostare grosse strutture, in quel caso gli 
algoritmi che si basano sui puntatori come il merge sort son molto più 
efficaci
(mettici il tempo per allocare e deallocare memoria!!!)
Come si vede N deve essere molto grosso per rendere sensibile il 
miglioramento
Se volete vi posto il codice (ehm che per ora non funzia ancora bene)


acc ma come si fa a stampare la codifica esadecimale di un intero???


 acc ma come si fa a stampare la codifica esadecimale di un intero???
Te l'ho indicato nel post sopra:
printf("%x", variabile);


 printf("%x", variabile);
infatti avevo capito che servisse per stampare il codice ascii del 
carattere... me ne sono accorto provando ^_^

Newsgroup: it.comp.lang.c
Titolo: [linux - semiOT] personalizzare il configure

Salve a tutti,
   ultimamente ho dovuto sviluppare un tool in C per la ricerca di 
indirizzi da un torrent. Questo tool lo dovrei distribuire ad altri 
colleghi che lo utilizzeranno su altre macchine e quindi ho deciso di 
fare creare la struttura della directory a KDevelop. Considerato che 
fino ad ora mi sono cimentato in progetti che non richiedevano di essere 
distribuiti (di conseguenza il makefile me lo facevo a mano) e non ho 
mai avuto la necessita di creare il file configure.
Nel mio piccolo progetto utilizzo le librerie openssl per l'algoritmo 
sha1 e mi piacerebbe che il configure controllasse se nel computer sono 
presenti o meno le librerie. Qualcuno sa come posso fare per aggiungere 
questa condizione? (se è possibile direttamente da KDevelop)
Grazie a tutti
GeeRay

GeeRay wrote:
Non sei [semiOT], sei completamente OT, perche' questo gruppo
tratta solo le problematiche inerenti la parte standard del linguaggio C.
Rivolgiti al gruppo it.comp.linux.development dove
sapranno sicuramente consigliarti.
ciao,
g.

 g.
Ciao
GeeRay

Newsgroup: it.comp.lang.c
Titolo: perché non si ferma?

int main()
{
      int i,j,n,m;
      int a[n][m];
      printf("inserire dim di A\n");
      scanf("%d%d",&n,&m);
      for(i=0;i<n;++i)
      for(j=0;j<m;++j)
                {
                  scanf("%d",&a[i][j]);
                }
        for(i=0;i=n;++i)
            for(j=0;j<m;++j)
            {
              printf("%d",a[i][j]);
            }
      system("PAUSE");
      return 0;
}
Il prog compilato non da errori, ma quando lo eseguo non mi permette di
inserire i dati di input. Perché?

 ha scritto nel messaggio
news:oBMu6.12031$dJ6.7...@news.infostrada.it...


 int [n][m]; 
Byez
Paolo :)

        for(i=0;i=n;++i)
        i==n cosě assegni n ad i


Se vuoi fare le cose per bene segui i consigli di Mox.
Comunque puoi anche allocare staticamente la matrice: se programmi in
C da poco e' una soluzione piu' semplice, anche se ha lo svantaggio di
allocare sempre una matrice di dimensioni fisse solitamente piu'
grande del normale (con conseguente spreco di memoria).
/* Dimensioni massime della matrice */
#define MAX_RIGHE 20
#define MAX_COLONNE 20
int main()
{   int i,j,n,m;
    /* Allocazione statica di una matrice MAX_RIGHE x MAX_COLONNE */
    int a[MAX_RIGHE][MAX_COLONNE];
    printf("inserire dim di A\n");
    scanf("%d%d",&n,&m);
    /*
     * Qui e' opportuno controllare almeno che
     * (n <= MAX_RIGHE) e (m <=MAX_COLONNE)
     *
     */
    for(i=0;i<n;++i)
        for(j=0;j<m;++j)
        {
            scanf("%d",&a[i][j]);
        }
    for(i=0;i<n;++i)
    /*
     * ATTENTO!!! Qui l'intestazione del tuo for era:
     *  for (i=0;i=n;++i)
     *           ^^^
     * cioe' effettui l'assegnamento i=n che restituisce sempre
     * (se n!=0) un valore !=0, causando la ripetizione infinita
     * del for
     *
     */
        for(j=0;j<m;++j)
        {
            printf("%d",a[i][j]);
        }
    system("PAUSE");
    return 0;
}
Ciao e spero di esserti stato d'aiuto :)
--
Leo-Panda
email: 
leo-...@libero.it
ICQ#: 105550412
Newsgroup: it.comp.lang.c
Titolo: Array di funzioni

Ciao a tutti.
Avrei bisogno di alcune indicazioni relativamente ai puntatori a funzioni.
 
Avrei la necessita' di individuare funzioni differenti tramite degli indici.
 
Provo ad usare un esempio senza funzioni per spiegarmi.
 
Se ho un vettore a due indici, 
p.es
. a[i][j] e voglio moltiplicare la prima riga
per una costante non devo fare altro che 
 
                 for j
                  a[0][j] *= c;
 
Supponiamo adesso che cambiando indice io non indirizzi una costante ma tante funzioni differenti che hanno in input _sempre_ le stesse grandezze, sia per numero che per tipo: come dovrei procedere?
 
Ho provato a cercare in google ma non sono riuscito a trovare una sequenza di keyords efficaci.
 
Ho trovato esempi di puntatori a funzione ma non sono riuscito a capire, per esempio come fare una matrice nxm di funzioni.
 
Grazie per i suggerimenti che potrete darmi


Cerco d'indovinare perché non ho capito benissimo...
 
Se vuoi un'array n*m di puntatori a funzione basta che fai qualcosa del tipo:
 
typedef void(*f_t)(void);
f_t arr[n][m];
 
Se vuoi invece fare quello che nei linguaggi funzionali si chiamano "funzioni
parzialmente applicate" (ovvero chiami una funzione che accetta due parametri
con un parametro solo e ti porti dietro l'affare) non si può fare a meno di
qualche trucchetto (ovvero porti dietro i parametri insieme al puntatore a
funzione in qualche modo)
 
Ciao!


Potresti utilizzare un array di puntatori ad array di puntatori a 
funzione. Se ad esempio le funzioni da indicizzare fossero del tipo:
 
int foo_0(long);
 
allora la dichiarazione sarebbe:
 
int(*(*myParray[])[])(long);
 
inizializzabie anche nel seguente modo:
 
int(*(*myParray[])[])(long) = {
				{ foo_1, foo_2},
				{ foo_3, foo_4}
                               };
 
se, ad esempio, vuoi utilizzare foo_3:
 
long val = 0;
int ret;
ret = myParray[1][0](val);
 
Ciao.


Ammetto di esser stato impreciso e pressapochista.
Per scusarmi accludo un esempio funzionante:
 
/**/
#include <stdio.h>
#include <stdlib.h>
 
int f1(int);
int f2(int);
int f3(int);
int f4(int);
int f5(int);
int f6(int);
int f7(int);
 
int (*(*mf[])[])(int) = {(int (*[])(int)){f1, f2, f5, f6, 0},
                          (int (*[])(int)){f3, f4, 0},
                          (int (*[])(int)){f7, f6, f5, f4, f3, f2, f1, 0}
                         };
 
int main(int argc, char *argv[])
{
   int i, j;
 
   for(i = 0; i < sizeof mf / sizeof mf[0]; i++)
    for(j = 0; (*mf[i])[j] != 0; j ++)
      printf("La funzione [%d][%d] ritorna %d\n", i, j, (*mf[i])[j](10));
 
   system("PAUSE");
   return 0;
}
 
int f1(int a){return a + 1;}
int f2(int a){return a + 2;}
int f3(int a){return a + 3;}
int f4(int a){return a + 4;}
int f5(int a){return a + 5;}
int f6(int a){return a + 6;}
int f7(int a){return a + 7;}
/**/
Newsgroup: it.comp.lang.c
Titolo: Pointer e Handler

Ciao!
Qualcuno di voi potrebbe spiegarmi in modo esauriente la differenza tra
puntatori
ed handler? E' giusto dire che gli handler sono particolari tipi di
puntatori?
Grazie!
Paolo Pancini
p.pa...@agonet.it
--
Posted from root@[212.69.128.10] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Paolo wrote:

Per quanto ne so' i due nomi sono sinonimi. se non sbaglio in windows
il tipo HANDLER e' un typedef di void*.
Ciao Angelo.

Newsgroup: it.comp.lang.c
Titolo: urgente!!!!





come faccio a costruire in c un programma che mi da 
in output un numero binario,naturalmente all'inizio gliedodo 
numerico!!!


potreste darmene la soluzione 
gentilmente????????


ciao by Angelo




The majority of the stupid is invincible and guaranteed for all time.
The terror of their tyranny, however, is alleviated by their lack of
consistency.
                -- Albert Einstein

darmene la soluzione gentilmente???????? ciao by Angelo
i compiti fatteli da solo...
-- 
January 15, 2028 - Intel announces their new 400THz processor, which 
performs 100 billion floating-point operations in the millisecond before 
it consumes itself in a nuclear explosion. This is a step up from AMD's 
recent processor which simply fries any nearby user with bolts of plasma 
energy. Hobbyists are already looking into ways to overclock the chip.

 i compiti fatteli da solo...
caz** .... vuoi dire che gli ho fatto il compito ????


caz** .... vuoi dire che gli ho fatto il compito ????
quando urlano, dicono che è urgente e sono sgrammaticati, cercano SEMPRE 
qualcuno che gli faccia i compiti...


 qualcuno che gli faccia i compiti...
buono a sapersi per la prossima volta ;-)))
ciao

Newsgroup: it.comp.lang.c
Titolo: Errore...

Qualcuno sa dirmi perchč il compilatore mi da questo errore?
/tmp/ccQUOTT0.o(.text+0x3e): In function `main':
: undefined reference to `pow'
collect2: ld returned 1 exit status
L'istruzione č questa:
main()
{
int a[3][3];
int k = 0;
int c, f;
int i = 0;
int signed one = -1;
  while(i < 3)
  {
     f = pow(one, 2 + i);
     k = k + (a[0][i] * f);
     c = det(i);
     k = k * c;
  }
printf("\n\nDet = %d\n\n", k);
}
Grazie a chi vorrą aiutare sto cerebroleso(si fa per dire ;-) )!

Shien ha scritto:

evidentemente non hai detto di usare la libreria matematica
gcc nomefile.c -o nomeEseguibile -lm

 $  cc file.c -lm -o programma
e magari in cima al file devi mettere anche
un bel
#include<math.h>
visto che la funzione double pow(double x, double e)
viene definita in math.h
(fra parentesi: l'attributo "signed" e' inutile...)
ciao,
g.

Giovanni Resta wrote:

Il link alla libreria l'avevo gia messo...
È questo il problema!

 Giovanni
Ho seguito la tua istruzione e me l'ha compilato...
Ma mi chiedo se ogni volta che includo <math.h> o qualche altra libreria
devo linkarla dalla shell!
Non lo fa in automatico?

 Non lo fa in automatico?
In generale, no. Perche', ad esempio, tu potresti voler linkare librerie 
diverse che forniscono le stesse funzionalita'.
Comunque per automatizzare le cose puoi crearti un Makefile
ed eseguire il comando make.
ciao,
g.

 Non lo fa in automatico?
No.  Solo la libc viene linkata automaticamente.


Newsgroup: it.comp.lang.c
Titolo: Files di dati

Ciao a tutti
ho un problema con dei files creati da una procedura fatta in Pascal 7.0.
I files in questione contengono dei records che devo importare in Access 97.
Basterebbe poco se non che i dati contenuti in alcuni records sono in un
formato non leggibile (sono stati modificati dal programma di origine) e
quindi non riesco ad importarli neppure in formato txt.
Ho il compilatore ma non ho i sorgenti.
Purtroppo non conosco il tipo di struttura dei files.
Non conoscendo la struttura è ugualmente possibile fare un programma che
trasformi i files in formato txt?
E’ se si può potrebbe qualcuno suggerirmi come?
Io non conosco il Pascal e non sono un programmatore.
Grazie per l’aiuto Pietro
p...@telware.it

Io non conosco il Pascal e non sono un programmatore.
Il Pascal in realta` non c'entra, e la programmazione solo fino a
un certo punto, come _strumento_ per il compito che a te
interessa.  Quello che c'entra veramente: la crittografia, cioe`
la scienza di scoprire e rovesciare codifiche sconosciute sui
dati; l'enigmistica, dove uno spesso si trova davanti a dati
"offuscati", ma non totalmente, e deve riportarli "in chiaro";
l'archeologia, particolarmente la linguistica-archeologica, che
in passato ha spesso affrontato (e non sempre risolto, oppure,
risolto solo parzialmente) problemi analoghi, dai geroglifici al
Lineare B, dalla ricostruzione parziale a posteriori del Maya,
a quella dell'Etrusco.
Alex
Newsgroup: it.comp.lang.c
Titolo: Sintassi del make

Ciao amici, dove posso trovare su Internet risorse che mi speghino la
sintassi del make del C. Io la conosco a grandi linee (ma proprio
grandi eh !!!) però ho notato dai programmi che scarico (in
particolare quelli dello GNU) che è praticamente quasi un linguaggio
di programmazione, simile alla shell di unix. Potete aiutarmi?
Ciao
Gabriele

Il problema e' che, effettivamente, il make e' un programma che non ha
formalmente a che fare con il compilatore C. 
Di fatto, lo si usa per compilare velocemente un progetto complicato per i
motivi che avrai gia' scoperto (infatti si riutilizzano moduli oggetto per
poi linkare il tutto `alla fine etc. etc.).
Se hai occasione (e tempo!!!), puoi chiedere la pagina del man di make...
in tal caso, in bocca al lupo.
Rony Cesana
ces...@cli.di.unipi.it
http://www.cli.di.unipi.it/~cesana
---___---___---___---
due persone su una 
sono schizofreniche;
non ch'io sia una di
quelle, ma io si'.



Make e' un programma di gestione delle fasi compilazione/link che non e'
legato a un particolare linguaggio di programmazione, dunque l'espressione
"make del C" non significa nulla. Le varie incarnazioni di UNIX supportano
certe versioni di Make le cui caratteristiche precise stanno nei manuali di
programmzione della specifica versione UNIX. Per una spiegazione generale un
qualsiasi testo di UNIX da' una introduzione. Anche altri OS supportano
programmi simili: DOS, OS9. Nel contesto di GNU e' stato sviluppato una
versione di make (chiamata spesso gmake) che e' particolarmente ricca. Gmake
ha un manuale che puo' essere scaricato dai siti GNU, scaricando il codice di
make. Spero di essert stato di aiuto. Ciao Paolo
-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/
       Search, Read, Discuss, or Start Your Own    

Make e' un programma di gestione delle fasi compilazione/link 
e non solo, anche se l'uso piu' tipico e' quello. In parole grezze,
il make e' una sorta di linguaggio che permette di specificare come
raggiungere un certo obiettivo partendo da una serie di componenti
e sapendo che passaggi bisogna fare.
Nel caso piu' comune dei programmi, l'obiettivo e' il programma
eseguibile, i componenti sono i sorgenti, e i passaggi sono
l'invocazione del compilatore, linker etc. 
Il livello di genericita' di make e' talmente grande da poter
essere sfruttato in una infinita' di altri modi. L'unico problema
e' che in genere i makefile per eseguire operazioni complesse
risultano spesso illeggibili e convoluti.

Newsgroup: it.comp.lang.c
Titolo: graphics??

Scusate per la domanda che deve avere una risposta molto semplice.
Sapete che direttiva esisyte al posto di <graphics.n> in Visual C, visto che
mi dice che non esiste.
Grazie

 visto che mi dice che non esiste.
Non e` un header standard. Il gruppo piu` adatto per il tuo problema e`:
it.comp.programmare.win32
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Quando un uomo porta dei fiori a sua moglie senza motivo, 
un motivo c'e`.
Newsgroup: it.comp.lang.c
Titolo: Stack

Salve a tutti i frequentatori del newsgroup.
Vorrei chiedervi un aiuto.
Sono uno studente di informatica ed oggi in classe abbiamo fatto
l'implementazione dello stack in c. Siccome il programma non funge, ho
provato a cambiarlo ma alla fine mi sono imbattuto nei seguenti errori
(il compilatore è il gcc):
stack.c: In function `push':
stack.c:54: incompatible types in assignment
stack.c:55: invalid type argument of `->'
stack.c:56: invalid type argument of `->'
In sintesi il programma dovrebbe leggere i caratteri da tastiera e
stamparli in ordine inverso MA utilizzando esclusivamente delle
funzioni che implementino lo stack in c.
Il codice del programma è scritto qui sotto.
Ringrazio anticipatamente chi mi risponderà.
#include <stdio.h>
struct node
{
 char info;
 struct node *next;
};
struct node *stack;
int isempty(struct node *p);
struct node *createstack(void);
struct node *push(struct node *p, char c);
char pop(struct node *p);
int main(void)
{
struct node *p;
int c;
p=createstack();
while((c=getchar())!=EOF)
 push(p,c);
while(!isempty(p))
{
 c=pop(p);
 putchar(c);
}
return(0);
}
int isempty(struct node *p)
{
if (p==NULL)
 return(1);
else
 return(0);
}
struct node *createstack(void)
{
 return(NULL);
}
struct node *push(struct node *p, char c)
{
struct node b;
b=(struct node *)malloc(sizeof(struct node));
b->info=c;
b->next=(*p);
*p=b;
return(p);
}
char pop(struct node *p)
{
char val;
struct node b;
val=p->info;
b=*p;
p=p->next;
free(b);
return(val);
}

 b->next=(*p);
Suppongo sia questa la riga che ti da errore vero? In pratica tu tenti di
assegnare ad uno struct node* uno struct node. Togli (*) e lascia p.
-- 
Andrea Bergia - studente          Linux Registred User #281550
Per favore non mandatemi allegati in Word o PowerPoint.
Si veda 
http://www.fsf.org/philosophy/no-word-attachments.html

 scrisse:

Grazie ora con il tuo consiglio compila ma non fa quello che deve
fare. Il codice completo è qui sotto:
#include <stdio.h>
struct node
{
	char info;
	struct node *next;
};
struct node *stack;
int isempty(struct node *p);
struct node *createstack(void);
struct node *push(struct node *p, char c);
char pop(struct node *p);
int main(void)
{
struct node *p;
int c;
p=createstack();
while((c=getchar())!=EOF)
	push(p,c);
while(!isempty(p))
{
	c=pop(p);
	putchar(c);
}
return(0);
}
int isempty(struct node *p)
{
if (p==NULL)
	return(1);
else
	return(0);
}
struct node *createstack(void)
{
	return(NULL);
}
struct node *push(struct node *p, char c)
{
struct node *b;
b=(struct node *)malloc(sizeof(struct node *));
b->info=c;
b->next=p;
p=b;
return(p);
}
char pop(struct node *p)
{
char val;
struct node *b;
val=p->info;
b=p;
p=p->next;
free(b);
return(val);
}

 }
La modifica p=p->next; rimane locale,
in quanto p é un parametro passato per 
copia.
Mancano inoltre i controlli che p non sia pari 
a NULL.
Devi fare in modo che l'indirizzo della cima dello
stack venga modificato. 
-- 
Remove _NOTRASH to answer me!

 scrisse:
[snip tutto!]
Grazie ora provo.
Ciao.
Newsgroup: it.comp.lang.c
Titolo: prime armi

sto scrivendo un codice C sotot Linux.
Ora se uso un file .h e lo devo includere
faccio #include "miofile.h"
ma il significato delle virgolette qual'e'? Cioe' il
compilatore cerca il file .h solo nella directory corrente,
o in un percorso stabilto in qualche file del compilatore, e se si quale 
file?
Grazie,
Dario


Allora, se non sbaglio, #include "miofile.h" include il file miofile.h
contenuto nella directory corrente (dove si trova il sorgente da compilare).
#include <miofile.h> va a ricercare nella directory di default degli
include, che sotto linux potrebbe essre /usr/include
Ciao

 default degli include, che sotto linux potrebbe essre /usr/include
sě, li cerca lě o in altre directory che gli vengono passate col flag -I

DZ wrote:

Se usi
    #include <file.h>
la ricerca viene effettuata nelle directory standard (che dipendono dal 
sistema... sotto linux probabilmente ci sono almeno 2 posti che contengono 
il primo informazioni standard, altre con informazioni che dipendono 
dall'architettura) E in tutte le directory specificate come parametri al 
GCC
Se invece usi
    #include "file.h"
la ricerca viene effettuata nella directory corrente o in tutte quelle 
specificate come parametro.
Rispetto alle altre risposte, ti puntualizzo appunto che entrambi i path di 
ricerca sono customizzabili (o meglio, estensibili) passando opportuni 
parametri, non solo il primo.
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."
Newsgroup: it.comp.lang.c
Titolo: [REQ]:Compilatore GNU C/C++ per DOS

Sapreste indicarmi, per favore, da dove poter scaricare il suddetto
compilatore?
Thanks

 compilatore?
Prendi il DJGPP all'indirizzo 
http://www.delorie.com/djgpp/
.
EMG

Newsgroup: it.comp.lang.c
Titolo: Comunicazione seriale in C (emulare il comportamento di hyperterminal)

Sto utilizzando un modulo gprs collegato al pc tramite porta seriale,
per inviare dei dati attraverso la rete GPRS. Per gestirlo gli invio i
comandi AT "a mano", utilizzando hyperterminal.
Ora, però, devo scrivere un programma in C che, caricato su un
microcontrollore, permetta di gestire in automatico l'esecuzione delle
operazioni (es: invio di un sms, trasferimento di un file via ftp), a
seconda di determinate condizioni.
Scrivo a questo ng perchè la parte critica, per me, è proprio gestire
la comunicazione attraverso la seriale utilizzando il C. Ho cercato con
google e con google gruppi, ho letto delle API ReadFile, WriteFile,
GetCommState (e altre) ma, non conoscendo il C ad un livello avanzato,
non sono riuscito a capire troppo bene come dovrei usarle (pur avendo
letto le descrizioni delle api nel file win32.hlp).
Peraltro ho trovato dei programmi
(
http://www.hendrik-sattler.de/scmxx/
), in cui la comunicazione seriale
(nel caso del link con un cellulare), è gestita senza l'uso delle api,
ma con delle funzioni scritte ad hoc. Anche qui non ho capito molto,
perchè la gestione della comunicazione è solo una parte di tutte le
funzionalità (per me inutili) del programma.
Per questo ho deciso di chiedere aiuto domandandovi delucidazioni su un
esempio preciso:
Come posso fare a inviare al mio modem gprs, collegato alla pota COMn,
il comando "ATI", e leggere la sua risposta (che nel caso di ATI sarà
una stringa di testo che indica la marca del modulo), facendo in
pratica quello che adesso faccio "a mano" con hyperterminal?
Mi rendo conto di essere probabilmente OT, ma non sapevo dove
altrimenti postare questa richiesta.
grazie
athos

altrimenti postare questa richiesta.
Ti dovresti spostare in it.comp.programmare.win32 essendo la tua
applicazione per Windows.
Ti consiglio di iscriverti gratuaitamente su
http://www.codeproject.com/
 e cercare "serial port", gli esempi
di codice C e C++ saranno abbondanti.
Un altro buon link di bookmark e' questo:
http://www.lvr.com/serport.htm
Newsgroup: it.comp.lang.c
Titolo: Stack

Ciao a tutto NG, volevo chiedervi se è corretto usare elementi dello stack
in questo modo
typedef struct MyPersonal {
 char nome[N_NOME];
 char cognome[N_COGNOME];
    ...
 } MyPersonal;
typedef MyPersonal *Element;
typedef struct _Stk {
   Element      storage;
   Element      bottom;
   Element      ptr;
   int          size;
   int          entrysz;
   int          count;
} Stk;
typedef Stk *PStk;
PStk shnd;
MyPersonal *data;
main(void)
{
         ...
        StkPush(shnd, data);
        ...
}
grazie a tutti.

 in questo modo
Non vedo nulla di sbagliato, ma avendo tu omesso la funzione di
inserimento non posso dirti niente di preciso.
In linea di massima si puo` semplificare la gestione in questo modo:
MyPersonal stack[MAX_SIZE];
int sp = -1;
int push(MyPersonal data) {
	if (sp + 1 == MAX_SIZE) {
		/* Stack pieno */
		return -1;
	}
	stack[++sp] = data;
	return 0;
}
MyPersonal pop(void) {
	if (sp == -1) {
		/* Stack vuoto */
	}
	return stack[sp--];
}
sp e` lo stack pointer, ovvero indica l'elemento corrente. 
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Carpe diem, quam minimum credula postero. (Q. Horatius Flaccus)

Newsgroup: it.comp.lang.c
Titolo: non pikkiatemi dopo questa !!!

salve a tutti
io uso come ambiente di sviluppo Visual C++ per fare applicazioni console
(me lo hanno passato a squola cosě...)
2 cose: conoscete tutti la famosa clr( ) che in TurboC andava a meraviglia
no? Beh, in VC++ non esiste con quel nome. Ho provato con: cls, clrscr,
clearscreen ma nulla!
chi di voi sa dirmi il nuovo nome di questa funzione?
la seconda č: per usare la funzione deelay(time) che libreria devo
includere?
muchas muchas graciazzz
ciao a tutti

 includere?
Non esiste nello standard, devi utilizzare funzioni specifiche per la
tua piattaforma:
it.comp.programmare.win32
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Io mi ricordo sempre il compleanno della mia ragazza:
cade il giorno dopo di quando lei me lo ricorda

 Kronos
stra


e se usassi direttamente la fuzione system("cls")? può andare?
va solo in dos/windows
--
Lawrence Oluyede
rhy...@myself.com

 (me lo hanno passato a squola cosě...)
Veramente dovrebbero picchiarti violentemente per aver scritto
sQuola :-)
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 sQuola :-)
ma l'ho fatto appostaaa! non si vedee?  ;-----)


 e se usassi direttamente la fuzione system("cls")? puo` andare?
Si`, ma come l'ho fatta io e` piu` cool :))
Diciamo che e` stato fatto nella speranza che qualcuno legga gli archivi
di google ed eviti di ripere la domanda...
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"Su cio` di cui non si puo` parlare e` bene tacere".
 Ludwig Wittgenstein

 di google ed eviti di ripere la domanda...
Vana speranza. ;-)
Bye,
 Emmanuele.
-- 
Emmanuele Bassi (Zefram)           [ 
http://www.radiance.d2g.com/~zefram
 ]
GnuPG Key fingerprint = 4DD0 C90D 4070 F071 5738  08BD 8ECC DB8F A432 0FF4
Newsgroup: it.comp.lang.c
Titolo: *ptr

e' lecito scrivere e avere garanzie di funzionamento su tutti i compilatori :
*p1 = *p2
per copiare un blocco di memoria, senza usare memcpy ?
L'ho visto su VMS ma non sono sicuro che sia ANSI o perlomeno "widely supported".


Scusa, ma come sono definiti questi p1 e p2 ?
ciao,
v.

 supported".
L'espressione ha un significato preciso in C, ma non sostituisce memcpy.
Max

 wrote in message news:E16Vf.48883$A83.1...@twister1.libero.it...


 una forma standard e alternativa a memcpy()
Come ho scritto nella mia risposta, si tratta di un assegnamento 
perfettamente valido anche nel caso in cui l'espressione a sinistra denoti 
un'istanza di una struct. Perciň non sei tenuto ad usare memcpy per copiare 
il contenuto di una singola istanza in un'altra.
Max
Newsgroup: it.comp.lang.c
Titolo: Quesito su strutture

Il mio problema è il seguente:
in base ad un valore scritto in una locazione di memoria (eeprom)
devo poter definire globalmente una struttura con un numero di campi
diversa.
Mi spiego meglio
#define MODO  (* (unsigned char *) (0xfe051)) // locazione di memoria
//PRIMA DEFINIZIONE
typedef struct StrutturaUtente {
 char Cognome[20];
 char Nome[20];
}UTENTE;
//SECONDA DEFINIZIONE
typedef struct StrutturaUtenteLungo {
 char Cognome[20];
 char Nome[20];
 char Indirizzo[20];
}UTENTELUNGO;
// COSA DEVO METTERE QUI
// PER DEFINIRE UNA O L'ALTRA
// IN ESECUZIONE ??
// O ESISTE UN'ALTRA POSSIBILITA' ?
//SE MODO = 1
UTENTELUNGO Utente;
//se modo=0
UTENTE Utente;
main
{
  strcpy(Utente.Cognome ,"Rossi");
  strcpy(Utente.Nome,"Mario");
  if (MODO == 1) strcpy(Utente.Indirizzo,"Via delle primule");
}
Grazie a tutti.
Elso Gasparotto
els...@inrete.it

 Il mio problema č il seguente:

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/
       Search, Read, Discuss, or Start Your Own    

Elso Gasparotto (
els...@inrete.it
) wrote:
: Il mio problema č il seguente:
: in base ad un valore scritto in una locazione di memoria (eeprom)
: devo poter definire globalmente una struttura con un numero di campi
: diversa.
[ snip ]
Potresti usare una union:
[ riprendendo il tuo esempio ]
.............................
typedef union Utente {
        UTENTE U;
        UTENTELUNGO UL;
} UT;
.............................
UT mioutente;
.............................
main()
{
.............................
        if( MODO ) {
                strcpy(mioutente.UL.Cognome ,"Rossi");
                strcpy(mioutente.UL.Nome,"Mario");
                strcpy(mioutente.UL.Indirizzo,"Via delle primule");
        } else {
                strcpy(mioutente.U.Cognome ,"Rossi");
                strcpy(mioutente.U.Nome,"Mario");
        }
.............................
}
Fai attenzione pero' che la union e' sempre abbastanza grande da contenere
il piu' ampio dei suoi elementi, per cui in questo caso e' sempre almeno 60 
byte.
A proposito, visto come sono definiti U e UL, in questo caso puoi scrivere
piu' semplicemente:
.............................
                strcpy(mioutente.U.Cognome ,"Rossi");
                strcpy(mioutente.U.Nome,"Mario");
                if( MODO )
                        strcpy(mioutente.UL.Indirizzo,"Via delle primule");
.............................
Ciao ciao
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

Perchč il mio primo obbiettivo č quello di risparmiare memoria
Grazie comunque.
Elso Gasparotto.
els...@inrete.it

Newsgroup: it.comp.lang.c
Titolo: Programmare in C ( K&R)

Ciao
al seguente indirizzo cми un economico cult
di Kernighan e Ritche sul linguaggio c.
date un'occhiata!
http://cgi.ebay.it/ws/eBayISAPI.dll?ViewItem&item=6933909063&ssPageName=ADME:B:BN:IT:1


http://cgi.ebay.it/ws/eBayISAPI.dll?ViewItem&item=6933909063&ssPageName=ADME:B:BN:IT:1
Mah...
Tommy


Questo è in inglese....
In italiano l'ho comprato adesso on line.
Il mio manuale "linguaggio C - guida alla programmazione" di Bellini e 
Guidi, da troppe cose per scontate, ma io sono un principiante 
(smanettavo un po con il php) e ora sui puntatori e la ricorsione 
(l'esempio della torre di anoy è per me arabo....) non seguo più.
Spero questo prossimo libro di testo mi sia piu chiaro.

= 5 the second test
is not performed.
expr1 || expr2
Evaluate expr1. If the result is one, stop
evaluating the whole expression and set the
result of the expression to 1. If not, continue
evaluating expr2. The result of the expression
is the logical OR of the results of each
expression.
a == 5 ||a == 3
This will be 1
if either a is
5 or 3
expr ?
val1:val2
If expr evaluates to non-zero (true), return val1,
otherwise return val2.
See Conditional_operator.
a= b ? 2 : 3
a will be 2 if
b is true, 3
otherwise
expr *= expr1
Multiply expr by expr1 and store the result in
expr
a *= 7
expr /= expr1
Divide expr by expr1 and store the result in
expr
a /= 78
expr %= expr1
Calculate the remainder of expr % expr1 and
store the result in expr
a %= 6
expr += expr1
Add expr1 with expr and store the result in expr
a += 6
expr -= expr1
Subtract expr1 from expr and store the result in
expr
a -= 76
expr <<= expr1
Shift left expr by expr1 bits and store the result
in expr
a <<= 6
expr >>= expr1
Shift right expr by expr1 bits and store the
result in expr
a >>= 7
expr &= expr1
Bitwise and expr with expr1 and store the
result in expr
a &= 32
expr ^= expr1
Bitwise xor expr with expr1 and store the result
in expr
a ^= 64
expr |= expr1
Bitwise or expr with expr1 and store the result
in expr
a |= 128
expr , expr1
Evaluate expr, then expr1 and return the result
of evaluating the last expression, in this case
expr1
a=7,b=8
The result of
this is 8

L'ho trovato in Italiano sul sito eBay...
-- 
"Windows cerca di fare Unix e ci riesce male, Red Hat cerca di fare Windows
e ci riesce benissimo" (Jimmy Olgeni)
Newsgroup: it.comp.lang.c
Titolo: [OT] esempi prog. dinamica

Salve gente,
volevo sapere se quacuno di voi sa indicarmi qualche link o qualche problema
da risolvere tramite la tecnica della programmazione dinamica.
Questo appello è rivolto soprattutto ai colleghi dell'uni di Napoli che
stanno seguendo il modulo B dell'esame di algoritmi e Strutture Dati :)
Segnalate gente segnalate ;-)

 ha scritto nel messaggio
news:De0xc.294943$hc5.12...@news3.tin.it...

Sei con Bene o Catanzariti?
Paura !!!!

 Paura !!!!
 concordo!!!

 Con Bene
e tu?
Hai qualche esercizio che non sia quello sul sito?
Ciauz

 ha scritto nel messaggio
news:Ufixc.298514$hc5.13...@news3.tin.it...


 Ciao
byez e in bocca al lupo

 in privato...basta togliere il NOSPAM
Bene, adesso spero la chiuderemo con la posta privata, e pure OT, vero?
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://www.cs.unibo.it/~mbellett
Linux registered user 299762 @ Linux registered machine 213003

 Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
Sorry Mattia ma il post non era iniziato come una cosa privata, poi è
degenerata ... non succederà più :-)
Pep

Newsgroup: it.comp.lang.c
Titolo: Misurare il tempo di una funzione

Ho il seguente problema: dopo aver scritto una funzione, dovrei misurare 
quanto tempo ci mette ad eseguirla. per ora utilizzo questo metodo
	int iTStart, iTempoTotale;
	double Secondi;
	iTStart=clock();
	while(int i=0; i<1000; i++){
		miafunzione();
	}
 
	iTempoTotale=clock()-iTStart;
	Secondi=(double)iTempoTotale/CLOCKS_PER_SEC
 
Qualcuno ha in mente soluzioni più precise?

Qualcuno ha in mente soluzioni più precise?
GetTickCount(), il timer interno di Windows
ha una risoluzione di un kHz (1/1000 di secondo)
su altri sistemi non so
-- 
-----BEGIN GEEK CODE BLOCK-----
Version 3.1 (with proprietary extensions)
Comments: waiting for version 4.0 ;)
GE/M/S/O d- s:--- !a C++++()>$ UL P+>+++ L+>++ e w++>$ N++ o-- K- W++ O? 
M? V? PS++ PE- Y+>+++ PGP++ t+ 5? X++(+) R tv--  b++>++++ DI++ D++ G-- e 
h! !r xy**
------END GEEK CODE BLOCK------

Quello che forse ti serve e' la funzione:
double difftime(time_t time1, time_t time0);
in <time.h>. Restituisce la differenza di due tempi "calendario"
espressa in secondi e memorizzata in un double. E' una funzione della
libreria standard. Puoi seguire la conversazione con oggetto "clock()"
del 03/01/01.
Newsgroup: it.comp.lang.c
Titolo: gcc sotto Win Xp

Uso dal diversi anni il compilatore gcc con target specifico per alcuni
microprocessori (Hitachi, Motorola etc.). Purtroppo sono ancora
costretto ad utilizzare Win98 come so base in quanto il suddetto
compilatore gira sotto una finestra dos.
Ho provato a cercare ma purtroppo non esite una versione binaria in
grado di girare in una simile configurazione sotto WinXp, decistamente
piu' stabile.
Se qualcuno mi suggerisco un modo, che non sia l'uso delle versione
Linux con Cygwin sotto Xp, già provata ma non vanno bene...
Grazie
Enrico
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Linux con Cygwin sotto Xp, già provata ma non vanno bene...
http://www.mingw.org/
-- 
Marco Barisione

 wrote in message
news:6bp3ja7g...@marco.barisione

Grazie per il suggerimento, ma probabilmente mi sono spiegato male. Io
purtroppo non devo compilare software che GIRI sotto Windows, in quanto
il target del gcc è Motorola oppure Hitachi. Uso una versione apposita
del gcc denomita GCC-68K ed un'altra fatta tanto tempo fa dalla Cygnus,
che non ora non esiste piu'. Questi binari girano sotto finestra dos, e
ovviamente non vanno nel simul dos di Xp/2000.
Arigrazie !


 Enrico
E' un workaround ma...ipotizzando che GCC-68K non esista per winXP,
potresti cercare un emulatore di DOS su cui far girare la versione che
gia' possiedi.
Ciao,
Riccardo
-- 
-=Riccardo Galli=-
 _,e.
s~  ``
 ~@.   ideralis Programs
.   ol 
 `**~  
http://www.sideralis.net

 ovviamente non vanno nel simul dos di Xp/2000.
mmm, non so se funzionera', pero' puoi:
opzione A: provare a usare la bash di cygwin per compilare con gcc-68k
opzione B: provare a ricompilare gcc-68k con cygwin
opzione C: provare a ricompilare gcc in cross-compiling

 opzione C: provare a ricompilare gcc in cross-compiling
Grazie per i vari suggerimenti, per ora utilizzo un ennesimo pc con un
Win98
pulito, sperando non si inchiodi piu' di 4 volte al di' -:). Ho anche
trovato una versione di GCC68K denominata ELF, che gira sotto cgywin, ma
non ho ancora
capito a cosa si riferisce ELF. Me lo studuierň.
Grazie


 capito a cosa si riferisce ELF. Me lo studuierò.
prova a dare uno sguardo qui
http://tinyurl.com/65gm
Newsgroup: it.comp.lang.c
Titolo: Variabili globali - locali

Sto creando una libreria le cui funzioni fanno solo ed esclusivamente
chiamate sequenziali (non-multithreading insomma).
Mi chiedevo se in questo contesto, è opportuno fare uso di sole variabili
globali per un semplice motivo: una maggiore leggibilità del codice: meno
variabili locali = meno dichiarazioni e meno parametri da passare alle
funzioni.
Ovviamente farei comunque uso di variabili locali, ma solo per scopi a breve
termine (le temp, insomma).
Visto che l'accesso alle variabili è esclusivo (senza ricorrere alla mutua
esclusione programmata delle variabili), non si dovrebbe compromettere
l'integrità dell'output, giusto?

 funzioni.
La leggibilità del codice è discutibile. Come è discutibile avere 
variabili con uno scope maggiore del loro effettivo utilizzo, o 
comunicare alle funzioni tramite variabili globali anzichè parametri.
Tenendo conto di tutto questo, non ci sono altre controindicazioni.

 funzioni.
Generalmente la massima e` "non usare variabili globali a meno che non sia
assolutamente necessario".
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

 l'integrità dell'output, giusto?
Sei sicuro che chi usa la tua libreria non faccia ricorso ai thread?
La mutua esclusione non serve solo se la tua libreria fa uso dei thread, ma
anche (e specialmente) se è il fruitore della lib ad usarli.
E' opportuno che una libreria fornisca per ogni fuzione non rientrante una
versione equivalente che invece lo è (eg: strtok, strtok_r).
Ciao
-- 
none

 ma anche (e specialmente) se è il fruitore della lib ad usarli.
Ottimo rilievo... a dire la verità non ci avevo pensato.
Grazie del commento, utile davvero.
Ciao
        F
Newsgroup: it.comp.lang.c
Titolo: Funzionamento strano del ciclo While!

Per capire meglio la scrittura e la lettura di caratteri in C ho scritto
questo programma di esempio:
#include <stdio.h>
#include <ctype.h>
int main()
{
    char ch;
    printf("Immettere un carattere (un punto per uscire).\n");
    while(ch != '.') {
          ch=getchar();
          if(islower(ch)) ch=toupper(ch);
          else ch=tolower(ch);
          putchar(ch);
          }
    return 0;
}
La conversione da maiuscolo a minuscolo e viceversa funziona bene, ma se
inserisco il punto (.) il programma prima di uscire mi stampa un altro punto
in una nuova riga; questo significa certamente che ha eseguito almeno una
volta il ciclo!
Come mai?? Il ciclo While se trova nella condizione un valore falso non
dovrebbe eseguire il ciclo neanche una volta!! Almeno questo č quello che io
ho studiato!
Se anche secondo voi il funziona cosě potrebbe essere il compilatore un po'
sballato?
Io utilizzo DEV-C++ della GNU.
Ciao ciao
RuNg>{  

 sballato?
Non mi pare che alcun compilatore, di alcun linguaggio del mondo
salvo forse il NOSTRADAMUS, possa soddisfare ai tuoi desideri.
Alex

dovrebbe eseguire il ciclo neanche una volta!!
Peccato che il ciclo while scopra che la condizione e' falsa dopo aver
eseguito completamente un ciclo.
ciao

           else ch=tolower(ch);
  Controllo inutile: le funzioni to(low|upp)er sono auto-consistenti da
questo punto di vista. La pagina del manuale, infatti, recita: "The
value returned is that of the converted letter, or the input if the
conversion was not possible".
	Alla prossima,
		Marco

 conversion was not possible".
Perche` inutile?  Questo snippet trasforma tutte le minuscole in
maiuscole *E VICEVERSA*.  La parte "viceversa" non si puo`
realizzare senza un if(islower o equivalente.
In altri termini: l'if sarebbe inutile SE non ci fosse anche l'else,
ma c'e`, e quindi non e` affatto inutile, bensi` utilissimo.
Alex

Newsgroup: it.comp.lang.c
Titolo: JNI

Avrei urgente bisogno di un illustrazione di come produrre una DLL in c ,
che usa classi Java .
Ringrazio tutti coloro che mi risponderanno.
--------------------------------
Inviato via 
http://usenet.iol.it

 che usa classi Java .
 
http://java.sun.com/docs/books/tutorial/native1.1/concepts/
   Sei /off-topic/: news:it.comp.java
-- 
Veri pirati noi siamo       Ma cosa c'e` di male?
Contro il sistema lottiamo  Ma cosa c'e` di strano?
Ci esercitiamo a scuola     Facciamo un gran casino
A far la faccia dura        Ma in fondo lavoriamo
Per fare piu` paura         Per capitan Uncino
Newsgroup: it.comp.lang.c
Titolo: Driver per Windows NT

C'è qualcuno in grado di dirmi se e come è possibile utilizzare dei driver
per Windows 95 di una stampante Xerox su Windows NT 4.0 ?
Sper che qualcuno mi possa aiutare !.
Ciao.

Sper che qualcuno mi possa aiutare !.
Scordatelo. :-)
E' come voler usare un driver Linux su OS/2. Sono due sistemi
operativi completamente diversi.
Quindi, cercati i driver della Xerox per WinNT...
Ciao!


Di solito NO, se per driver intendi file VXD e le DLL associate. Anche se l'
aspetto e' molto
simile NT e' internamente una bestia MOLTO diversa.

Newsgroup: it.comp.lang.c
Titolo: aiuto

ho iniziato da poco a programmare in c,chi puo aiutarmi a sviluppare qualche
programma per aquisire esperienza?
grazie.
antonio

programma per aquisire esperienza?
Per cominciare, potresti procurarti un manuale e seguire gli esempi,
poi magari cerchi di modificarli per fare qualcosa di leggermente
diverso e nel caso incontri problemi ti rivolgi al ng.
Questo e' il metodo migliore per imparare il nuovo linguaggio.
Nel caso, poi, avessi qualche domanda "urgente", chiedi pure... ;)
Andrea Laforgia        (
andrea_...@bigfoot.com
)
----------------------------------------------------
There is nothing better for understanding a kangaroo
than seeing it jump.
----------------------------------------------------
Newsgroup: it.comp.lang.c
Titolo: macro a parametri variabili, howto?

come si fanno?
Il mio problema č questo: in vari punti del mio progr devo scrivere alcune
variabili interne su un log che č gestito da una fn a parte(niente debug
classico, sono sotto interrupt rapido).
Attualmente faccio un blocco di questo tipo
{
//n:b. per logon
char strLog[200];
sprintf(strLog,"\nriccK P=%02d,PL=%s,Pap=%02X\n",pippo,pluto, paperino);
addS(strLog);
}
e tutto funziona, perň in punti diversi del programma devo salvare variabili
diverse, che hanno tipi diversi, sono in numero diverso etc etc.
La mia intenzione, se possibile,era di centralizzare il tutto facendo una
macro che venga chiamata con la stringa di conversione e la lista di
variabili da stampare di caso in caso.
E' possibbole?
Se sě, come si fa?
grazie, saluti

 variabili da stampare di caso in caso.
Tratto da un mio programma:
#ifdef SYSLOG
void log (int priority, char * format,...) {
        static unsigned char open;
        va_list args;
        char string[512];
#ifndef DEBUG
        if (priority == LOG_DEBUG)
                return;
#endif
        va_start(args, format);
        vsnprintf(string, 512, format, args);
        va_end(args);
        pthread_mutex_lock(&lock_log);
        if (!open) {
                openlog("Kpost", LOG_PID, LOG_USER);
                open = 1;
                syslog(LOG_NOTICE, "%s\n", "Starting logging...");
        }
        syslog(priority, "%s\n", string);
        pthread_mutex_unlock(&lock_log);
}
#endif
Per il tuo caso puo` bastare questo:
void log(char *format, ...) {
        va_list args;
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
}
Si usa come una normale printf:
log("foobar\n");
log("i = %d, f = %f, s = %s\n", i, f, s);
ecc.
Sono *quasi* sicuro che la vprintf ci sia anche nel C89.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
La vasca da bagno fu inventata nel 1850, il telefono nel 1875.
Se fossi vissuto nel 1850, avrei potuto restare in vasca per 25 anni
senza sentir squillare il telefono

 senza sentir squillare il telefono
"Was it over when the Germans bombed Pearl Harbor?"
Senatore John P. Blutarski

 adesso provo....
Meglio questa, scrive direttamente su file, si usa come la vprintf.
int vfprintf(FILE *stream, const char *format, va_list ap);
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Recursion n.:
        See Recursion.

Sono *quasi* sicuro che la vprintf ci sia anche nel C89.
Iso C89 sicuramente e dovrebbe essere anche pre-ansi, facendo la
dovuta attenzione ovviamente: nel C89 rispetto al pre-ansi e' cambiata
la libreria per l'uso dei numero di argomenti variabili.
Nel C99 (o semplicemente con GCC con le estensioni GNU) potrebbe
direttamente farsi una macro con numero variabile di argomenti, cosa
comodissima per scrivere su un log o fare una stampa di debug :)
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."