Newsgroup: it.comp.lang.c++
Titolo: String Drid con lettere

Salve,
devo costruire una griglia con dentro, in ogni singola cella, una singola
lettera, tutte appartenenti ad una stessa stringa.
Esempio:
Stringa = "Ciao mamma";
la griglia sarà:
_______________________________
|  C |  i  |  a  |  o  |    |  m  |  a  |  m  |  m  |  a  |
............
Spero sia chiaro.
Riccardo

...


 questo algoritmo č sicuro non dovresti incontrare bug
La prossima volta prova a far girare i programmi prima di inviarli. E
magari sforzati di correggere questo e di inviarci la versione
funzionante. Ok?
EMG


Comunque ecoti il codice migliorato non l'ho testato perchč no ho tempo di
testarlo pero dovrebbe andare bene:
 int strlen(char* pchar, char EOS ='\0'/*Caratere di fine riga*/);
 int strlen(char* pchar, char EOS /*Caratere di fine riga*/)
 {
     int id=0 ;/* numero di carateri carateri*/
     for(id=0; pchar[id]!=EOS; id++);/*deve esistere un caratere di fine
     riga se non il ciclo gira all'infinito*/
     return id;
 }
char* strGriglia(char* pchar, char csep='|'/*Caratere separatore*/);
char* strGriglia(char* pchar, char csep/*Caratere separatore*/)
 {
        char EOS='\0'; /*Caratere di fine riga che*/
       int id=0, count=strlen(pchar, EOS)/*strlen(pchar)*/;
       char* mpchar =pchar;// uso una coppia locale per sicurezza
           mpchar[id]=csep;
     for(id=0;id<count;id++)
     {
         mpchar[id]=csep;
         mpchar[id+1]=pchar[id];
     }
     mpchar[id+1]=EOS;
     return mpchar;
 }
anche questo codice e da provare e da adattare alle proprie necessita
uso cha* perchč non č detto che in un compillatore esista il tipo string al
meno a me non risualta. anche perchč nell'ANSI C++ non č mai stato
dichiarato l'obligo di implementare un qualche tipo stringa.
se non č cosi fatemi sapere.
ciao 
Ri...@euromedia.it

se non è cosi fatemi sapere.
Non esiste un "ANSI C++": l'American National Standards Institute (ANSI)
sancisce invece lo standard "ISO C++" (ISO, International Standards
Organization, raggruppa tutte le organizzazioni nazionali come ANSI ecc).
Lo standard ISO per il linguaggio C++ e` stato approvato a Luglio 1998,
e, come prevedibile visto che da molti anni questa feature era presente
nei draft (bozze) dello standard, comprende anche una classe stringa
("#include <string>" per accedervi; e` denominata "std::string" poiche`
vive nel namespace "std").
Qualunque compilatore ragionevolmente recente implementera` dunque
questa classe; cio` vale, in particolare, per Visual C++ a partire dalla
versione 4.2, GCC e suoi derivati (egcs, djgpp, ecc) a partire dalla
versione 2.7 (all'epoca senza la "std::" poiche` non supportava allora
i namespace), Borland a partire almeno da C++Builder 1 (ma mi pare
anche il precedente Borland C++ 5?), Watcom mi sembra a partire
dalla versione 11.  Per compilatori disperatamente obsoleti e` pur
sempre possibile provare a trovare in rete, scaricare, e istallare, varie
versioni gratuite di questa classe (ed altre classi della libreria,
predecessore di quella standard del C++, detta all'epoca "STL"),
ma conviene sicuramente fare l'upgrade del proprio compilatore (o,
magari, passare all'ottimo e gratuito egcs 1.1.1, disponibile dalla rete
per quasi tutte le piattaforme).
Alex

 se non è cosi fatemi sapere.
Il tipo std::string fa parte dello standard ISO C++, e i
compilatori sono tenuti ad averlo. 
I compilatori vecchi pero' sono senza, oppure hanno qualche
classe String non standard.
Una possibile soluzione con std::string
  std::string
  griglia( const std::string & str, char sep = '|' )
  {
    std::string grid( 1, sep );
    for (std::string::size_type p = 0; p < str.length(); ++p) {
      grid += str[p];
      grid += sep;
    }
    return grid;
  }
	Mauro

Signori miei grazie dei vostri consigli ma io prima di oggi non ho mai
sentito parlare di tipi string per il c o il c++( Escluso la classe CString
e i relativi riferimenti pero quetsa classe fa parte delle MFC. i
compilatori gli IDE che ho usato per dos sonno BC31 e GCC(RHIDE) che ho
scaricato da internet circa 1-2 anni fa)anche perchč nelle documentazioni
che ho a disposizione non viene citato nessuna class o tipo e ho letto piů
di 10 libri per il C, il C++ e il VC++. Comunque i compilatori che usavo io
era gia tanto se ti gestivano la mem e gli unici tipi presenti erano
integer, long, double, char e i relatici signed, unsigned, far e near. senza
nessua funzione per la gestione delle stringhe erano compilatori free che si
scaricava dalle bbs non so se rendo l'idea.
comunque usando il VC++ 6.0 o il 5.0 quell'algoritmo puo venire trasformato
in:
CStrin strGriglia(CString strValue, char csep/*Caratere separatore*/)
{
    strValue.TrimLeft();/*Tolga evaentuali spazi inutili dai lati*/
     strValue.TrimRight();/*Tolga evaentuali spazi inutili dai lati*/
       char EOS='\0'; /*Caratere di fine riga che*/
       int id=0, count=strValue.Len();/* Leng() non mi ricordo*/
     CString strReturn =" ";/*L astringa che verra restituita*/
     strReturn[id]=csep;
     for(id=0;id<count;id++)
     {
         strReturn[id]=csep;
         strReturn[id+1]=pchar[id];
     }
     strReturn[id+1]=EOS;
     return strReturn;
}
ciao 
Ri...@euromedia.it

 se non č cosi fatemi sapere.
Infatti non č cosě: il tipo 'string' č parte integrante dello standard
ISO C++ ed č veramente comodo.
EMG

 }
Continui a riportare codice con sempre gli stessi errori. Basta, ci
rinuncio... :-(
EMG

molto positiva che la dichiarazione e la definizione siano diverse.
Non sara` molto positiva, ma e` obbligatoria a norma di standard ISO: il
valore di default non puo` essere ripetuto, dev'essere presente una sola
volta (tipicamente e` nella dichiarazione della funzione).
Alex

questo esempio di codice dovrebbe andare bene
comunque il principio č buono si dovra solo adatare ha le proprie necessita
ad esempio invece di usare char* si protebbe usare una classe che gestisce
le stringhe
avverto che questa versione se eseguita da dei problemi percč i puntatori
non sonostati gestiti al meglio buona fortuna.
PS: appena lo provo vi mando un possibile eseguibile.
Ciao 
ri...@euromedia.it
char* strGrid(const char* pc)
{
 int id=0,count=strlen(pc), idx=0;
 char* mpchar=" ";
 char ch=' ';
 mpchar[idx]='|';//Prima sbarra
 for(id=0; id<count; id++)
 {
  ch=pc[id];
  switch(ch)
  {
   case 'a':ch=' ';break;// possibile controllo sui carateri
   case 'e':ch=' ';break;
   case 'k':ch=' ';break;
   case 'g':ch=' ';break;
  }
  mpchar[++idx]=ch;//Incremento e aggiungo lettera
  mpchar[++idx]='|';//Incremento e aggiungo |
 }
 mpchar[++idx]='\0';//Caratere di fine riga
 return mpchar;
}
void main(void)
{
 clrscr();
 //char* pctmp="Eureka Gente!!";
 char* pret="Hello Word";
 pret=strGrid("Eureka Gente!!");
 printf("\n%s",pret);
 getch();
 delete pret;
}

 volta (tipicamente e` nella dichiarazione della funzione).
Beh, sembra che abbia detto l'ennesima corbelleria. Ma qual'č la
motivazione che ha spinto gli standardizzatori ad optare per questa
scelta?
EMG

...
    [snip]

Vedi Stroustrup, "Design and Evolution of C++", un testo fondamentale
per chi voglia capire le motivazioni che stanno dietro le scelte di
progetto del C++ (non e` aggiornato al processo di standardizzazione,
ma tante scelte, come questa, lo predatano [erano gia` presenti
nell'Annotated C++ Reference Manual, ARM, che ha funto da documento
di base per il processo stesso di standardizzazione]).
Riassumendo...: questo e` uno dei vari casi in cui, se si volesse
permettere al programmatore di ripetere, con ridondanza, certe
informazioni, si dovrebbe garantire che esse siano ripetute "in
modo eguale".  Ma, cosa significa "eguale"...?  La nozione e` ben
definita per i *tipi* (e per "ben definirla" prende parecchie delle
pagine piu` mattone-sullo-stomaco dello Standard:-), ma non
necessariamente per i *valori*.  Ad esempio (se, per assurdo,
fosse ammessa la ripetizione dei valori di default):
int pippo(int);
void pluto(int x=pippo('c'));
int pippo(char);
void pluto(int x=pippo('c')) { }
Qui, il buonsenso ci dice che il valore di default per il
parametro x nella dichiarazione e definizione della funzione
pluto NON e` eguale -- pur essendo esattamente la stessa
sequenza di token (in realta`, anche di caratteri!) -- perche`
"sono DIVERSE funzioni pippo che debbono venire chiamate
per fornire il valore di default": secondo la dichiarazione, la
pippo(int) [unica in scope a quel punto, e accettabile] ma
secondo la definizione, la pippo(char) [miglior match per
l'overload-resolution].
E queste, sono "eguali"...?
void pluto(int x=4);
void pluto(int x=2+2) {}
Il buon senso dice di si`, ma bisogna trovare una formulazione
che lo esprima con precisione; e cosa fare per:
void pluto(double x=3.0/2.0);
void pluto(double x=1.5) { }
visto che nessuna regola del linguaggio C++ garantisce che
3.0/2.0 faccia *ESATTAMENTE* 1.5...?
Stroustrup decise che definire e codificare rigorosamente
cosa significa per due valori di default, espressi rispettivamente
in dichiarazione e definizione, "essere eguali", era di gran
lunga piu` complesso di quanto fosse ragionevole "pagare"
per un "beneficio" (ammettere la ridondanza) minuscolo e
discutibile (mentre la stessa nozione di eguaglianza per i
_tipi_ e` assieme piu` semplice, non esistendo "equivalenze"
un po' nebulose come per i valori, e molto piu` importante,
poiche` indispensabile per chiarire con precisione una parte
del meccanismo di risoluzione di overload; e quindi, quella
c'e`).  Ammettere la ridondanza SENZA controllare
l'eguaglianza avrebbe fatto piu` male che bene, producendo
un "falso senso di sicurezza".  E quindi, in C++, i valori di
default degli argomenti rientrano nella "One-Definition Rule"
("ODR") che e` cruciale per mantenere sufficientemente
"semplici" (lo so che non sembra...!-) cosi` tante parti del
linguaggio.
"Non sembra", come dicevo, vista la complicazione astrusa
del linguaggio, ma in C++ ha avuto un suo peso ANCHE la
possibilita` di dare una definizione sufficientemente precisa,
semplice, completa, rigorosa, ecc ecc, di questo o quell'altro
concetto, o costrutto; parecchie cosette sono state omesse
o anche tolte per la difficolta` di definirle alla perfezione (e`
per questo, secondo me, che Ada e` ancora "in corsa" nella
gara di "linguaggio piu` complicato del mondo": pur non essendo
in realta` "del tutto" altrettanto ricca e completa del C++, Ada
e` stata progettata con meno attenzione alla [relativa]
semplicita`, per cui comprende anche ad esempio feature
superficialmente attraenti [ma troppo complicate da definire
con precisione rispetto a modesti benefici] come l'overload
sul tipo _di ritorno_ da funzioni, e quindi, la sua complessita`
ne risulta ingigantita).
Alex

>> > > int strlen(char* pchar, char EOS /*Caratere di fine riga*/)
Questo codice non da lamentele da parte del compilatore perchč il valore di
default viene definito a livello della dichiarazione tenendo presente che le
dichiarazione devono essere inserite nel file header.
Comunque il mio compilatore che č VC++6.0 mi darebbe erore se io ridefinisse
il valore di defaulth nell'efettiva funzione infatti mi da:
I:\DWorkspace.cpp(33) : error C2572: 'CDWorkspace::CDWorkspace' :
redefinition of default parameter : parameter 1
        i:\classes\utils\06-02-1999\dbmdbutils\dworkspace.h(17) : see
declaration of 'CDWorkspace::CDWorkspace'
quindi a me sembra pił tosto strano che il tuo compilatore accetti che tu
ridefinisca il valore di defaulth in un altro file.
Da quello che so io non č possibile definire 2 volte un valore di dafaulth
per una funzione se non altro perchč non sarebbe pił di dafaulth che ne
pensi?
Ha visto le modifiche che ho fatto per la generazione della griglia? che ne
pensi?
io devo ancora provarlo se mi sai dire qualcosa mi faresti di aiuto.
Grazie.
ciao 
Ri...@euromedia.it

ridefinisca il valore di defaulth in un altro file.
In questo caso, come ho gia` spiegato, VC++6 e` in piena aderenza
con lo standard; e` dunque l'altro compilatore che ha qui una estensione
non standard (e` una *violazione* dello standard, da parte dell'altro
compilatore, se non da` almeno un warning sul fatto che questo codice,
con default ripetuti, non e` portabile; i compilatori C e C++ derivati da
gcc [djgpp, egcs, ecc] tipicamente obbediscono allo standard solo se
chiamati con parametri -Wall -pedantic -ansi).
Alex

 Riassumendo...: [...]
Grazie per la esauriente spiegazione.
EMG

> Riassumendo...: [...]
?????????
ciao 
Ri...@euromedia.it

 ridefinisca il valore di defaulth in un altro file.
No, infatti non lo accetta. Ho già chiarito in un messaggio precedente
di essermi sbagliato.
EMG

 spiegazioni.
No, perfettamente chiaro, grazie.
EMG
PS. Di dove sei? Non sei italiano, vero?

PS. Di dove sei? Non sei italiano, vero?
Giusto sonno Zairese(o congolose dirsivoglia)
Ri...@euromedia.it

