mii-community/UsenetArchiveIT-conversations huggingface dataset:
Newsgroup: it.comp.lang.c
Titolo: Re: Ricorsione (spunto dall' esempio postato da Andrea)

 scelta...
Puoi leggere qualcosa qua
http://it.wikipedia.org/wiki/Ricorsione
Riporto un pezzo
Vantaggi e svantaggi
La ricorsione ha un vantaggio fondamentale: permette di scrivere poche linee
di codice per risolvere un problema anche molto complesso. Tuttavia essa ha
anche un enorme svantaggio: le prestazioni. Due sono le cause:
- In ogni caso la ricorsione genera una quantità enorme di overhead,
invadendo gli stack di memoria per un numero di istanze pari alle chiamate.
Funzioni che occupano una grossa quantità di spazio in memoria, pur potendo
essere implementate ricorsivamente, potrebbero dare problemi a tempo di
esecuzione. Inoltre la ricorsione impegna comunque il processore in maniera
maggiore per popolare e distruggere gli stack
- Su alcuni processori, inoltre, è presente un Link Register utilizzato
direttamente dalle chiamate assembly di istruzioni simili alla JSR del
Motorola 68000. Tale Link Register permette al processore di saltare
dall'exit-point di una subroutine alla sua chiamante. Questo fenomeno accade
soprattutto nei palmari, ed è causa di errori di compilazione o di run-time.
Nei compilatori più avanzati, il tutto si risolve con un calo considerevole
delle prestazioni dovuto all'utilizzo di istruzioni assembly alternative.
Pertanto, se le prestazioni sono obiettivo principale del programma e non si
dispone di sufficiente memoria, si consiglia di non utilizzare la
ricorsione.
Marco

 anche un enorme svantaggio: le prestazioni. 
Non č necessariamente vero.  Molti compilatori, ottimizzando, sono in
grado di produrre codice che ha esattamente le stesse prestazioni del
codice iterativo.
Per rispondere all'OP: io prediligo la ricorsione per gli algoritmi
"naturalmente" ricorsivi (come la navigazione di strutture dati come
liste, alberi, ecc...).  
La ricorsione ha difatti un'enorme vantaggio: la sicurezza.  E' molto piů
facile scrivere codice corretto e questo č un vantaggio che deriva
direttamente dal paradigma funzionale.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 codice iterativo.
Si vede che Wikipedia non conosce questi compilatori...

 - In ogni caso la ricorsione genera una quantità enorme di overhead,[...]
In questo thread c'era stata una digressione sulla ricorsione 
e sulle tecniche usate dai compilatori per tradurre il codice 
ricorsivo in modo efficiente:
http://groups.google.it/group/it.comp.lang.c/browse_frm/thread/321916b633a7358b/0a07f20e7ae6b5fd?tvc=1&hl=it#0a07f20e7ae6b5fd
Ciao.

Si vede che Wikipedia non conosce questi compilatori...
Probabilissimo:
http://www.ddj.com/184410590
Newsgroup: it.comp.lang.c
Titolo: pulire lo schermo..

ciao ragazz questo è il mio primo posti!
avrei bisogno di sapere una cosa
come faccio durante il mio programma a cancellare tutto il contenuto dello schermo?..se non ricordo male in unix si usava qualcosa del tipo clrscr...
grazie per le risposte
-- 
Neonum6 
------------------------------------------------------------------------
View this thread: 
http://www.itsistemi.net/viewtopic-748974.html
Inviato via 
http://www.itsistemi.net

 
E adesso cosa stai usando?
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

system("CLS"); 

 
Si va bene ma system() lancia un altro processo e praticamente
fa quello che ho scritto io.


Newsgroup: it.comp.lang.c
Titolo: Aiuto per neofita

Salve a tutti, sarei intenzionato ad imparare il linguaggio C in molti
mi hanno consigliato di partire con un testo semplice ma senza 
dirmi quale, c'è qualcuno che può consigliare, GRAZIE !!!!

dirmi quale, c'è qualcuno che può consigliare, GRAZIE !!!!
Fai meglio ad imparare il C++.
E' piu' attuale, meno problematico e prima o poi ci dovresti passare
comunque.
Scarica "Thinking in C++" da 
www.BruceEckel.com
 e accostalo ad un buon
testo introduttivo (scegli la traduzione da un testo americano che non
sia assolutamente di Helbert Shildt e procedi).
Buona fortuna ! ;)
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

 dirmi quale, c'è qualcuno che può consigliare, GRAZIE !!!!
Io ritengo che il migliore sia il Kernighan & Ritchie - Il linguaggio C
- Seconda edizione. E' scritto dagli inventori del linguaggio.
EMG

dirmi quale, c'è qualcuno che può consigliare, GRAZIE !!!!
Secondo me ti sarebbe molto utile "Guida al linguaggio C" della McGrawHill
costa circa 40000£
Ciao

dirmi quale, c'è qualcuno che può consigliare, GRAZIE !!!!
Sono anch'io nella stessa situazione ,  io ho comprato "Programmare in
C" , lo affianco al K&R che ritengo più orientato a chi ha già
esperienza con altri linguaggi di programmazione ... (parere
personale)
mg...@polbox.com

Newsgroup: it.comp.lang.c
Titolo: sintassi funzione const

Salve a tutti  ,
non ricordo bene la sintassi corretta, ma più volte in alcuni sorgenti
mi sono imbattuto in funzioni,
TIPO nome_funzione ( TIPO ) const ;
qualcuno sa spiegarmi che particolare significato da alla funzione in
questione la parola "const" ?
grazie duido

questione la parola "const" ?
vuol dire che quella *funzione* non modifica i dati al suo interno...
in C++ in una funzione dichiarata con il suffisso const possono essere
modificati solo quei membri dichiarati come mutable

 modificati solo quei membri dichiarati come mutable
Ecco, appunto ;)
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Runtime error 6D at f000:a12f : user incompetente

grazie ad entrambi per i chiarimenti e scusate per OT
duido
Newsgroup: it.comp.lang.c
Titolo: Buon Natale

Buon Natale a tutti !!!!
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
ATTENZIONE! Rimuovere "
riccar...@iol.it
"
dall'indirizzo email
Saluti by Riccardo
e-mail : 
riccar...@iol.it

Grazie e Buone Feste anche a te.
Angelo.
----------
Rimuovere la protezione anti-spam dall'indirizzo di posta prima di
rispondere. Grazie.
Please remove anti-spam protection from my e-mail address before answering.
Thank you.
----------
Newsgroup: it.comp.lang.c
Titolo: chiudere un file

Ciao, scusate la domanda scema, ma c'e' un modo per controllare se un
file e' gia' stato chiuso?
Il fatto e' che ho sto programma (non mio) che evidentemente ha un bug e
chiude due volte un file, crashando inevitabilmente. Ho commentato un
fclose in una funzione e lasciato quello che, insieme ad altri, chiude
tutti i file aperti. 
Diciamo che sono fiducioso del fatto che se fclose che ho commentato
c'era, era per un motivo, quindi vorrei decommentarlo e, piuttosto,
aggiungere un controllo se il file e' ancora aperto prima di
chiuderlo....
grazie
d


Chiudere piu` volte un file non dovrebbe mandare in crash il 
programma.  E` piu` probbabile che il programma tenti di utillizzare 
il puntatore dopo che il file e` stato chiuso.
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   Registered Linux user #337974  < 
http://giovanni.homelinux.net/
 >

chiuderlo....
Se nessuno ha idee migliori ti consiglio:
FILE *fp = NULL;
.
.
.
fp = fopen ("pippo.txt","w");
.
.
.
if (fp != NULL)
   fclose (fp);
fp = NULL;
oppure sostituisci una fflush al primo fclose che almeno ti
preserva i dati scritti su disco.
PS. L'operazione che di solito porta a un crash e' la
cancellazione di un file (di solito temporaneo) ancora aperto in
scrittura.

 preserva i dati scritti su disco.
Mmm, credo che faro' cosi'.
d

 
La glibc si comporta bene e facendo una doppia fclose() da` il messaggio:
*** glibc detected *** double free or corruption (top): 0x0804a008 ***
Aborted
Verifica se hai lo stderr abilitato e dovresi vederlo se hai una close 
replicata.  In ogni caso, IMO e` piu` probabile che avvenga una 
operazione sul file gia chiuso come scritto in precedenza.


 Aborted
Appunto. Siccome questo programma veniva usato in passato mi chiedo se
precedenti versioni di glibc non dessero questo errore e non facessero
nessun sanity check... boh.

 ha scritto:

La seconda. Il check è stato introdotto di recente. Come workaround
(pessima idea, meglio sistemare il bug) puoi settare la variabile
d'ambiente MALLOC_CHECK_ a 0 (ignora completamente il problema) oppure a
1 (stampa il messaggio ma non chiama abort).
Luca
-- 
Recursion n.:
	See Recursion.
Newsgroup: it.comp.lang.c
Titolo: Domanda classica Perl o C (II) ?

D'accordo, l'entusiasmo di dovere dimenticare almeno per
un po' l'orrida gestione delle stringhe di C (almeno su questo
concorderete!)
per la stupenda gestione delle stringhe in Parl mi ha fatto scrivere una
st*****ta.
Mi ritiro in lurking.
Ciao,
Matteo.

 Mi ritiro in lurking.
Ciao.

 Assembly.
Sai, e' che quando in un char pippo[MAXCHAR] inserisci dei valori,
e che un valore ogni 30.000 valori che gli copi e' lungo MAXCHAR+2,
e l'errore ti salta fuori dopo molti mesi che hai scritto quel codice
perche' stai sporcando la memoria ma, prima delle ultime modifiche era 
andato tutto bene, e per trovare l'errore ci metti 3 giorni in cui 
non ti spieghi dove' il pastrocchio che (ovviamente) si manifesta
in tutt'altra zona del codice, e' un trauma.
Ciao!

 ha scritto nel messaggio
news:2WTC6.36574$s93.1...@news.infostrada.it...


 in tutt'altra zona del codice, e' un trauma.
Ehm, in effetti non č una situazione felice.
Ciao.

 qualche piccola modifica?
Il C viene come versione definitiva del linguaggio, precedentemente chiamato
B e poi successivamente rinominato nel suddetto, con lo scopo di facilitare
la costruzione di sistemi operativi precedentemente realizzati in Asm.
D'accordissimo con te che tra Assembly e C c'è stato il B. La tua è una
giustissima osservazione.
Chiedo scusa se precedentemente sono stato poco chiaro.
Ciao.

Mi ritiro in lurking.
Ecco, bravo.

 ha scritto nel messaggio
news:9oWC6.38393$s93.1...@news.infostrada.it...


 
Probabilmente perchè prima di B c'era l' A...ssembler?
Cia'
----------------------------------------------------------------
 Wizzent - Programmatore
 
http://thexfails.cjb.net
 - 
http://robotstream.cjb.net
 "Odio le citazioni al fondo delle e-mail" (by Aristotele)

 hanno chiamato B e poi C?
Forse la A è quella presa dall'Assembly.
Personalmente se qualcuno chiamasse un linguaggio bassembly o cassembly
comincerei a dubitare delle sue facoltà mentali.
Cmq casi sono due: o quello precedentemente espresso, oppure effettivamente
c'è stato un linguaggio A che ha avuto una così bassa diffusione che nessuno
lo ricorda.
Ciao.

*B*ell Laboratories
o sbaglio?
Charlie



Thx!!!
(Poffarbacco che livore, cos'hai mangiato a pranzo ???)

 Probabilmente perchè prima di B c'era l' A...ssembler?
Ok, interessante, ma potreste togliere il fw-up da it.comp.lang.perl?
:-)
Ciao
M.
-- 
rm -rf 
and be happy

o sbaglio?
BCPL era il linguaggio precedente al C.
La B e' la prima lettera.
La C e' la seconda lettera.
Sono state scelte in ordine, in base al nome di quel linguaggio.
Per molto tempo alcune persone hanno pensato, difatti, che il
successore del C si sarebbe chiamato P.
Ma poi e' arrivato il C++ e ha risolto ogni dubbio.
Newsgroup: it.comp.lang.c
Titolo: vettore di byte e gestione singoli bit

Buongiorno,
devo gestire variabili (meglio dei campi) di diverse dimensioni
memorizzate in un vettore di byte (unsigned char). Gestire nel senso
di estrarle e memorizzarle in variabili adeguate (in paratica devo
fare un'analisi di un header IP).
Per i campi da 2 byte pensavo di utilizzare un unsigned int, per i
campi da un byte unsigned char, e per i campi da 32 bit... long? Come
faccio a memorizzare in un unsigned int i 16 bit che lo compongono, a
rigor di logica userei un puntatore alla variabile che punta al primo
dei due byte che lo compongono.
 Inoltre il problema e' che ci sono campi da 6 bit, e da 4 bit.. come
mi comporto per la loro gestione? devo estrarre i primi 4 bit di un
byte e metterli da una parte, i secondi dall'altra... il mio C e' nu
po'arruginito su queste cose :(
 Per controllare i singoli bit di un byte, inoltre, come mi conviene
procedere?
Scusate per il post da lamer, ma sono un po'con l'acqua alla gola a
livello di tempo. Grazie mille a chi vorra' rispondermi. :)
__
Elwood (Peter S.)

 Scusate per il post da lamer, ma sono un po'con l'acqua alla gola
                          ^^^^^
Spero prorpio che tu non lo sia!
-- 
asettico (aka Roberto) [
http://www.rossomaltese.it/
]
GPG fingerprint [ BA20 8C8D 7712 9D9A 57F3  A96A A7BE 905C 1CB9 26BA ]
-----BEGIN GEEK CODE BLOCK-----
Version: 3.12
GCS/IT/O d++(-) s:+>: a34 C++$ ULAVH*++$>++++ 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++ y+++*
------END GEEK CODE BLOCK------

 l'ordine dei campi in memoria sia lo stesso della sua definizione.
Invece si`.


Ecco la citazione rilevante (dal solito n869.txt, cioe` l'ultima bozza 
pubblica dello standard):
     6.7.2.1  Structure and union specifiers
     [...]
     Semantics
     [...]
     [#12]  Within  a structure object, the non-bit-field members
     and the units in which bit-fields reside have addresses that
     increase in the order in which they are declared.

     increase in the order in which they are declared.
Come non detto, alcune caratteristiche delle versioni 89/99 mi sfuggono.
Rimane però la questione dell'allineamento (anche se mi pare che riguardi 
solo l'architettura i386).


 Spero prorpio che tu non lo sia!
Beh, chi vivra' vedra' :D
ciao e grazie.
__
Elwood (Peter S.)

 Beh, chi vivra' vedra' :D
Nu te ce provà! ;-)
No lamer? Happy hacking!


Newsgroup: it.comp.lang.c
Titolo: Esempio di codice per PING e DIG

Ciao a tutti!
Qualcuno avrebbe mica (o saprebbe dirmi dove posso trovare) un esempio di
come implementare PING e DIG in C?
Grazie
Luca Bertoncello
(
luca...@lucabert.de
)
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 come implementare PING e DIG in C?
É free software, ed é molto probabile che i suddetti programmi sono
stati scritti in C. Vai sulle loro homepage e scarica quello che ti
interessa.
Benjamin
Newsgroup: it.comp.lang.c
Titolo: Differenza passaggio per valore e per riferimento

Credevo di aver capito quali fossero le differenze, ma scrivendo del codice
vedo che ho le idee poco chiare...
Quando passo un valore per riferimento, all'uscita della funzione, la
variabile modificata dovrebbe conservare il valore, a differenza del
passaggio per valore che scrive nello stack( è così ???) e all'uscita della
funzione si perde il valore
Allora dov'è che sbaglio??? Ce la sto mettendo tutta ma francamente non
capisco...
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char prototipo(char*);
int main()
{
   char buffer='a';
   prototipo(&buffer);
   printf("%c\n",buffer);
   return 0;
}
char prototipo(char *appo)
{
    appo=(char*) malloc (1);
    strcpy(appo,"b");
    return 0;
}
La printf mi stampa "a", invece di "b"!!!
Ciao e grazie in anticipo!!!

    strcpy(appo,"b");
Non va bene per due motivi :
1. vuoi modificare un char, quindi ti basta scrivere :
   *appo = 'b' ;
2. allochi per un memoria per 1 carattere e sposti nella memoria
puntata 2 caratteri (ricordati che "b" equivale a { 'b', '\0' }).
-- 
Andrea Laforgia (ICQ# 87230455) ---------------------------
Non scrivetemi in privato, se non richiesto espressamente.
No replies in private e-mail, unless explicitly requested.
----------------------------------------------------------

 {
*appo = '?';
non va?


 puntata 2 caratteri (ricordati che "b" equivale a { 'b', '\0' }).
Non è vero 'b' corrisponde al codice ascii di 'b'
"b" corrisponde alla stringa 'b'+'\0'
è corretto come scrive chi fa la domanda

è corretto come scrive chi fa la domanda
Assolutamente no. E' sbagliato.
Consulta un manuale del linguaggio.

Newsgroup: it.comp.lang.c
Titolo: int[char*] ???

Guardando una entry dell' Obfuscated C code contest del '84
ho visto un espressione del genere
	(intero) [ char* ]
che viene valutato come (se castato su char)
	 0 ["ABCDEF"] --> 'A'
	 1 ["ABCDEF"] --> 'B'
	....
	 6 ["ABCDEF"] --> '\0'
la usava in un modo simile a
#include <stdio.h>
int main()
{
	int i;
	char c;
 
	while( (c = i++["Hello World\n"]) )
		putchar(c);
 
	return 0;
}
Ho cercato qualcosa sul K&R ma non ho trovato niente .
Mi sapete dare qualche indicazione
Ciao grazie
Dario
--------------------------------
Inviato via 
http://usenet.libero.it

 }
Grandioso! Non so proprio da dove salta fuori questa sintassi,
anche se e' comprensibile quello che succede a livello di
puntatori. (PS. se il tuo compilatore non inizializza
la i a 0, bisogna aggiungere la linea i=0; da qualche parte
altrimenti si pianta)
ciao,
g.

"Giovanni Resta" <g.r...@iit.cnr.it.nospam> wrote in message
news:3E75DE17...@iit.cnr.it.nospam

Personalmente non ci trovo niente di grandioso nel martellarsi
gli zebedei con sintassi estreme (tipo quelle che si trovano su
ioccc).
In ogni caso e' la normale equivalenza tra array e puntatori.
a[i] == *(a+i) == *(i+a) == i[a]
C:\>iao angelo
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 ioccc).
Non sto dicendo che lo userei in un programma per il pubblico,
ma sinceramente lo trovo un esempio molto simpatico di qualcosa
che a prima vista sembra sorprendente. Sinceramente penso
che i partecipanti all'ioccc non si martellino gli zebedei ma che invece
si divertano parecchio. E certamente provare a capire
come funzionano alcuni di quei programmi e' istruttivo
e in ogni caso interessante. Si tratta in ogni caso di opere
di ingegno che possono essere contemplate con lo stesso piacere
con il quale si contempla un quadro o si ascolta un brano musicale(imho)
ciao,
g.

a[i] == *(a+i) == *(i+a) == i[a]
Grazie mille, ciao


 g.
Hai ragione, me lo ero dimenticato
Grazie ciao


 e in ogni caso interessante.
Sicuramente non e' che ho capito molto come funziona
http://www.es.ioccc.org/2000/dhyang.c
ma resta uno dei miei preferiti. :-)
C:\>iao Angelo


 
Secoli fa nel gruppo era stato postato questo che e' anche piu'
divertente......
---------------------
 #include <stdio.h>
 int main()
 {
  printf(&unix["\021%sao\012\0"],(unix)["tanti"]+"baci"-0x5F);
 }
----------------------
che compilato sotto linux (dove "unix" vale 1) scrive "ciao".
Se vuoi ti posso postare un po' di spiegazione, ma ci si dovrebbe
arrivare sapendo quello che dici sopra.
Ciao,
     GianPiero
Newsgroup: it.comp.lang.c
Titolo: Visualizzazione dei caratteri accentati

Ciao a tutti,
sono nuovo del ng e del C. Volevo sapere, come da oggetto, come visualizzare 
i caratteri accentati. Uso Dev-C++.
Grazie, Costantino 

i caratteri accentati. Uso Dev-C++.
Prova a lavorare in UNICODE.

 ha scritto nel messaggio 
news:mg3ij2pu2an7vmune...@4ax.com...

Scusa ma come si fa?

Scusa ma come si fa?
Per prima cosa si cerca "unicode" con Google e sull'MSDN...
Poi controlla se l'IDE del Dev-C++ lo supporta (io non conosco
questo ambiente di sviluppo).
Infine decidi se sviluppare l'intero progetto in Unicode, oppure
usare solo le API di output.
Ogni funzione di output ha due versioni: una ASCII e una Unicode.
Per esempio, la TextOut e' in realta' TextOutA in ASCII e
TextOutW in Unicode.
Se vuoi stampare una lettera accentata, o un carattere
particolare che trovi da qualche parte nel programma Mappa
Caratteri, devi essere certo di lavorare con quel font e poi
stampi con:
WCHAR wszStr [256];
wcscpy (wszStr,L"אטלעש");
TextOutW (hdc,r.left,r.top,wszStr,wcslen (wszStr));

 ha scritto nel messaggio 
news:jftnj25crmn7ap39k...@4ax.com...

Ok, grazie. Anche se me lo aspettavo un po' piש semplice.
Newsgroup: it.comp.lang.c
Titolo: Numeri casuali tra -1 e 1

Salve a tutti.
Premetto che sono un po' arrugginito per quanto riguarda il c.
Dovrei creare un array le cui componenti siano piccoli numeri,positivi
e negativi,
vicini allo zero(-1,1).Ho cercato in giro e ho trovato documenti che
pero' trattavano sempre di numeri tra 0 e N creati con rand(),srand()
e compagnia bella.
Qualcuno potrebbe suggerirmi un modo per superare questo scoglio?
Grazie a chi volesse rispondermi.
Saluti.

 rand(),srand() e compagnia bella.
Generi tra 0 e 2, poi sottrai 1.
float foo(void) {
        float ret;
        ret = (2.0 * rand() / (float)RAND_MAX);
        ret = ret - 1.0;
        return ret;
}
Luca
-- 
Home: 
http://kronoz.cjb.net
This message will self destruct in 5 seconds.

Newsgroup: it.comp.lang.c
Titolo: Passaggio di matrci a funzioni

Scusatemi potreste spiegarimi, per favore, come si deve fare per
effettuare in passaggio di una matrice (array bidimensionale) ad una
funzione?
So che bisogna specificare la dimensione delle colonne...
In particolare, dove bisogna specificare tale dimensione? Nella
dichiarazione della funzione oppure nel prototipo oppure nella
chiamata?
Il problema si pone nel momento in cui non conociamo la dimensione
della matrice, quindi se ad esempio la dimensione deve essere
specificata nella dichiarazione, come facciamo a saperlo a priori?
Grazie mille!!!
Allora facendo così è giusto?:
int provamat2(const int[][]);
int main(){
    int mat[4][4];
    for(j = 0;j < 4; j++){
        for(z = 0; z < 4; z++){
            mat[j][z] = j+z;
        }
    }
    i = provamat2(mat);
    return 0;
}
int provamat2(const int matrice[][4]){
    int j, z;
    printf("Sono nella funzione PROVAMAT2!!!\n\n");
    for(j = 0;j < 4; j++){
        for(z = 0; z < 4; z++){
            printf("%d\t", matrice[j][z]);
        }
        printf("\n");
 
    }
 
    printf("\n\n");
 
    return 1;
 
}

Passa alla funzione un puntatore alla matrice e vivi felice :-)
Will ha scritto:


 Passa alla funzione un puntatore alla matrice e vivi felice :-)
Eh si anche, in realtà anche su questo punto ho dei dubbi...
Come lo passo il puntatore alla matrice? C'è bisogno di utilizzare i
doppi puntatori?
Grazie!!

Macchè doppi puntatori...
Mi sa che non hai molto chiara la relazione fra vettori e puntatori, ti
consiglio di riguardartela
Will ha scritto:


 consiglio di riguardartela
Uhm...ok guarderò...
Eppure avevo visto degli esempi coi doppi puntatori...


Se dopo qualcosa non e' chiaro... domanda pure.
Ciao
-- 
Cybertoldo
Per rispondermi via email, sostituisci moc.liamg con 
gmail.com

 }
-- 


Newsgroup: it.comp.lang.c
Titolo: leggere una riga?

Salve,
per favore, qualcuno si ricorda il nome della funzione per 
leggere un'intera riga da un file di testo?
grazie - saluti,
Marco Zanon [
http://www.marcozanon.com
]

 Marco Zanon [
http://www.marcozanon.com
]
-- 
Posted from  [213.82.129.50] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG
Newsgroup: it.comp.lang.c
Titolo: Come stampare?

Ciao a tutti!
Sono alle prime armi con questo linguaggio e vorrei sapere come fare per
stampare (su stampante, non a video...) una qualunque cosa.
Grazie!

 ha scritto nel messaggio
news:92b64k$nii$1...@lacerta.tiscalinet.it...

Newsgroup: it.comp.lang.c
Titolo: restituire una stringa

Come fare a restituire una stringa?
Pensavo che l'unico modo fosse passare alla funzione un array atto a
contenerla, ma la funzione "char *tmpnam(char *)" mi smentisce:
se tmpnam viene invocata con NULL come argomento, la funzione restituisce lo
stesso una stringa. Forse alloca dello spazio internamente. Ma questo
spazio, non andrebbe poi deallocato? Come funziona?
Ciao.
Antonio.

 spazio, non andrebbe poi deallocato?
Per il  caso particolare  di tmpnam  vedi man tmpnam  che spiega  che la
funzione usa un buffer statico (primo esempio). Non devi quindi chiamare
free(). In  generale devi  vedere la  documentazione della  funzione per
sapere cosa fare.
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
Windows /win'dohz/ n. : thirty-two  bit extension and graphical shell to
a sixteen  bit patch to an  eight bit operating system  originally coded
for a  four bit microprocessor  which was  written by a  two-bit company
that can't stand a bit of competition.

 wrote in
news:883t1v4g8s5vre4cc...@4ax.com
: 

Se l'argomento non è NULL, la funzione memorizza il il risultato nel 
puntatore fornito assumendo che ci sia spazio sufficiente e restituisce lo 
stesso puntatore. Se è NULL, restituisce un buffer statico che di 
conseguenza non va distrutto.

 stringa.
Ha anche lo svantaggio che la funzione demanda la deallocazione al 
chiamante. Non č banale, perchč venendo meno la regola del "chi alloca, 
dealloca" chi scrive il programma non sa piů cosa deve deallocare e cosa 
no.
Il problema della sovrascrittura del buffer statico e facilmente risolto 
sapendo che č tale :-) ovvero non usando quel puntatore ma copiando il 
contenuto in un "luogo sicuro". Oppure passando il puntatore come 
argomento.

Grazie per le vostre risposte. Non avevo pensato alla soluzione del buffer
statico, mentre, la seconda (quella del buffer allocato dinamicamente) mi
sembrava poco pulita, per i motivi  spiegati da voi.
Ciao

Newsgroup: it.comp.lang.c
Titolo: sscanf() e dati divisi da :

Salve a tutti,
ho una stringa: stringa[] = "hostname:1234";
come faccio ad acquisire in 2 distinte variabili il primo e il secondo campo
divisi dai :?
Ho provato cosě:
1.
char szHostname[20];
char szPort[20];
sscanf(stringa,"%s:%s",szHostname,szPort);    /* Non funziona... */
2.
char szHostname[20];
int iPort;
sscanf(stringa,"%s:%d",szHostname,&iPort);   /* Non funziona... */
Come devo fare?
Grazie

Come devo fare?
#include <stdio.h>
int main()
{
    char s[128];
    char fstpart[128];
    char sndpart[128];
    fgets(s, sizeof s, stdin);
    sscanf(s, "%[^:]:%[^\n]", fstpart, sndpart);
    printf("%s e %s\n", fstpart, sndpart);
    return 0;
}

>     sscanf(s, "%[^:]:%[^\n]", fstpart, sndpart);
Grazie e 1000, funziona alla perfezione, ma dove posso trovare online i
riferimenti della sscanf() per fare operazioni tipo questa? Non mi piace non
capire....
Ancora grazie!

 wrote in message
news:3c1c704a...@news.tin.it...



Talking about music is like dancing about architecture.
                -- Laurie Anderson
Newsgroup: it.comp.lang.c
Titolo: e' possibile?

Salve, volevo sapere se e' possibile nascondere il cursore della console
win32...

 win32...
Non qui. Prova su:
it.comp.programmare.win32
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"Sei l'unica donna della mia vita".
(Adamo)

Newsgroup: it.comp.lang.c
Titolo: offsetoff()

Riquadro8-2:Caratteristica ANSI-La macro offsetof
Lo standard ANSI fornisce un metodo per la valutazione dello
]scostamento in byte di un elemento di una struttura(eccettuati i campi di
bit).
La macro richiede come argomenti il tipo della struttura e il nome
dell'elemento:
offsetof (type,member-name)
e restituisce il valore intero in byte dello scostamento dell'elemento
dall'inizio della struttura.Il tipo del risultato è specificato dalla macro
'size_t' definita nel file header 
stddef.h.Si
 consideri il seguente
esempio:
#include <stddef.h>
typedef struct
{
        char widgetname[MAX_NAME];
        int widgetcount;
        enum WIDGET_TYPE widgetType;
} WIDGET_INFO;
  . . .
   size_t  typeOffset = offsetof(WIDGET_INFO,widgetType);
A questo punto,la variabile typeOffset contiene un valore intero
che rappresenta lo scostamento dell'elemento widgetType.
Questa informazione può essere molto utileper determinare le
modalità di allineamento degli elementi di una struttura adottate
dal compilatore.
Anche se questa caratteristica è una estensione allo standard K&R,
molti compilatori forniscono costrutti di questo tipo da anni.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Il problema è:
la macro size_t so solo che restituisce un valore ottenuto da
un espressione sizeof().Il testo non dice altro.
Indi per questa e altre(siGh!)cause non riesco a capire la
seguente direttiva #define:
5)La macro ANSI offsetof  fa uso di un interessante insieme di puntatori C
   e operazioni di conversione di tipo esplicite.La macro offsetof può
essere
  definita nel modo seguente:
  #define offsetof(t ,m) (size_t)&((t *)0 ->m)
Spiegar in dettaglio perchè questo codice calcola lo scostamento in
byte di un elemento in una struttura e ipotizzare una modalità
alternativa per realizzare offsetof.
Ciao!
--
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Per rispondere cancella "NOSPAM" o indirizza a "
Fl...@chierinet.it
"
                                                    Ciao!
             §
§
 For answer delete "NOSPAM" or address to "
Fl...@chierinet.it
"
                                                     Bye!
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 alternativa per realizzare offsetof.
Allora: t* e' un cast che converte lo zero in un puntatore al tipo t.
Quindi (t*)0->m e' l'elemento m di una struttura che, in memoria,
comincia da 0. Quindi il suo indirizzo (di m) &((t *)0 ->m) indica
proprio l'offset di m nella struttura.
Il size_t davanti a tutto e' un cast da (tipo di m *) a size_t.
 
-- 
Andrea Vettori
------------------------
vet...@computer.org
http://www.dei.unipd.it/~vettori
    (italiano)
http://www.geocities.com/ResearchTriangle/9236
   (english)
Newsgroup: it.comp.lang.c
Titolo: cambiare password in c su linux

Per tutti i programmatori linux:
Chi sa dirmi in che modo posso scrivere una funzione che modifichi la
password criptata nel file shadow?
So che esiste (e l'ho utilizzata) una funzione che restituisce una
strutura contenente tutti i dati contenuti nel file di shadow relativo
ad un utente, passandogliil nome, ma in questo modo posso solo leggere e
non modificare. Esiste qualche cosa per modificare?
Grazie!

, 
bart...@iol.it
 says...

penso che la cosa migliore sia dare un'occhiata ai sorgenti del programma 
passwd.
Dovresti trovarlo senza problemi su qualsiasi mirror del sunsite (ad 
esempio 
ftp.unina.it/pub/linux..
..
Ciao
-- 
Pietro F. Maggi                             pietromaggi AT libero DOT it
http://pietromaggi.50megs.com/
 
La pedina è il pezzo più importante degli scacchi...per la pedina

 password criptata nel file shadow?
Guarda putspent().
Ciao ciao,
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

Newsgroup: it.comp.lang.c
Titolo: Re: Modifica file

 Intendevo data ed ora di creazione
Tramite una API di Windows.

Qual'č? Abbi pazienza, ho googleato un pň (pure sui NG) ma non ho trovato
nulla sul C...
-- 
"Windows cerca di fare Unix e ci riesce male, Red Hat cerca di fare Windows
e ci riesce benissimo" (Jimmy Olgeni)

Intendevo data ed ora di creazione
-- 


C'è una funzione che mi permette di modificare attributi di un file (esempio
data ed ora) su Windows? Ho trovato solo dei programmi precompilati, a me
interessava proprio sapere la funzione (o comunque un'eventuale procedura
da seguire).



prova se c'č l'header fstat.h (librerie C niente API)

 prova se c'è l'header fstat.h (librerie C niente API)
Siete OT... spostatevi su it.comp.programmare.win32
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it
Newsgroup: it.comp.lang.c
Titolo: Redirezionare l'output su una shell

Ciao a tutti,
stavo leggendo in rete un esempio di creazione shell.
Ok, la shell viene creata, ma poi ho pensato di inviare un comando alla
shell, direzionando lo standard output (stdout) all'input della shell.
Cosa sto sbagliando?
Ho sentito parlare del pipe, devo per forza crearne uno per far comunicare
la shell creata con il mio programma?
Ciao, Simo

fw to: it.comp.os.linux.development

Non ho capito molto di quello che hai detto, ma in sostanza di solito si:
- usa popen (che però.. mah..)
- usa pipe+fork+dup2+execve
- ma execve di sh -c bla? system?
Per il primo caso man popen.
Nel secondo si creano 2 pipe [se vuoi leggere e scrivere alla shell,
altrimenti 1 sola].
Si forka (o vforka), si esegue dup2 [nel figlio] di standard input, output
ed error alle pipes appropriate e si fa l'execve.
Se qualcosa non ti è chiaro riposta che buttiamo giù 2 righe di codice.
Attento con i comandi che generano *molto* output.. trova il modo di
svuotare la pipe leggendo il suo contenuto altrimenti il programma eseguito
in shell si bloccherà [occhio quindi alle wait()]
Hai pensato di usare execve con sh -c o addirittura system?
Ciao.
-- 
none

 ha scritto nel messaggio
news:KroCd.361008$b5.17...@news3.tin.it...


 Ps: sono OT, devo spostarmi?
si. e potresti anche quotare in modo umano.
-- 
[ RiK0                                ]
[ non credo negli schemi non vincenti ]
[ two is an odd prime number          ]

Newsgroup: it.comp.lang.c
Titolo: per chi usa Djgpp

Salve a tutti  , una domanda per gli utenti Rhide+Djgpp :
come devo settare il file Autoexec.bat  per utilizzare questo compilatore
con Win95 e Win98?
Grazie 1000 Ciao :-)   Roberto

 ha scritto nel messaggio
news:8cpq8j$6jm$1...@pegasus.tiscalinet.it...

Newsgroup: it.comp.lang.c
Titolo: Mi spiegate com'è possibile??????

se stampo su standard output la variabile md (un puntatore a carattere) con
la seguente:
for (i=0; i<20; i++) {
        printf("%x",*(md+i));
}
mi restituisce il valore
ffffffb06e56fffffff4ffffffb732
ffffffb5ffffff88ffffff91ffffff
d0fffffff8dffffffabffffffb0fff
fff8f9752c6238
che "sarebbe" quello desiderato se non ci fossero tutte quelle "ffffff".
La cosa strana poi è che strlen(md) mi dice che la lunghezza di questa
stringa è di 20 bytes, quando, a monte dei 104 valori stampati, dovrebbero
essere 52 (104*4/8);
cos'è successo??????


quasi sicuramente hai usato i char invece degli unsigned char e il bit 
di segno si è popagato durante la pomozione ad int richiesta da %x.
prova ad usare gli unsigned char.
ciao.

 cos'è successo??????
Ma, scusa, in base a cosa dici che sono stati stampati proprio 104
"valori"!? Io vedo un solo numerone, fatto da 104 cifre esadecimali...
Punto primo, se devi stampare una serie di numeri, mettici qualcosa (uno
spazio, un a capo, una virgola, quel che vuoi) per separare un numero
dall'altro!
Invece di "%x" usare, che, so "%x\n". Vedrai che i valori stampati sono
proprio 20:
   ffffffb0
   6e
   56
   fffffff4
   ffffffb7
   32
   eccetera...
Numeri come 0x6E o 0x56 sono probabilmente quel che t'aspettavi. Restano
da spiegare numeri come 0xFFFFFFB0.
Per farlo bisogna ricordare che, in C, non esistono espressioni di tipo
"char". Possono esistere *variabili* di tipo char, ma non espressioni.
Considera il seguente codice:
    char a = 2;
    char b = -2;
    printf("%x %x\n", a, b);
"a" e "b" sono singoli byte che contengono, rispettivamente, i seguenti
otto bit ognuna:
   00000010 (+2 a 8 bit)
   11111110 (-2 a 8 bit)
Ma quando tu le valuti all'interno di un'espressione, per esempio dentro
la chiamata alla printf, diventano espressioni di tipo int che contengono,
rispettivamente i seguenti TRENTADUE bit:
   00000000000000000000000000000010 (+2 a 32 bit)
   11111111111111111111111111111110 (-2 a 32 bit)
In entrabi i casi, l'estensione da 8 a 32 bit viene fatta riempiendo i 24
bit aggiunti a sinistra con il valore del bit più a sinistra del numero a
8 bit.
Se tu stampi questi due valori int con la direttiva "%d" otterrai,
rispettivamente, "2" e "-2". Ma se li stampi con la direttiva "%x", che
otterrai "2" e "fffffffe".
Sicurissimo di non essere riuscito a spiegarmi manco per una cippa, ti fo
un ultimo appunto: perché scrivi un'espressione illeggibile come  *(md+i)
, quando potresti invece scrivere  md[i] ?
--
Cingar
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 che "sarebbe" quello desiderato se non ci fossero tutte quelle "ffffff".
Il perche` ti e` stato spiegato. Se vuoi stampare dei char (come interi,
non come caratteri) usa il modificatore "hh", ie:
printf("%hhx", ...);
Luca
-- 
Home: 
http://kronoz.cjb.net
Io sono un uomo che non deve chiedere mai. Di solito imploro.
Newsgroup: it.comp.lang.c
Titolo: Come passo i parametri a questa funzione?

Salve, mi sono imbattuto su questa funzione:
uint16_t CRC16_Small_LT(const uint8_t* const pui8_DataBuf, const
uint32_t ui32_DataBufSize)
Non riesco a capire la dichiarazione del primo parametro:
quando chiamo la funzione passo delle costanti, in questo modo:
a= CRC16_Small_LT(0x0000, 0x0100);
Il tutto funziona.
Se però provo a mettere una costante diversa da zero nel primo
argomento la compilazione fallisce:
a= CRC16_Small_LT(0x0002, 0x0100);
errore : Function argument incompatible with its declaration
Possibile che si tratti di un dichiaratore astratto??
Sapete dirmi come posso passare alla funzione dei valori maggiori di
zero?
Grazie


Il primo parametro deve essere un puntatore;
0x0000 è NULL quindi te lo accetta
Ciao
M

 0x0000 è NULL quindi te lo accetta
Ma perchè non è dichiarato con l'asterisco che precede il nome del
parametro che passo:
uint16_t CRC16_Small_LT(const uint8_t const *pui8_DataBuf, const
uint32_t ui32_DataBufSize)  ?
Cioè .. che differenza c'è tra:
uint16_t CRC16_Small_LT(const uint8_t* const pui8_DataBuf, ...)
uint16_t CRC16_Small_LT(const uint8_t const *pui8_DataBuf, ...)
Grazie

 uint16_t CRC16_Small_LT(const uint8_t const *pui8_DataBuf, ...)
Ti compila? Mi pare ci sia un const di troppo.
E.

 uint16_t CRC16_Small_LT(const uint8_t const *pui8_DataBuf, ...)
Non c'e' una differenza.
cc

 Ti compila? Mi pare ci sia un const di troppo.
% cat main.c
#include <stdio.h>
int main() 
{
        const const char const const * const const s = "ok";
        puts(s);
}
% gcc -Wall -std=c99 -pedantic -o dummy main.c
% ./dummy
ok
cc

Claudio Carobolante ha scritto:

No, sono diversi. Il primo ï¿œ un puntatore costante, a intero costante, 
il secondo ï¿œ un puntatore a intero costante. Per verifica:
 > cat test.cpp
const int * const p;
const int const *q;
const int *r;
 > gcc -c test.cpp
test.cpp:1: error: uninitialized const 'p'
test.cpp:2: error: duplicate 'const'
E.

Claudio Carobolante ha scritto:

Ok, il C lo sopporta, il C++ no...
E.

 test.cpp:2: error: duplicate 'const'
Scusa, ma qui siamo in/nel/su/? (scusate il mio male italiano)
it.comp.lang.c e stiamo parlando dalla lingua C. Come C++ sta vedendo
questo punto, non e interessante qui.
% cat main.c
#include <stdio.h>
int main() 
{
        const int * const p;
        const int const *q;
        const int *r;
}
% gcc -Wall -std=c99 -pedantic -o dummy main.c
main.c: In function `main':
main.c:5: warning: unused variable `p'
main.c:6: warning: unused variable `q'
main.c:7: warning: unused variable `r'
Vedo warnings, non vedo errori.
cc

Claudio Carobolante ha scritto:

prova ad aggiungere le righe:
p=q;
q=p;
e vedrai che la prima delle due ti dï¿œ errore.
E.

 e vedrai che la prima delle due ti dï¿œ errore.
Hai ragione. Scusa, qui in germania diciamo che avvevo un pannello
avanti la testa (ein Brett vor dem Kopf). Non ho guardato bene e
avvevo un grande pannello avanti la testa.
cc
Newsgroup: it.comp.lang.c
Titolo: Array di stringhe di lunghezza fissa allocato dinamicamente

Io voglio allocare dinamicamente un array di stringhe di lunghezza fissa
cosi' (50 stringhe lunghe 100 carattteri nell'es.):
#define MAXLEN 100
#define MAXELEM 50
main()
{
    int i;
    char **prova;
    prova=(char **)calloc(MAXELEM,sizeof(char *));
    for(i=0;i<MAXELEM;i++)
    {
        prova[i]=(char *)malloc(MAXLEN*sizeof(char));
    }
}
Tutto funziona perfettamente ma volevo sapere se esistono altri metodi piu'
semplici e corti per fare la stessa cosa (senza pero' usare una struttura
con un solo campo di cui poi allocare MAXELEM con una sola calloc, l'ho gia'
provata....).
Ad es. si puo' gia' nella dichiarazione (del tipo char (*prova)[MAXLEN]....)
scrivere che ogni stringa deve essere lunga MAXLEN caratteri e poi fare una
sola calloc per allocare tutti gli elementi dell'array?
Un'altra domanda, e' possibile sapere nel codice precedente tramite la
sizeof quanto spazio per ogni stringa dell'array avevo riservato con la
malloc (in pratica se non so MAXLEN nel caso in cui allocassi dinamicamente
anche la lunghezza di ogni singola stringa dell'array)?
Grazie a tutti

 }
puoi fare più semplicemente:
   char *prova[MAXELEM] = {0};
e poi il ciclo che alloca memoria per ogni elemento.
A mio avviso non ci sono altri metodi di allocazione dinamica diversi da
qusti due. (altrimenti char prova[MAXLEN][MAXLEN]; ma è statico)
--------------------------------
Inviato via 
http://usenet.libero.it
Newsgroup: it.comp.lang.c
Titolo: Algoritmi per stringhe e ordinamenti

Qualcuno puo' indicarmi dei siti in cui posso trovare degli algoritmi
o delle librerie per la gestione delle stringhe e ordinamenti(sort).
Ringrazio Ugo (
vi1...@iperbole.bologna.it
)

...

Newsgroup: it.comp.lang.c
Titolo: ma perchè non va?

Ciao a tutti.
Ho un problemino con questo tipo di assegnazione:
typedef struct Albero {
	struct Albero *figlio_destro;
	struct Albero *figlio_sinistro;
	char   data[300];
} ALBERO;
ALBERO *radice_albero_ptr = NULL;
99  radice_albero_ptr = malloc(sizeof(ALBERO));
100 radice_albero_ptr->data = "ferrucci"; 
101 radice_albero_ptr->figlio_destro = NULL;
102 radice_albero_ptr->figlio_sinistro = NULL;
in fase di compilazione mi da un errore di questo tipo:
In function `main':
..:100: incompatible types in assignment
Qualcuno di voi sa dirmi dove sbaglio?
Grazie in anticipo.

 Qualcuno di voi sa dirmi dove sbaglio?
riga corretta:
100 strcpy(radice_albero_ptr->data,"ferrucci"); 
bye
-- 
Onofrio Panzarino, Ancona, Italy
 O glaube, mein Herz, o glaube:
 Es geht dir nichts verloren!
Newsgroup: it.comp.lang.c
Titolo: Sul suono...

Questa e' una domanda un po' specifica...
ho provato a convertire la tastiera del pc in tastiera musicale ... tutto
ovviamente semplicissimo. Il problema e' che non so a che frequenza ( in
Mhz) corrisponde il Do e a quanto Mhz corrisponde un tono. 
Mi spiego ... se a 'q' voglio assegnare il do, devo sapere che valore
mettere in sound(...). Se poi mettessi un numero a caso ( cosi' facendo non
saprei che nota e' ), affinche' il 'w' sia la nota successiva devo sapere
esattamente un tono a quanto equivale altrimenti avrei solo un' accozzaglia
di suoni e niente piu'...
Qualcuno  mi puo' aiutare ??? 
-- 
Pietro Spadavecchia
 A.(also) K.(known) A.(as)     
 Z100 on IRC ( EFnet #italia #15billion )
 
http://www.geocities.com/TheTropics/6147
 
---
La bisessualita' immediatamente raddoppia 
le tue chances il sabato sera.
                           - Woody Allen-

Perché non provi a postarlo a it.comp.musica?
Ciao Gabry
peter ha scritto nel messaggio <01be2053$c486de20$671a78c3@pietrosp>...


sacla cromatica a temperamento equabile: LA=440 Hz
scala cromatica normalizzata:LA=435 Hz
scala scientifica (basata sul DO): DO=256 Hz => LA=426.67 Hz
Cerca su "Handbook of Chemistry and Physics" alla voce musical scales

Il LA del diapason ha una frequenza di 440Hz.
Una nota di un ottava ha una frequenza doppia della stessa nota dell'ottava
precedente; ad esempio 220Hz e 880Hz sono sempre LA.
Il rapporto tra un semitono (sono 12) ed il precedente e' pari alla radice
dodicesima di 2:
quindi LA# = 440 * 2^(1/12) = 466.
Antonio Donatiello.


Newsgroup: it.comp.lang.c
Titolo: Compilatore free

Ciao o tutti,
qualcuno conosce qualche compilatore C free che sia in grado di generare
codice a 16 bit? Djgpp e' a 32 bit ... :-(
Grazie!
Aquaz

 di generare codice a 16 bit? Djgpp e' a 32 bit ... :-(
  Dicono che la Borland abbia rilasciato i suoi vecchi compilatori a
sedici bit, come il Turbo C 3.0. Controlla sul loro sito.
	Alla prossima,
		Marco
Newsgroup: it.comp.lang.c
Titolo: Caratteri ASCII e numeri hanno diversa larghezza?

Ciao,
innanzi tutto voglio ringraziare Alessandro per la sua risposta ad un
precedente post: sei stato illuminante!
Il mio problema:
per fare dei rudimentali istogrammi mi sono servito del carattere ASCII
148 (quadratino). Era mia intenzione porre alla base di ciascuna colonna
il valore dell'asse x, ovvero semplici numeri cardinali. Tuttavia mi
sono accorto che la larghezza dei quadratini e' minore di quella di un
numero e alla fine, pur partendo insieme, istogramma e asse x sono
sfalsati.
Anche includendo il numero dell'asse x come elemeto zero nel vettore dei
quadratini ottengo lo stesso antipatico risultato.
qualcuno ne sa qualcosa?
come si puo' fare?
grazie e ciao,
mirko  
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 [...]
In un ambiente con interfaccia testuale, ogni carattere stampabile occupa lo
stesso spazio degli altri.
Se stampi su due righe diverse lo stesso numero di caratteri, le righe
devono apparire sullo schermo della stessa lunghezza, a meno che non ci sia
qualche carattere 'non stampabile' in una delle due righe...
Invece che i quadratini prova a usare qualcosa di sicuro '|', 'O', etc...
Ciao,
Ema

 
Ciao,
intendi se il mio numero sull'asse x e' di una o piu' cifre?
e' una cifra sola, va da 0 a 9.
il prog stampa le occorrenze dei numeri digitati da tastiera e le plotta
in un istogramma.
percio' c'e' una colonna per ogni numero del tastierino.
qualche idea?
ciao e grazie, mirko


 Ma questo numero quanti caratteri ha?  E` sempre lungo uguale?
[Spero di non postare due volte... prima ha fatto casino...]
Il numero e' di una cifra sola, va da 0 a 9.
Il prog stampa le occorrenze dei numeri digitati da tastiera e le plotta
in un istogramma.
dunque la colonna 0 si riferisce alle oocorrenze del numero 0, la col. 1
a quelle del numero 1 e avanti fino al 9.
qualche idea?


 
Ciao,
si, il numero e' sempre lungo uguale ed e' di una cifra.
Il prog registra le occorrenze dei numeri inseriti da tastierino
dall'utente e ne riporta le frequenze in un istogramma.
dunque la col 0 riporta le occorrenze del numero 0, la col 1 quelle del
numero 1, e cosi' fino a 9.
Io vorrei stampare sotto le colonne il numero corrispettivo, ma, come
detto, istogramma e asse x risultano sfalsati.
qualche idea?



Due straccetti di algoritmo e/o codice?
Cosi' a occhio...
se "int occorrenze[10]" contiene le occorrenze delle cifre e "int max_occ"
contiene il massimo valore occorrenze[i]
l'istrogramma si potrebbe costruire cosi' (codice non testato):
for (j = max_occ; j >= 0; j--) {
    for (i = 0; i < 10; i++) {
        if (occorrenze[i] <= j) printf("|");
        else printf(" ");
    }
    printf("\n");
}
printf("0123456789\n");
Ovviamente viene tutto un appiccicume. Ma quello si aggiusta poi...
Ciao,
Ema