C++ ed HTML [Archivio] - Hardware Upgrade Forum

View Full Version : C++ ed HTML

misterx

18-12-2002, 19:37

ho scritto un programma in C/C++ nel quale sono presenti una miriade di stringhe, redirette su disco di questo tipo:

fprintf(fp,"<body bgcolor=\"#000000\">\n");
fprintf(fp,"<center>\n");
fprintf(fp,"<table border="1">\n");
fprintf(fp,"<tr>\n");
.....................................

queste, sono ancora delle più semplici, molte sono di gran lunga molto più complesse; il risultato è che tra:
codice C/C++/HTML/javascript il tutto diviene alquanto illeggibile e poco manutentabile

non volevo pensare ad un file esterno sul quale salvare il codice HTML o javascipt e poi richiamarlo all'occorrenza, ma ad un qualcosa che rimanga all'interno dell'eseguibile

se avete suggerimenti o esperienze analoghe

grazie 1000 :)

cionci

19-12-2002, 01:38

Un #define ?

#define HTMLHEADER "<body bgcolor=\"#000000\">\n<center>\n<table border=\"1\">\n<tr>\n"

Altrimenti puoi sempre definire una variabile che contiene quel codice...

misterx

19-12-2002, 06:32

la domanda è nata in quanto mi sono chiesto come fanno ad esempio word o excel quando si esporta una tabella o un documento in formato HTML

sicuramente per non perdersi hanno adottato qualche tecnica particolare che rende il codice ancora leggibile

lombardp

19-12-2002, 07:43

Originally posted by "cionci"

Un #define ?

#define HTMLHEADER "<body bgcolor=\"#000000\">\n<center>\n<table border=\"1\">\n<tr>\n"

In più potresti inserire la lunga lista di #define all'interno di un file H, che poi vai a includere dove gli utilizzi. COsì il tuop codice risulta compatto e leggibile, ed il file H facilmente manutenibile.

/\/\@®¢Ø

19-12-2002, 10:42

Non e' piu' semplice un normale

const string s = "blablabla"
oppure un
const char* s = "..."

:confused:

usando il const char* tra l'altro il compilatore e' in grado di ottimizzare il codice come se avessi usato un #define (e senza i rischi del caso)

poi, non sarebbe piu' leggibile usare gli stream ?

misterx

19-12-2002, 16:03

Originally posted by "/\/\@®¢Ø"

Non e' piu' semplice un normale

const string s = "blablabla"
oppure un
const char* s = "..."

:confused:

usando il const char* tra l'altro il compilatore e' in grado di ottimizzare il codice come se avessi usato un #define (e senza i rischi del caso)

poi, non sarebbe piu' leggibile usare gli stream ?

e i doppi apici che ti servono all'interno delle linee HTML?

const string s = "blablabla=\"%s\" pincopallino" :)

cionci

19-12-2002, 16:50

Originally posted by "misterx"

e i doppi apici che ti servono all'interno delle linee HTML?
Quelli servono anche con il define...

misterx

19-12-2002, 19:32

Originally posted by "cionci"

e i doppi apici che ti servono all'interno delle linee HTML?
Quelli servono anche con il define...

questo lo so anch'io, ma l'amico marco se n'era scordato ;)

/\/\@®¢Ø

19-12-2002, 21:33

Per gli apici non e' cosi' facile, visto che e' una cosa intrinseca del c++
due cose semplici che mi vengono in mente:

1- Usare un altro carattere al posto degli apici (ad esempio un apice singolo), che dovra' essere successivamente cambiato. Si potrebbe fare ad esempio buttando l'output su uno stream su stringa e poi mandare la stringa (modificata) allo stream vero e proprio

"<body bgcolor=\"#000000\">\n<center>\n<table border=\"1\">\n<tr>\n"

diventerebbe quindi

"<body bgcolor='#000000'>\n<center>\n<table border='1'>\n<tr>\n"

In alternativa scrivi i caratteri scomodi come costanti e usi quelle:
fp << "<body bgcolor=" << quote << "#0000" << ..
dove
const char quote = '"';

Pero' forse la cosa migliore e' lavorare ad un livello piu' alto, crearsi degli oggettini per le parti piu' ripetitive;
Un qualcosa del tipo

HtmlBody hb;
hb.color = green; ( opportuni typedefs qui )
hb.align = center;
...

out << hb<< text << table << ...

una cosa del genere...
dipende cosa devi fare ovviamente !

misterx

20-12-2002, 19:08

marco, tanto per entrare nel vivo dell'argomento: guarda questa porzione di codice che salva uno scipt; ho idea che nessuna regola sia valida; in pratica è un caos immane

fprintf(fp,"<script language=\"JavaScript\"></script>\n");

fprintf(fp,"<style>");\n");
fprintf(fp,".mio\t{\n");\n");
fprintf(fp,"font-family:Arial;\n");
fprintf(fp,"font-size:12px;\n");
fprintf(fp,"height:21px;\n");
fprintf(fp,"border-width:4px;\n");
fprintf(fp,"border-style:solid;\n");
fprintf(fp,"border-color:#C0C0C0;}\n");
fprintf(fp,"</style>\n");

fprintf(fp,"<body bgcolor=\"#000000\">\n");
fprintf(fp,"<center>\n");
fprintf(fp,"<table border=\"1\" cellpadding=\"5\" cellspacing=\"5\" bordercolor=\"#C0C0C0\" bordercolorlight=\"#C0C0C0\">\n");[/siz]

/\/\@®¢Ø

21-12-2002, 13:39

Una prima cosa che si puo' fare secondo me e' quella di usare gli stream.
Il tuo codice diverrebbe qualcosa del tipo:

fp << "<script language=\"JavaScript\"><!--" << endl
<< "function apri(nomefile)" << endl
<< "{\n" << "nw=window.open('','nwin','top=0 , left=0 , width=' + (screen.width-100) + ',height=' + (screen.height-100));\n" << ...

che alleggerisce gia' un po' ( spariscono tutti i fprintf e relative parentesi
tonde.
Altra cosa: ricordati che puoi concatenare piu' stringhe in modo semplice:

"nw.document.writeln(\"<script>\");\n"
"nw.document.writeln(\"function zp(){\");\n"

e' equivalente a

"nw.document.writeln(\"<script>\");\nnw.document.writeln(\"function zp(){\");\n"

se quindi il codice html e' statico potresti quindi prima scrivere la stringa a
parte e poi stamparla con una unica chiamata
ad esempio

const char* c = "<script language=\"JavaScript\"><!--\n"
"function apri(nomefile)\n"
"{\n"
"nw=window.open('','nwin','top=0 , left=0 , width=' + (screen.width-100) + ',height=' + (screen.height-100));\n"
"nw.document.writeln(\"<script>\");\n"
"nw.document.writeln(\"function zp(){\");\n"
"nw.document.writeln(\"immagine.height = immagine.height + 50;\");\n";

...

fp << c << endl;

Anche in questo caso ottieni perlomeno di alleggerire l'output.

Un'altra soluzione potrebbe essere quella di leggere il codice html da file, dove puoi scrivertelo in modo "tradizionale"

Se invece il codice e' dinamico (e numeroso) secondo me come dicevo
piu' sopra ti conviene aggiungere un po' di astrazione: ad esempio crearti
una struttura dati gerarchica che rappresenti la pagina e i suoi elementi. In questo modo il codice 'sporco' va a finire solo in piccoli oggetti che provvedono alla stampa. Ad esempio una HtmlList a cui puoi aggiungere a runtime gli elementi della lista che ti servono; al momento di stamparla scrivera' da se il codice per la lista e in piu' provvedera' a far stampare gli oggetti che contiene (in modo simile a quanto accade con le Awt o le Swing di Java , se hai presente ).Perderai la visione del codice html ma ti restera' quello della struttura della pagina ( che e' quello che conta penso ). Tra l'altro dovrebbero esserci gia' delle librerie C o C++ che fanno qualcosa di simile ( scommetto si chiameranno libwww o libhtml :D ).

cionci

21-12-2002, 16:43

Basterebbe richiamare il costruttore con i parametri da inaserire al posto dei %s ;)

Ad esempio basterebbe sovrascrivere l'operatore << per dare in output il codice modificato con i parametri passati al costruttore...
Una cosa del genere :

file << HTMLHeader(titolo, commento) << OpenWindowJScript(nomeFinestra, link) << HTMLLink(link, HTMLImg(pathImmagine));

Per fare l'ultima cosa questo bisogna ad esempio sovrascrivere l'operatore di conversine a string...
Una cosa del genere :

#include <iostream>
#include <string>

using namespace std;

class HTMLInterface {
protected:
string txt;
HTMLInterface() { };
public:
virtual operator string() { return txt; };
friend ostream &operator << (ostream &out, const HTMLInterface &html);
};

inline ostream &operator << (ostream &os, const HTMLInterface &html) { os << html.txt; return os;};

class HTMLImg : public HTMLInterface
{
public:
HTMLImg(const string path, const string l, const string h);
};

HTMLImg::HTMLImg(const string path, const string l, const string h)
{
txt = "<img src=\"" + path + "\" width=\"" + l + "\" height=\"" + h + "\" border=\"0\">";
}

class HTMLLink : public HTMLInterface
{
public:
HTMLLink(const string link, const string target, const string onclick, const string body);
};

HTMLLink::HTMLLink(const string link, const string target, const string onclick, const string body)
{
txt = "<a href=\"" + link + "\"";
if(target.length() > 0)
txt += " target=\"" + target + "\"";
if(onclick.length() > 0)
txt += "onclick=\"" + onclick + "\"";
txt += ">"+ body + "</a>";
}

Per provarlo basta una cosa del genere:

cout << HTMLLink("pippo.html", "", "", HTMLImg("ciao.jpg", "100", "200"));

misterx

21-12-2002, 19:05

Originally posted by "/\/\@®¢Ø"

Tra l'altro dovrebbero esserci gia' delle librerie C o C++ che fanno qualcosa di simile ( scommetto si chiameranno libwww o libhtml :D ).

non lo metto in dubbio ma, se per usarle devi leggerti chilometri di documentazione :)

lasciamole a che le ha scritte ;)

/\/\@®¢Ø

22-12-2002, 11:35

cionci ha colto nel segno quel che volevo dire, magari ridefinendo gli operatori di output invece che creando la stringa, rendendo piu' semplice la modifica on-the-fly della struttura.

misterx

24-12-2002, 19:40

sicuramente esiste un metoo ancora + semplice; le classi non mi sono molto simpatiche :D ;)

cionci

25-12-2002, 10:56

Originally posted by "misterx"

le classi non mi sono molto simpatiche :D ;)
Male...molto male ;) E nonostante tutto le usi tutti i giorni :)

misterx

26-12-2002, 09:01

Originally posted by "cionci"

le classi non mi sono molto simpatiche :D ;)
Male...molto male ;) E nonostante tutto le usi tutti i giorni :)

e lo so cionci; ma mi riferivo solo a questo caso in specifico :)

misterx

12-01-2003, 13:01

un esempio banale; non vi sembra un pò macchinoso questo codice per effettuare una semplice conversione?

daccordo che il codice, prelevato su html.it ha la sola funzione di far capire i concetti che stanno alla base della programmazione ad oggetti: ma sembrerebbe che non in tutti i casi rappresenti una comodità :)

/*
* Un semplice programma che converte le lire in Euro
* File Conversione.h
*/

class Conversione
{
public:
Conversione();
~Conversione();

long valore_lira;
float valore_euro;

void ottieni_valore();
float converti_lira_in_euro( );
};

/*
* File Conversione.cpp
*/

#include <iostream.h>
#inclde "Conversione.h"

Conversione( )
{
cout << "Inizio della conversione\n";
valore_lira = 0;
// Inizializzazione della variabile valore_lira
valore_euro = 0.0;
// Inizializzazione della variabile valore_euro
}

~Conversione( )
{
cout << "Fine della conversione\n";
}

void Conversione::ottieni_valore( )
{
cout << "Inserire il valore in lire: " ;
cin >> valore_lira;
cout << endl;
}

float Conversione:: converti_lira_in_euro( )
{
float risultato;
risultato = ((float) valore_lira) / (float) 1936.27;
return risultato;
}

main( )
{
Conversione conv;
conv.ottieni_valore( );
conv.valore_euro = conv.converti_lira_in_euro( );
cout << conv.valore_lira <<
" in lire, vale " << conv.valore_euro << " Euro."
cout << endl;

return(0);
}

cionci

12-01-2003, 13:33

Certo, ma è chiaramente un esempio didattico...

/\/\@®¢Ø

13-01-2003, 13:26

Originally posted by "misterx"

un esempio banale; non vi sembra un pò macchinoso questo codice per effettuare una semplice conversione?

daccordo che il codice, prelevato su html.it ha la sola funzione di far capire i concetti che stanno alla base della programmazione ad oggetti: ma sembrerebbe che non in tutti i casi rappresenti una comodità :)

Questo e' un esempio che mostra perche' un linguaggio che supporti solo la programmazione OO (come Java) nonj e' il massimo. Ci sono cose che risultano migliori fatte in modo procedurale, altre se fatte ad oggetti. Non ha senso costruire un oggetto per fare il lavoro di una funzione (a meno che non ti serva un oggetto-funzione ovviamente :D;) ).

misterx

13-01-2003, 16:08

Originally posted by "/\/\@®¢Ø"

Questo e' un esempio che mostra perche' un linguaggio che supporti solo la programmazione OO (come Java) nonj e' il massimo. Ci sono cose che risultano migliori fatte in modo procedurale, altre se fatte ad oggetti. Non ha senso costruire un oggetto per fare il lavoro di una funzione (a meno che non ti serva un oggetto-funzione ovviamente :D;) ).

pensa che nonostante io programmi in un ambiente completamente ad oggetti, non ne ho mai avuto la necessità di implementarne dei miei: mah...

forse scrivo programmi troppo banali :D ;)

cionci

13-01-2003, 19:16

Originally posted by "misterx"

forse scrivo programmi troppo banali :D ;)
Questo è il problema dei linguaggi con framework completi come il BC++B, Delphi e Java... Si finisce con il far diventare la programmazione ad oggetti un accessorio...ed in pratica si ritorna a programmare in maniera imperativa...
Sinceramente con MFC mi sono trovato a definire molto spesso oggetti derivati da oggetti del framework (è una cosa molto comune, si chiama subclassing) per aggiungerne funzionalità e gestirne i messaggi...

Non perchè scrivi programmi banali (non è detto che un programma non banale necessiti per forza di oggetti), ma perchè probabilmente ciò che scrivi si appoggia principalmente all'interfaccia per cui gli oggetti sono già definiti...

misterx

13-01-2003, 19:24

e allora significa che spremo bene ciò che ho a disposizione; almeno credo, certo, finchè dura cioè: fino a che mi va di lusso

poi magari se ne riparlerà.....

devo ammettere che non è facile slegarsi dalla programmazione procedurale o "top down" del vecchio C; sono nato su questo linguaggio

penso sia solo una questione di mentalità :)

cmq, sto provando ad aggiungere, per curiosità, il metodo "Resize" ad un componente di tipo TImage: ne è sprovvisto

se la storia non diviene troppo lunga inizierò anch'io questa avventura ;)

cionci

13-01-2003, 19:35

Dovrebbe bastare derivare pubblicamente la tua classe da TImage ed aggiungere resize come metodo pubblico...

misterx

13-01-2003, 19:44

e sicuramente potrei chiamare il nuovo metodo Resize() con:

Image1->Resize(320,240);

oppure volendo eliminare una componente nel colore RGB di una immagine potrei scrivere:

Image1->RGB_TieniSolo(B);

etc...etc...

cionci

13-01-2003, 19:48

Sì !!!

misterx

13-01-2003, 19:56

Originally posted by "cionci"

Sì !!!

però, personalizzare altamente un ambiente ha i suoi pro e contro; il primo contro che mi viene in mente è che ti devi produrre documentazione per ricordarti l'uso delle personalizzazioni

sai, lo faccio già tutto il santo giorno ed alla sera divento pigro

sono convinto che se usassi per un pò BCB (magari lo hai già fatto) ti accorgeresti che non è poi tanto male

BCB mi piace in quanto digerisce di tutto, lo trovo un ambiente molto aperto alle personalizzazioni

però ti faccio una domanda per la quale non ho ancora ben colto:
non ho capito che distinzione faccia BCB tra un componente ed una classe, di primo acchito a me paiono la stessa cosa se non chè, un componente possiede una parte grafica, una classe penso di no, nonostante entrambi posseggano metodi proprietà ed eventi: di questi ultimi non ne sono sicuro per quanto riguarda le classi

cionci

13-01-2003, 20:00

Lo scopo principale degli oggetti non è solo la personalizzazione, ma la possibilità di riutilizzare facilmente il codice dell'oggetto...

Non mi sembra di aver detto che non è un buon ambiente, anzi lo apprezzo molto ;)

Sicuramente un componente è una classe, ma è anche un "tasto" da mettere nella toolbar...per poterlo inserire in maniera visuale nell'applicazione... Sinceramente non conoscendo bene l'ambiente non so come si realizzano...

misterx

13-01-2003, 20:07

per la creazione di componenti BCB ti crea un ambiente guidato del tipo:

Nuovo->Componente

hanno lavorato veramente molto bene i signori della Borland, magari avessi scritto io un tale ambiente

eh, ci vogliono altre conoscenze :)

/\/\@®¢Ø

13-01-2003, 21:33

Originally posted by "misterx"

pensa che nonostante io programmi in un ambiente completamente ad oggetti, non ne ho mai avuto la necessità di implementarne dei miei: mah...

forse scrivo programmi troppo banali :D ;)
Piu' che altro dipende dal tipo di programmi che fai. Raramente un "comune programmatore" ha bisogno di crearsi tutta una gerarchia di oggetti, pero' se confronti la difficolta' nell'utilizzare una interfaccia grafica C tipo gtk e una in C++... ;).
Come diceva cionci comunque gli oggetti vanno bene non solo per la personalizzazione. Sono comodi per definire comportamenti generali (ad esempio quando fai una funzione che usa uno stream, va bene con qualsiasi stream, che sia la console, un file, un socket ), e senza necessariamente dover definirne di nuovi
In C++ inoltre sono usati spesso come funzioni in cui si ha bisogno di una "memoria locale" alla funzione stessa

misterx

14-01-2003, 06:37

Originally posted by "/\/\@®¢Ø"

Piu' che altro dipende dal tipo di programmi che fai. Raramente un "comune programmatore" ha bisogno di crearsi tutta una gerarchia di oggetti, pero' se confronti la difficolta' nell'utilizzare una interfaccia grafica C tipo gtk e una in C++... ;).
Come diceva cionci comunque gli oggetti vanno bene non solo per la personalizzazione. Sono comodi per definire comportamenti generali (ad esempio quando fai una funzione che usa uno stream, va bene con qualsiasi stream, che sia la console, un file, un socket ), e senza necessariamente dover definirne di nuovi
In C++ inoltre sono usati spesso come funzioni in cui si ha bisogno di una "memoria locale" alla funzione stessa

però mi sto accorgendo che aggiungendo nuovi comportamenti ad oggetti già predefiniti da altri, sta diventando anche una mia necessità :)

cionci

14-01-2003, 08:59

Se ti interessa vedere le potenzialità degli oggetti....ecco qua un bel link che parla dei design patterns... I design patterns sono linee guida per la creazione di classi e gerarchie di classi che devono espletare alcune particolari funzioni... I diagrammi che vedi nel link sono fatti in UML...

http://home.earthlink.net/~huston2/dp/patterns.html

Ti posso fare un semplice esempio in cui usare una gerarchia di classi è fondamentale...
Pensa di dover fare un software di disegno tipo Corel Draw...
I vari oggetti che puoi emttere sulo schermo saranno generalizzati da una classe drawObject... Tutti i vari oggetti deriveranno direttamente o indirettamente da drawObject...
Ad esempio Ellipse, Text, Rectangle deriveranno direttamente da drawObject...
Circle deriverà da Ellipse... RoundedRectangle (rettangolo con gli spigoli arrotondati) e Box (quadrato) deriveranno da Rectangle...ad esempio da ogni componente puoi far derivare una altro componente che ha l'interno riempito...

In questo modo quando dovrà essere applicata una funzione su un qualsiasi oggetto basterà applicarla su drawObject...

Ad esempio :

void Commands::Remove(drawObject *d, drawPage *p)
{
objData data = p->FindObject(d);
p->RemoveObject(data);
}

Questa stessa funzione andrà bene per TUTTI gli oggetti della gerarchia !!!
Inoltre grazie all'"information hiding" (cioè il tenere private all'interno delle classi le variabili membro) si ha anche una certa indipendenza sull'implementazione di drawPage (posto che anche drawPage potrebbe essere una gerarchia di classi)...
Ad esempio da questa funzione non si vede come vengono memorizzati gli oggetti...potrebbe essere una lista, uno stack (utile in questi casi, perchè per un buon 50% dei casi si andrà a lavorare sull'ultimo oggetto creato) o un vettore dinamico...

misterx

14-01-2003, 19:18

moooolto interessante, altrochè se mi interessa, se può semplificarti la vita :)

quando hai parlato di "subclassing" o termine similare è la medesima cosa di "discendenza"?

oppure "discendenza" è un termine usato per indicare che una proprietà o metodo che appertengono si ad un oggetto ben definito ma che per similitudine può essere usato anche per altri tipi di oggetto?

pardon se la domanda è un pò strana :)

cionci

14-01-2003, 19:37

Il subclassing è la derivazione di un oggetto del framework per aggiungerci funzionalità...
Discendenza non l'ho mai sentito dire...
La classe derivata dall'oggetto del framework ne eridita dati e metodi (a seconda del tipo di derivazione)...

misterx

14-01-2003, 19:41

Originally posted by "cionci"

Il subclassing è la derivazione di un oggetto del framework per aggiungerci funzionalità...
Discendenza non l'ho mai sentito dire...
La classe derivata dall'oggetto del framework ne eridita dati e metodi (a seconda del tipo di derivazione)...

più propriamente "descendant"; la documetazione di BCB è strapiena di questo termine e inizio a pensare che sia la medesima cosa di "derivata" come sostieni tu :)

cmq, mi sto muovendo: con calma ma mi sto muovendo ;)