Newsgroup: it.comp.lang.c
Titolo: Si ricomincia ...

Dopo tantissimo tempo riprendo a programmare. Ho scelto C/C++ per iniziare.
Sono quindi alle primissime armi.
Prima ancora di addentrarmi nei meandri della programmazione orientata agli
oggetti vorrei consolidare le mie conoscenze relativamente alla sintassi
delle funzioni di base ... sotto dos.
Esistono in rete sorgenti di programmini in c o c++ ... anche i più
"stupidi" :-)) .. che possa scaricare e studiare ?
Quesito da ... 100 lire.
Mi aiutate a trovare l'algoritmo corretto per la risoluzione di questo
"problema" ? Magari con qualche esempio in c e c++ ?
Premesso che il programma deve girare sotto dos.
Come faccio ad inserire i valori in determinati campi visualizzando però dei
simboli che "nascondano" il carattere effettivamente battuto ? Ed inoltre,
come posso muovermi fra i "campi" attraverso le frecce direzionali ?
Es. Il programma deve visualizzare questa maschera:
Nome: *******************
Cognome: *******************
Età: ***
In fase di input il cursore dovrebbe posizionarsi sul primo "*" del campo
'nome' da dove l'utente può digitarne il contenuto ... Premendo invio si
dovrebbe poter scendere al secondo campo. Per tornare al primo si dovrebbe
soltanto utilizzare la freccia (tasto freccia in alto). Stessa cosa per
scendere al successivo campo (ovviamente freccia in basso) ... E ciò anche
se non è stato inserito niente nel campo.
Grazie 100.000
Arturo

you wrote :

--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

"stupidi" :-)) .. che possa scaricare e studiare ?
Francamente io ti consiglierei di procurarti una distribuzione
Linux o FreeBSD e programmare li' sopra in C o C++: i vantaggi
sono moltissimi e vanno dall'avere a disposizione i migliori
tool per editing e compilazione (da vim a emacs al compilatore
gcc) all'avere i sorgenti di praticamente tutti i programmi che
girano su quei sistemi (secondo il sistema "free software" o
altrimenti detto "open source") e, cosa non secondaria,
all'avere attorno una comunita' di persone giovani e meno
giovani che il C o il C++ lo respirano.
Tieni presente che quello che programmi sotto unix in C e'
abbastanza facilmente portabile sotto DOS e anche sotto
win(95,98,NT): e di esempi ce ne sono molti.
-- 
Bye by Red  |  BHP on a Linux box                   E-mail: 
ME7...@mclink.it
            |---------------------------------------------------------------
            |  grep [Ll]ove Western_Civilization.txt > Desperate_Love.txt
            |  rm Western_Civilization.txt && echo '(Mr. Nobody)'

Il nostro Andrea ha ancora qualche problemino con Agent a quanto pare...
;-)
-- 
 Ciao, Luca.
 Reply to 
luca....@tiscalinet.it

altrimenti detto "open source")
Attenzione però a non confondere le cose.
"Free software" ed "Open Source" non sono la stessa cosa.
La differenza è sottile, ma esiste.
Lo stesso Richard Stallman, che ha avviato la rivoluzione del "free
software", ha divulgato un documento a riguardo.
L'"Open Source" è un concetto che dichiara soltanto che il codice
sorgente del programma può essere visto e, quindi, comprende, oltre a
tutta la classe del codice distribuito come "Free Software", anche
diversi software non del tutto liberi o addirittura proprietari, ma
distribuiti con determinate forme di licenza.
Il Free Software è intendibbile come un sotto-dominio dell'Open
Source.
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)

;-)
Mea Culpa, Mea Culpa ! Maledizione !!! ;))
/**************************/
/* MASKDOS.C - 15/11/1999 */
/**************************/
/* compilato con DJGPP    */
/**************************/
/* Andrea Laforgia        */
/**************************/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
#define MASKCHAR     '*'
#define BACKSPACE     8
#define ENTER        13
#define ESC          27
#define UPARROW      72
#define DNARROW      80
#define TRUE          1
#define FALSE         0
#define DOEXIT(x)       { RetVal = x ; ExitCond = TRUE ; break ; }
typedef unsigned  word ;
typedef int       bool ;
typedef struct {
                  char buffer[50] ;
                  word size ;
                  word x ;
                  word y ;
               } recordtype ;
static recordtype field[3] =
{ { "\0", 15, 22, 5 },
  { "\0", 25, 22, 7 },
  { "\0",  3, 22, 9 } } ;
void Color( word foreground, word background )
{
     textcolor( foreground ) ;
     textbackground( background ) ;
}
void WriteStringAtPos( char *s, word max, word x, word y )
{
     word p, l = strlen( s ) ;
     for ( p = 0 ; p < max ; p++ )
     {
         gotoxy( x+p, y ) ;
         if ( p < l )
            putch( MASKCHAR ) ;
         else
            putch( ' ' ) ;
     }
}
bool ValidChar( char c )
{
     return ( isalnum( c ) || ( c == ' ' ) ) ;
}
word ReadString( char *s, word max, word x, word y )
{
     char c ;
     word p, RetVal ;
     bool ExitCond = FALSE ;
     Color( 15, 1 ) ;
     p = 0 ;
     while ( ExitCond == FALSE )
     {
         WriteStringAtPos( s, max, x, y ) ;
         gotoxy( x+p, y ) ;
         c = getch() ;
         if ( c == 0 )
         {
            c = getch() ;
            switch( c )
            {
                  case UPARROW    : DOEXIT(UPARROW) ;
                  case DNARROW    : DOEXIT(DNARROW) ;
            }
         }
         else
         if ( ValidChar( c ) && (p < max) )
         {
            s[p++] = c ;
            s[p] = 0 ;
         }
         else
         {
            switch( c )
            {
                  case ENTER     : DOEXIT(ENTER) ;
                  case ESC       : DOEXIT(ESC) ;
                  case BACKSPACE : if (p > 0)
                                   {
                                      s[--p] = 0 ;
                                   }
                                   break ;
            }
         }
     }
     return RetVal ;
}
word ReadField ( recordtype * F )
{
     return ReadString( F->buffer, F->size, F->x, F->y ) ;
}
void InitMask ( void )
{
     Color( 7, 0 ) ;
     clrscr() ;
     gotoxy( 10, 5 ) ;
     cprintf( "Nome......:" ) ;
     gotoxy( 10, 7 ) ;
     cprintf( "Cognome...:" ) ;
     gotoxy( 10, 9 ) ;
     cprintf( "Eta\'......:" ) ;
     gotoxy( 10, 15 ) ;
     cputs( "ESC per uscire" ) ;
}
int main()
{
    word Result = 0, RecIdx = 0 ;
    InitMask() ;
    while ( Result != ESC )
    {
        Result = ReadField( &field[RecIdx] ) ;
        switch ( Result )
        {
               case ENTER   :
               case DNARROW : if ( RecIdx == 2 )
                              {
                                 RecIdx = 0 ;
                              }
                              else
                              {
                                 ++RecIdx ;
                              }
                              break ;
               case UPARROW : if ( RecIdx == 0 )
                              {
                                 RecIdx = 2 ;
                              }
                              else
                              {
                                 --RecIdx ;
                              }
        }
    }
    Color( 7, 0 ) ;
    clrscr() ;
    puts( field[0].buffer ) ;
    puts( field[1].buffer ) ;
    puts( field[2].buffer ) ;
    return 0 ;
}
--
Andrea Laforgia        (
andrea_...@bigfoot.com
)


Bravo. Hai fatto bene a precisare le cose. Nella mia risposta
intendevo fare una grezza approssimazione, insomma intendevo
parlare genericamente di software di cui puoi accedere ai
sorgenti: tra l'altro la "confusione" e` anche abbastanza
lecita visto che a tutt'oggi la stragrande maggioranza del
software Open Source e` distribuito con la licenza GNU GPL e
dunque e` Free Software.
Anche se OT non possiamo fare a meno di consigliare a tutti i C
programmers (o aspiranti tali) di questo gruppo la lettura del
libro appena tradotto ed edito in italiano da Apogeo intitolato:
"OPEN SOURCES - Voci dalla rivoluzione Open Source" L. 29.000
Si tratta di una serie di articoli di personaggi fondamentali
di questo movimento (da Stallmann di ggc & emacs, a Wall di
perl, a Linus Torvalds del kernel Linux ecc.)
