» Client Side

[C] – Break, continue, goto ed etichette

Joel — Sat, 10 Oct 2009 09:40:05 +0000

In alcuni casi può essere opportuno interrompere un ciclo, prima della sua conclusione. Per far questo, utilizziamo l’istruzione break

if (x>1)
{
break;
}

Nel caso presentato sopra, non ci interessa continuare ad eseguire il ciclo, se il valore di x è maggiore di 1. In questo caso il ciclo esegui l’istruzione break e si interrompe prima della sua naturale conclusione.

Il continue permette invece di ignorare l’istruzione successiva del ciclo, dopo l’istruzione continue continuando poi ad eseguire il ciclo.

if (x>1)
{
continue;
}
istruzione che viene saltata;
}
ciclo che continua

Come potete vedere dal chiarissimo esempio, è un buon metodo per semplificare il programma senza dover annidare troppo il codice, con condizioni varie.

Veniamo adesso al costrutto goto e alle sue fantastiche etichette. Ho trovato in giro per il web più inviti ad non usare tale costrutto, perché quel che fa può essere ottenuto anche con altri metodi, più corretti. Ciò non toglie che può sempre essere utile conoscerlo, specialmente all’inizio, quando si è più portati a cercare una soluzione più easy ai nostri problemi.

Questo costrutto si usa solitamente nei casi in cui si voglia saltare velocemente da una parte ad un altra. Ad esempio, se abbiamo una condizione che potrebbe verificarsi più volte all’interno del nostro programma e vogliamo richiamarla velocemente, possiamo usare questa sintassi:

for (roba varia)
    for (roba ancora più varia)
          for (roba indefinita) {
          ...omissis...
               if (non trovi gli occhiali)
                    goto etichetta;
          }
    ...omissis...
    etichetta:
         guarda nella custodia

Ora, a parte l’evidente sproloquio, cosa possiamo dedurre dalle stringhe di codice superiori? che nel caso in cui si verifichi la condizione non trovi gli occhiali è cosa buona e giusta guardare nella custodia. Il collegamento fra la condizione e l’azione da compiere è creato dal goto appunto (go to = vai a) che va alla ricerca nel codice successivo, della parola etichetta (la parola in questione può essere la qualsiasi).

Appena riscontra la presenza di una parola identica a quella successiva a se stesso, accoppia le due stringhe e compie l’azione indicata.

That’s all folks!

[C] – Cicli while, for, do-while

Joel — Fri, 28 Aug 2009 10:36:53 +0000

Dopo qualche (tanto) tempo, riprendiamo il ciclo “studiamo C”. Troppo tempo lontani dalla programmazione fa male, com’è che si faceva? uhm…. iniziamo a parlare del while.

Il while ci permette di valutare un espressione. Se l’espressione valutata dal programma è diversa da zero il ciclo prosegue (eseguendo l’istruzione e rivalutando l’espressione), in caso contrario il programma passa a valutare il punto seguente.

while (x>1)
        go home (:-D)

Nel caso sopra citato, il programma valuta se la condizione del while (x=1) è differente da zero. In questo caso, esegue la bellissima funzione appena inventata da me, che invita il programmatore a porre fine alla sua tediosa giornata di lavoro.

E visto che la funzione è verificata, me ne vado a casa (8.15 pm, 05/08).

Rieccomi qui a scrivere (00.06 pm, 11/08). Adesso parliamo dei cicli for.

for (i=1; i < n; i++)

Vediamo di tradurlo in italiano:

I è uguale a uno.
I è inferiore ad n.
Aggiungi un unità ad I (che quindi diventa 2, poi 3, e così via).

A questo punto, il programma ricontrolla che la nostra I sia ancora inferiore ad n, in quel caso aggiunge un altra unità e così via.

Ipotizziamo che n corrisponda a 4. In questo caso il ciclo si blocca appena l’espressione relazionale

i < n

non è più verificata.

E’ un po’ come scrivere

i=1
while (i
A quanto ho capito, è meglio usare il for in caso di cicli semplici, dato che ha il gran vantaggio di mettere tutte insieme le espressioni, all’inizio. Cosa che diventerebbe complicata nel caso di cicli complessi.
Passiamo al do-while (28/08… che articolo sofferto !). La differenza principe fra do-while e while/for sta nel momento in cui si esamina la condizione di terminazione.
Nei casi già discussi, la condizione viene valutata inizialmente, mentre in questo caso, la sintassi usata è questa:
do
         istruzione
while (espressione);
In questo caso prima si esegue istruzione, poi si valuta espressione. Se è vera, si esegue nuovamente istruzione e il ciclo va avanti fino a quando espressione non diventa falsa.

Articoli correlati



[C] – Break, continue, goto ed etichette
In alcuni casi può essere opportuno interrompere un ciclo, prima della sua conclusione. Per far questo,…





Linguaggio C
In questa pagina raccolgo con ordine tutti i miei articoli su C. Lo scopo è di creare una sorta di guida…





[C] – Istruzioni, blocchi, if-else, else-if, switch
In C, così come in ogni altro linguaggio, dobbiamo seguire delle regolette di sintassi quando scriviamo il codice,…





[C] – Altri operatori ed elenco delle precedenze
Altro giorno altri operatori usati in C, non ce la faccio più.
Oggi guarderemo gli operatori condizionali egli…





[C] – Operatori ++, – -, manipolazione dei bit, assegnamento
Sabato ci siamo fermati ad esaminare gli operatori aritmetici, relazionali e logici, oggi guarderemo gli operatori…




	


	Post correlati
	
	[C] – Operatori aritmetici, relazionali e logici (3)
	[C] – Operatori ++, – -, manipolazione dei bit, assegnamento (0)
	[C] – Istruzioni, blocchi, if-else, else-if, switch (0)
	[C] – Dimensioni dei dati, costanti e dichiarazioni (0)
	[C] – C su Linux, primi passi (2)

Testi visibili/invisibili con un click, in Javascript

Joel — Thu, 30 Jul 2009 17:52:41 +0000

Capita di avere delle grosse masse di testo che per vari motivi non si vuole suddividere in più pagine. Un metodo simpatico e veloce per renderle rapidamente visibili o invisibili è usare Javascript.

function visualizza(id){
  if (document.getElementById){
    if (document.getElementById(id).style.display == 'none'){
       document.getElementById(id).style.display = 'block';
    } else{
       document.getElementById(id).style.display = 'none';
    }
  }
}

Questo è il codice da inserire nel nostro hidden.js, che richiameremo all’interno del tag head della nostra pagina, in questo modo:

A questo punto il motore del sistema è pronto, dobbiamo solo richiamare la funzione all’occorrenza. Il successivo codice è portato solo da esempio, dato che può essere semplicemente personalizzato a seconda delle esigenze.

Richiamiamo la funzione:

Il testo che volete

Basterà cliccare su questo link e il testo nascosto apparirà e scomparirà, come se fosse un interruttore.

Adesso, creiamo il contenitore del testo nascosto:

Testo nascosto

Ed il gioco è fatto. Quando cliccheremo su Il testo che volete spunterà fuori Testo nascosto, perchè lo status dell’attributo display passerà da none a block. Nel caso in cui il suo status sia block, al richiamare della funzione cambieremo block in none.

Una cosa importante da segnalare è che nel caso in cui utilizziamo questo metodo più volte nella stessa pagina, dovremo cambiare qualcosina nella struttura, secondo questo esempio:

Al quale ovviamente si accompagnerà un cambiamento, secondo questa falsariga:

E’ inutile spiegare come vanno accoppiate le cose, vero?

[C] – Istruzioni, blocchi, if-else, else-if, switch

Joel — Thu, 11 Jun 2009 09:53:21 +0000

In C, così come in ogni altro linguaggio, dobbiamo seguire delle regolette di sintassi quando scriviamo il codice, altrimenti sarebbe oggettivamente impossibile comunicare al nostro programma cosa vogliamo da lui.

Nello scrivere un espressione, dobbiamo ricordarci di mettere il ; in fondo, in modo da trasformarla in un istruzione. In questo modo,

x = 0;

Per creare un blocco (o istruzione composta) dobbiamo invece raggruppare dichiarazioni ed istruzioni all’interno di parentesi graffe { }. Il contenuto di due parentesi graffe viene letto come una singola istruzione, come un blocco unico. Ad esempio:

{ x = 0;
y = 1;}

Importante, alla fine di un blocco, con relativa graffa } non serve mettere un punto e virgola (facendo un confronto, basti notare che non serve mettere il ; neanche alla fine di un elenco di istruzioni in un CSS, prima della graffa)

L’istruzione if-else ci permette di porre una condizione (if) al verificarsi della quale avremo un determinato comportamento,oppure (else) avremo un comportamento diverso. Di seguito il costrutto base:

if (espressione)
   istruzione1
else
   istruzione2

Se il valore di espressione è diverso da zero, il programma eseguirà l’istruzione1, altrimenti l’istruzione2.

E’ importante ricordare, i compilatori abbinano else al più vicino if che non ne ha già uno assegnato.

Nel caso di istruzioni nidificate, come queste:

if quelchevuoi1
   if quelchevuoi2
   else

il compilatore assegnerà else a quelchevuoi2. E se invece volessimo assegnarlo a quelchevuoi1? dobbiamo utilizzare le parentesi graffe, così:

if (espressione) {
   if quelchevuoi2
      }
else

Il costrutto else-if complica un po’ le cose, dato che aumenta le variabili in gioco e le relative istruzioni. Nonostante ciò è estremamente intuitivo e facile da realizzare, guardiamolo insieme:

if (espressione1)
   istruzione1
else if (espressione2)
   istruzione2
else if (espressione3)
   istruzione3
else
  istruzione4

E così via, si potrebbe continuare mettendo un infinità di else-if, ma per l’esempio attuale bastano ed avanzano questi. La traduzione è la seguente:

se espressione1 è vera esegui l’istruzione1, altrimenti, se l’espressione2 è vera esegui istruzione2, altrimenti se espressione3 è vera esegui espressione 3, oppure, se nessuna delle precedenti espressioni è vera, esegui istruzione4.

L’istruzione switch ragiona in modo simile, ma ha alcune differenze, ad esempio, il seguente costrutto

switch (espressione) {
   case x1
   istruzione x1
   break
   case x2
   istruzione x2
   break
   case x3
   istruzione x3
   break
   default
   istruzione x4
   break
}

significa:

Valuta l’espressione, se è uguale al caso x1 esegui istruzione x1, altrimenti passa a caso successivo (break) e valuta il caso x2, nel caso in cui coincida esegui l’istruzione x2, altrimenti passa al caso x3, se coincide esegui l’istruzione x3. Nel caso in cui nessuna di queste istruzioni coincidano esegui l’istruzione x4 contenuta nel default quindi esci dal costrutto switch.

Questo costrutto è detto a cascata perché ogni volta che finisce di eseguire il codice relativo ad un caso, passa al caso successivo.

E anche per oggi è andata, di questo passo fra solo 2.134.234 giorni circa, avremo finito

[C] – Altri operatori ed elenco delle precedenze

Joel — Wed, 10 Jun 2009 08:52:53 +0000

Altro giorno altri operatori usati in C, non ce la faccio più.

Oggi guarderemo gli operatori condizionali egli operatori di cambio priorità. Ed infine faremo un bel riassunto dei diritti di precedenza dei vari operatori fra di loro, dato che neanche io riesco più a capire chi è che comanda.

Operatore condizionali

?, utilizzato nelle espressioni condizionali, nelle quali il programma verifica la veridicità di una data espressione, assegnandole un valore in caso positivo, assegnandone un altro in caso negativo. Il caso
```
if (espr_1)
    espr_2;
  else
    espr_3;
```
esprime questo concetto. Se la prima espressione è vera lo è anche la seconda, altrimenti è vera la terza. Guardiamolo con dei valori, che è sempre più chiaro:
```
if (x > y)
    k = x;
  else
    k = y;
```
Appunto, se x è maggiore di y, allora k è uguale a x, se invece è minore o uguale, il valore di k sarà uguale al valore di y.

Operatore di cambio priorità

(), probabilmente il più semplice. Come in matematica, il contenuto delle parentesi viene eseguito per primo. Se vogliamo che una porzione della nostra espressione venga eseguita prima delle altre, non dovremo fare altro che racchiuderla nelle parentesi

E ora una piccola tabella per capire chi prevale su chi, dato che di operatori è pieno il mondo, dovremo ben sapere in che ordine il compilatore li leggerà. Ogni riga ha prevalenza sulla successiva e si legge da sinistra a destra, salvo dove diversamente specificato. Gli operatori unari + – & * hanno diritto di precedenza sui loro omonimi binari. In questo elenco ci sono alcuni operatori che non ho trattato, perchè troppo avanzati. Quando avrò iniziato a capirci qualcosa di più, farò un articolo integrativo, parola di lupetto.

N.B. Ho diviso ogni operatore dall’altro, tramite delle graffe { }

{()}  {[]} {->} {.}
{!} {~} {++} {- -} {+} {-} {*} {&} {(tipo)} {sizeof } (da destra a sinistra)
{*} {/} {%}
{*} {-}
{<<} {>>}
{<} {<=} {>} {>=}
{==} {!=}
{&}
{^}
{|}
{&&}
{||}
{?:}                      (da destra a sinistra)
{=} {+=} {-=} {*=} {/=} {&=} {^=} {|=} {<<=} {>>=} (da destra a sinistra)
{,}

[C] – Operatori ++, – -, manipolazione dei bit, assegnamento

Joel — Tue, 09 Jun 2009 09:01:28 +0000

Sabato ci siamo fermati ad esaminare gli operatori aritmetici, relazionali e logici, oggi guarderemo gli operatori di incremento, di decremento, di manipolazione dei bit e assegnamento.

Operatori di incremento

++, aumenta di 1 il valore di una variabile

Operatori di decremento

- -, diminuisce di 1 il valore di una variabile

Possiamo utilizzarli come prefisso (++n) o come suffisso (n++). Utilizzandolo come prefisso, andiamo a modificare il valore di n prima che esso venga stabilito. Differentemente, prima si stabilisce il valore di n e poi lo si aumenta di 1.

Operatori per la manipolazione dei bit

di complemento a uno (unario), ~, converte ogni bit nel suo opposto, 1 diventa 0 e viceversa. Questa qui ~, si chiama tilde e si ottiene con ALT + 126 su Windows e ALTGR + ì su Linux.
AND bit per bit, &, azzera un insieme di bit, tranne l’ultimo valore a destra. Nel caso di confronto fra le due espressioni, mantiene i valori che hanno una corrispondenza. Ad esempio nel confronto fra 00010100 e 00011000, elimina tutti i valori 1, tranne l’unico con una corrispondenza, dando come risultato 00010000.
OR bit per bit, |, serve per impostare un 1 nelle posizioni in cui gli operandi presentano bit con valore 1. Ad esempio nel confronto fra 00010100 e 00011000, da come risultato 00011100, sovrapponendo le due sequenze.
OR bit per bit esclusivo, ^, serve impostare un 1 nelle posizioni in cui gli operandi presentano bit dal valore diverso e 0 dove sono uguali. Ad esempio nel confronto fra 00010100 e 00011000, il risultato è 00001100.
di scorrimento a sinistra, <<, serve per traslare la posizione dei byte spostandosi due volte a sinistra. Ad esempio 00010100 diventa 01010000.
di scorrimento a destra, >>, serve per traslare la posizione dei byte spostandosi due volte a destra. Ad esempio 00010100 diventa 00000101.

Operatori di assegnamento

=, permette di assegnare il valore di un espressione ad una variabile. Sono anche possibili espressioni multiple, ad esempio x = y = k = 1
op, doveop può essere + – * / % << >> & ^ |. Questi operatori permettono di risparmiare del tempo nella scritta del codice, ad esempio x = x +1 equivale a x + = 1 oppure y = y / 2 equivale a y / = 2.

[C] – Operatori aritmetici, relazionali e logici

Joel — Sat, 06 Jun 2009 08:48:38 +0000

Eccoci qui con un altra entusiasmante puntata di “impariamo C in allegria” !

Ok forse non c’è tanta allegria, dato che la mia faccia nel cercare informazioni su C è stata più o meno questa , ma nonostante ciò ce l’ho fatta e i frutti che ne ho raccolto potete vederli qui di seguito.

Oggi parleremo degli Operatori di C, che vanno posti fra due espressioni per operare un confronto di tipo diverso a seconda dell’operatore in uso, di seguito la lista dei vari tipi, ma prima una piccola premessa. In C, 0 equivale a falso (false), tutti gli altri valori equivalgono a vero (true):

Operatori Aritmetici

di Somma binario, +, somma due espressioni (2+2 = 4)
di Sottrazione binario, -, sottrae la seconda espressione alla prima (2-1 = 1)
di Moltiplicazione binario, *, moltiplica due espressioni (2*2 = 4)
di Divisione binario, /, divide la seconda espressione con la prima (2/2 = 1)
Modulo, %, da il resto di una divisione (5%2=1), non applicabile a valori float o double
di cambio segno unario, +, rende l’espressione positiva
di cambio segno unario, -, rende l’espressione negativa

Gli operatori unari + e - hanno la precedenza sugli altri, dopo di loro hanno precedenza gli operatori *, / e % ed infine gli operatori binari + e -

Operatori Relazionali

di Maggioranza, >, ritorna 1 se il valore della prima espressione è maggiore di quello della seconda, altrimenti 0
di Minoranza, <, ritorna 1 se il valore della prima espressione è minore di quello della seconda, altrimenti 0
di Maggioranza o Uguaglianza, >=, ritorna 1 se il valore della prima espressione è maggiore o uguale di quello della seconda, altrimenti 0
di Minoranza o Uguaglianza, <=, ritorna 1 se il valore della prima espressione è minore o uguale di quello della seconda, altrimenti 0

Questi quattro operatori hanno pari precedenza fra di loro e precedenza maggiore rispetto a tutti gli altri operatori relazionali.

di Uguaglianza, ==, ritorna 1 se il valore della prima espressione è uguale a quello della seconda, altrimenti 0
di Disuguaglianza, !=, ritorna 1 se il valore della prima espressione è diverso a quello della seconda, altrimenti 0

Tutti gli operatori relazionari hanno precedenza inferiore rispetto agli operatori aritmetici, che vengono considerati prima durante lo svolgimento dell’espressione. Ad esempio n > 2*2 si legge n > (2*2).

Operatori Logici

and, &&, se la prima espressione è falsa ritorna 0, se è vera procede a valutare la seconda, se questa è falsa ritorna 0, altrimenti da 1.
or, ||, se la prima espressione è vera ritorna 1, se è falsa procede a valutare la seconda, se questa è vera ritorna 1, altrimenti da 0.
di negazione unario, !, se l’espressione ritorna 0 lo trasforma in 1, se ritorna un numero diverso da 0 lo trasforma in 0. In pratica trasforma una cosa vera in una cosa falsa e viceversa.

L’operatore && ha precedenza su ||, mentre gli operatori relazionali e di uguaglianza hanno precedenza su tutti e due. L’operatore !, a quanto ho capito lavora da solo quindi non si parla di precedenza.

Oggi avrei voluto affrontare tutti gli operatori, ma c’è ancora una sfilza di roba e i ho già sfruttato tutte le capacità intellettuali residue. Devo dire che sta funzionando, riesco ad assimilare qualcosa, finalmente. Penso di fare a breve un articolo guida con dentro i link ordinati ad ogni lezione, se così vogliamo chiamarle.

[C] – Dimensioni dei dati, costanti e dichiarazioni

Joel — Fri, 05 Jun 2009 08:29:45 +0000

Dopo giorni di sfrenato cazzeggio mitigati da un po’ di finti lavoro, torno sui miei libri di studio. L’altra volta abbiamo fatto i primi passi con C, su Linux, oggi inizieremo ad addentrarci nel linguaggio e vedere di assimilare i concetti base.

Ma prima una piccola premessa, il C è molto probabilmente il linguaggio più famoso ma ci sono pareri discordanti nella sua facilità di apprendimento per i neofiti. A me è stato consigliato da più persone ed indicato come il migliore per imparare a programmare, ma a quel che leggo nel web, viene indicato come un linguaggio ostico, a causa dell’enorme flessibilità intrinseca che ci permette di scrivere la stessa cosa in un modo infinito di modi. In soldoni, è ben definito perchè ci sono poche istruzioni, ma queste poche istruzioni possono essere combinate in tantissimi modi, quindi è un bel po’ incasinato.

Dopo questa premessa, che avrà ottenuto l’effetto di allontanare i lettori da quest’articolo (ma perchè l’ho fatta?!? ), possiamo iniziare.

Abbiamo quattro tipi di dati fondamentali, con relative dimensioni

char : Grande un byte, contiene un singolo carattere

int : E’ un intero, varia da macchina a macchina

float : E’ un numero in virgola mobile, con precisione singola

double : E’ un numero con virgola mobile, con precisione doppia

A questo possiamo accoppiare agli interi gli attributi, tenendo presente che int può essere di 16 o 32 bit (lo decide il compilatore, valutando autonomamente ciò che ritiene adatto per la macchina su cui opera):

short : indica un interno con dimensione massima pari a 16 bit

long : indica un interno con dimensione minima pari a 32 bit

Ora, non ho mica capito tutta questa necessità di stabilire le dimensioni di quel che scriviamo. Posso presupporre che negli anni ‘70, nei quali è stato scritto C, fosse un grande problema, ma attualmente, pensare in bit è semplicemente assurdo. Ma ormai il linguaggio è questo, quindi tocca impararlo così.

Adesso passiamo alle costanti, come dice il nome si tratta di qualcosa che non muta, ma è fisso.

Ad esempio, con

#define MAXLINE 1000

inserito all’inizio del nostro programma, con modalità che vedremo un altra volta, indica che l’attributo MAXLINE (cioè il numero massimo di righe di imput) ha come valore 1000. Nel nostro programma potremo quindi richiamare direttamente MAXLINE invece che scrivere 1000. In questo modo potremo successivamente modificare i valori del programma con estrema facilità, modificando il valore contenuto nella #define, senza dover andare a modificare una sfilza di valori interni. Il meccanismo è simile a quello dei CSS in pratica.

I C abbiamo delle costanti già impostate, che tramite due (o tre) caratteri ne rappresentano solo uno, andiamo a vederli.

\a : segnale d’allerta

\b : spazio

\f : salto di pagina

\n : newline, a capo

\r : ritorno del carrello

\t : tabulazione orizzontale

\v : tabulazione verticale

\\ : barra inversa

\? : punto interrogativo

\’ : apice

\” : virgolette

\000 : da una a tre cifre in ottale (numeri da 0 a 7)

\xhh : una o più cifre esadecimali (numeri da 0 a 9, lettere da a a f, lettere da A a F)

Abbiamo anche delle costanti di enumerazione, con le quali possiamo stabilire una lista di valori interi costanti, come:

enum mesi { Gen = 1, Feb, Mar, Apr, Mag, Giu, Lug, Ago = 2, Set, Ott, Nov, Dic }

In questo caso abbiamo una seria di valori, a partire da 1. Feb, sarà un 2, Mar, un 3 e così via. Fino ad Ago, che ci permette di definire un altro punto dal quale iniziare a definire le costanti, Set sarà un 3 ad esempio.

Il vantaggio di questa tecnica è che si possono generare valori automaticamente e possiamo verificare i dati, cosa non possibile usando #define.

Veniamo quindi alle dichiarazioni, tutte le variabili devono essere dichiarate prima di essere dichiarate.

Con

int i = 0;

dichiariamo che la variabile i è uguale a 0 (ed è un intero)

oppure che le variabili lower e upper sono degli interi, così:

int lower, upper;

Abbiamo inoltre l’attributo const, che ci permette di dichiarare che il valore di una data variabile non subirà modifiche (le variabili normali vengono solitamente stravolte all’interno del programma).

Ad esempio

const int EXMPL = 1

nel quale dichiariamo che l’intero EXMPL che corrisponde ad 1, è costante.

Bene per oggi ho consumato a sufficienza i neuroni, alla prossima.

[C] – C su Linux, primi passi

Joel — Thu, 28 May 2009 11:20:25 +0000

Oggi ho preso una decisione storica (per me).

Visto che non riesco ad assimilare C, dovrò utilizzare un metodo alternativo. Quando andavo a scuola, il metodo migliore per imparare qualcosa era spiegarla a qualcuno. Per spiegare una cosa, la devi sapere, non c’è storia.

Riprendo quindi quel metodo, facendo degli articoli sul linguaggio C. Apprendimento e spiegazione insieme, insomma. Odio quei manuali pieni di paroloni e scritti in modo che non si capisca niente, cercherò quindi di parlare in modo semplice e chiaro… sarebbe alquanto imbarazzante non riuscire a capire le mie stesse parole.

Cosa serve per poter lavorare in C?

Se siamo in Windows ci serve un compilatore (tipo Dev-C++), se invece usiamo Linux (cosa che consiglio) ci basterà avviare una shell (o Terminale), dato che GCC, il compilatore di Linux, è installato in modo nativo nelle principali distribuzioni di Linux.

Il C è nato su Unix, quindi funzionerà in modo perfetto su Linux e darà qualche problemino su Windows. Nota bene, il problemino implica che quel che funziona su Linux potrebbe non funzionare affatto su Windows. Con C non ci sono vie di mezzo, o funziona o non funziona.

Se avete Windows ma non volete rinunciare a Linux per far girare C, vi consiglio di installarvi VirtualBox mettendoci dentro Ubuntu.

Di seguito qualche comando per iniziare a muoversi su Linux, vi ricordo che vanno digitati nella shell :

ls : per vedere l’elenco dei file presenti nella cartella

cd x : per entrare nella cartella x, ad esempio cd Documenti (vi ricordo che Linux è case sensitive)

./nomefile : per eseguire il file desiderato, ovviamente nomefile va adattato secondo le proprie esigenze

gcc -o nomefilefinale nomefileattuale.c : per compilare il programma in C da noi scritto.

CTRL+D : Per inviare al programma un EOF (end of file) che pone fine alle varie istruzioni

I programmi in C si possono scrivere tranquillamente con un qualsiasi editor di testo. Vanno salvati come nomeascelta.c .

Successivamente vanno compilati e poi aperti, come già indicato. Faccio un breve esempio pratico:

#include 

main()
{
	printf("Ciao\n");
}

Questo programmino serve a stampare a video la parola Ciao,

- la riga n° 1 serve ad includere la libreria base di C,

- la riga n° 3 definisce la funzione main, che deve essere presente in ogni programma.

- la riga n° 5 richiama la funzione printf che serve a stampare a video la parole Ciao, infine creiamo una nuova linea con \n, cioè newline.

N.B. Le parentesi graffe, su Linux, si fanno con CTRL+shift+[ oppure CTRL+shift+] (rispettivamente, graffa aperta e graffa chiusa).

Una volta che l’abbiamo scritto e salvato come ciao.c dobbiamo posizionarci nella cartella in cui abbiamo salvato il file, in questo modo.

Con il comando ls guardiamo dove siamo, successivamente usiamo cd nomecartella per entrare nella cartella contentente il file ciao.c quindi compiliamo il nostro file con gcc -o ciao ciao.c. A questo punto abbiamo un file compilato che si chiama ciao e possiamo eseguire, con il comando ./ciao.

Per lavorare con C, non serve conoscere altri comandi. Nel prossimo articolo inizieremo a guardare le prime caratteristiche del linguaggio.

Creare dei Box flottanti (elemento float)

Joel — Thu, 07 May 2009 09:38:14 +0000

Iniziamo con spiegare cosa fa la proprietà float.

Gli elementi a cui viene assegnata, vengono estratti dal normale flusso degli elementi della pagina e posizionati a destra o a sinistra rispetto al loro elemento contenitore.

Nonostante non seguano le normali regole di impaginazione, la loro presenza viene percepita dagli elementi che li circondano, che si regolano di conseguenza. Facciamo un esempio per capire meglio:

Come possiamo vedere abbiamo un div contenitore

a cui abbiamo attribuito un padding interno di 10 pixel per distanziare gli elementi contenuti, dall’elemento contenitore

.container{
	padding: 10px;
}

e abbiamo definito la sua larghezza e la sua altezza. Fate ben attenzione all’altezza, indispensabile per una corretta visualizzazione. Gli elementi flottanti infatti, non vengono considerati come contenuto e quindi non ridimensionano automaticamente il box contenitore. Si può ottenere un effetto simile inserendo del contenuto non flottante all’interno del box contenitore.

.width150{
	width: 150px;
}

.height50{
	height: 50px;
}

E sei piccoli box, tre a cui abbiamo attribuito un float: left;

.floatleft{
	float: left;
}

e tre a cui abbiamo attribuito un float: right;

.floatright{
	float: right;
}

A cui abbiamo combinato un po’ di margini

.marginbottom1-0{
	margin-bottom: 10px;
}

.marginleft1-0{
	margin-left: 10px;
}

Combinando il tutto, questo è il codice

Qui ne potete vedere l’applicazione, nella quale ho aggiunto dei bordi neri per far meglio capire la struttura.

Il codice originale, senza bordi, lo trovate qui, in .rar pronto per il dowload.