Newsgroup: it.comp.lang.c++
Titolo: array bidimensionale char

rieccomi...
come capirete dalla mia prossima domanda, il mio cervello è andato in pappa
e forse la guida di Schildt non è sufficiente a chiarirmi la questione.
Posso fare una dichiarazione del genere?
     char chart[5][2] = {
          {88, italia},
          {34, germania},
          {00, uk},
          {27, francia},
          {07, usa}
          };
In esecuzione mi compaiono simboli anomali, quali frecce, faccine ma non ciò 
che mi
aspetterei.
Lo scopo è leggere un codice isbn, controllare che contenga i primi due 
caratteri della
prima colonna dell'array e associarvi la nazione di pubblicazione.
Si tratta di esercizi di stile, niente di piu.
Spero di non aver mal posto la domanda e di avere un chiarimento da voi 
smaliziati :)
-- 
franz 

che mi aspetterei.
Adoro la faccine.

 };
grazie goodidea,
perň ho provato anche un'altra soluzione, usando solo un puntatore e senza 
struct:
     char *chart[][2] = {
          "88", "1",
          "34", "2",
          "00", "3",
          "27", "4",
          "07", "5",
          "", ""
          };
Funziona ma in stampa mi da come prima riga:
34  1   anzichč   88  1
Non capisco... :(
--
franz 


L'uso dei doppi apici prevede l'aggiunta del carattere '\0'
quindi "88" in verità è '8'+'8'+'\0' = 3 caratteri mentre
il tuo dimensionamento è di due.
Poi controlla che la formattazione di stampa sia corretta.
Bip
-- 
Questo articolo e` stato inviato dal sito web 
http://www.nonsolonews.it

 Non capisco... :(
Non vedo com'hai fatto stampare. Ma penso che:
    std::cout << chart[0][0] << ' ' << chart[0][1] << std::endl ;
deve ben dare "88 1".
Anche: hai detto che leggi Schildt primo. Sai che Schildt è
conesciuto per i suoi errori. Non fedartici.
--
James Kanze (GABI Software)             
email:james...@gmail.com
Conseils en informatique orientée objet/
                   Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, 
+33 (0)1 30 23 00 34


Non vorrei passare per un troll, e so che la vecchia guardia
di questo NG *odia* Schildt (sotto l'egida di 
www.accu.org
),
ma dire che Schildt č conosciuto per i suoi errori ... mah!
Io il problema lo vedo altrove, ma non si perde occasione 
di colpire Schildt eh?! ;)


Non capisco... :(
Usa
char *chart[] =
        "88", "1",
        "34", "2",
        ...
dove chart [0] e' "88", chart [1] e' "1", chart [2] e' "34", etc.

 di colpire Schildt eh?! ;)
Hai ragione, Schildt non e' sufficientemente conosciuto per i suoi
errori, tant'e' che la gente continui a comprare i suoi libri
nonostante siano infarciti di imprecisioni, invece di spendere meglio i
suoi soldi su libri di qualita'.
Il fatto poi che a dispetto dei fatti c'e' ancora chi lo difende e'
particolarmente triste.
Ciao,
Nicola


Mi dispiace di averti rattristato, non era mia intenzione.
Il fatto è che come molti,
ho speso anch'io soldi per i suoi libri.
E la sua capacità di spiegare le cose mi ha giovato tantissimo.
Io non seguo religioni, tanto più che mi piacciono e considero
validissimi anche altri autori (Eckel che ho consigliato spesso p. es.).
Penso che ognuno ha inevitabilmente vantaggi e pecche,
e non me la sento di scagliare alcuna pietra contro Schildt.
Schildt io non lo difendo e non penso che ne abbia bisogno.
Attaccatelo pure, se vi fa star bene, io gli devo molte facili comprensioni, e non solo di C++.
Cercherò di fare meno tristezza in futuro... intanto
facci sognare tu.


 facci sognare tu.
Se cominciate a darmi i soldi che avete dato a Schildt... ;-)
Ciao,
Nicola

 di colpire Schildt eh?! ;)
Vorrei solo aiutare un pincipiante. Se leggi Schildt, finisce a
conoscere tante cose false che non capirai mai perche i suoi
programmi non funzionnano. Schildt sa ben scrivere, ma
pertroppo, scrive dalle cose che non conosce.



eh, chissà dove sono a quest'ora!
Comunque, *non intendo affatto promuovere H.Schildt*, piuttosto
trovo poco elegante (ma non illecito) colpirlo sulla scia 
di un errore che non ha commesso.
Che io faccia tristezza, bé questo mi fa incazzare un pochino,
penso che sia comprensibile no?
Ciao



Caspita è così grave?
A me funzionava tutto quello che ho provato.
E' anche vero che non ho provato tutto. 
Boh!
Ciao


 ho speso anch'io soldi per i suoi libri.
Molti molti anni fa, ho imparato il C su uno dei suoi libri.
Non ricordo di averla trovata un'esperienza cosě terribile.
Kiuhnm

 E' anche vero che non ho provato tutto. 
Vediamo se hai le idee ben chiare.
Che differenza c'č tra
   char s[] = "abcdef";
e
   char *s = "abcdef";
?
Kiuhnm

Kiuhnm ha scritto:

Appena ho un pň di tempo recupero l'antico testo di Schildt e ti rispondo (LOL)


 Appena ho un pò di tempo recupero l'antico testo di Schildt e ti rispondo (LOL)
Allora questa la sbagli :-)
Kiuhnm

Kiuhnm
Lo immaginavo. ;)
Ma piů tardi riporterň lo stesso.
Ciao


pertroppo, scrive dalle cose che non conosce.
Grazie James,
è vero sono principiante e mi serve una mano.
Preciso una cosa: lo Schildt è stato caldamente consigliato dal
docente lo scorso anno accademico. Io l'ho comprato, pagandolo
anche parecchio.
Quest'anno il docente ha optato per un altro testo di cui non ricordo
l'autore, ma io non ho altri 50euro da dar via...quindi...
Per la cronaca, fino ad ora (ottavo capitolo) ho testato i codici di schildt
e...ta dà...molti non girano.
Lo svantaggio: aver speso soldi per un testo inaffidabile.
Il vantaggio: mi scervello per far funzionare i programmi e capire l'errore.
Alla prossima :)
--
franz

Kiuhnm
Immagino che ti riferissi alle idee di Schildt, quindi ora,
anche se bello cotto dopo una giornata di strapazzo lavorativo
causa scadenza (nota l'ora) riporto il pezzo incriminato.
(Ma chi me lo fa fare??? Boh!)
-----------------------
L'inizializzazione di array non dimensionati
[omissis]
Se, nell'istruzione di inizializzazione di un array, non si specificano le dimensioni dell'array, il compilatore C/C++ crea automaticamente un array grande 
a sufficienza per contenere tutti gli inizializzatori presenti. In questo caso si parla di *array non dimensionato*. Utilizzando questo approccio, la 
tabella dei messaggi diviene
char e1[]="Errore di lettura\n";
char e2[]="Errore di scrittura\n";
char e3[]="Impossibile aprire il file\n";
Date queste inizializzazioni, l'istruzione
printf("La lunghezza di %s è %d\n", e2, sizeof e2);
visualizzerà:
La lunghezza di Errore di scrittura è 20
Oltre a essere più comoda, l'inizializzazione di array non dimensionati consente di cambiare i messaggi senza temere di aver dimensionato in modo errato 
l'array.
Le inizializzazioni di array non dimensionati non si limitano agli array monodimensionali. Per gli array multidimensionali si deve specificare tutto tranne 
la dimensione più a sinistra (le altre dimensioni sono necessarie bla bla bla) [omissis]
------
Inizializzazione di puntatori
[omissis]
Un'altra variante del tema dell'inizializzazione è il seguente tipo di dichiarazione di una stringa:
char *p="ciao a tutti";
Come si può vedere, il puntatore p non è un array. Il motivo di questo tipo di inizializzazione risiede nel modo in cui opera il compilatore. Tutti i compilatori C/C++ creano una *tabella di stringhe*, utilizzata internamente dal compilatore per conservare le costanti di tipo stringa utilizzate nel programma. Pertanto, l'istruzione di dichiarazione precedente inserisce nel puntatore p l'indirizzo della stringa *ciao a tutti* che è memorizzata nella 
tabella delle stringhe. All'interno di un programma, p potrà essere utilizzata come qualsiasi altra stringa. Ad esempio il seguente programma è perfettamente corretto:
#include <stdio.h>
#include <string.h>
char *p="ciao a tutti";
int main(void)
{
  register int t;
 
  /* stampa la stringa in avanti e indietro */
  printf(p);
  for(t=strlen(p)-1;t>-1;t--) printf("%c", p[t]);
  return 0;
}
Nel C++ standard, il tipo di una stringa letterale è tecnicamente const char*. Ma il linguaggio C++ fornisce una conversione automatica in char*. Pertanto il programma precedente rimane valido. Tuttavia, questa conversione automatica è una funzionalità su cui è opportuno non fare affidamento quando si realizza nuovo codice. Nei nuovi programmi si deve sempre presumere che le stringhe letterali siano costanti e che la dichiarazione di p nel programma precedente debba essere scritta nel seguente modo:
const char *p="ciao a tutti";
----------------------
Messa così, concordo che ci sia una cappellaccia su
"Ma il linguaggio C++..."
Comunque l'avviso anche se male, lo ha dato.
Mio umile giudizio: esposizione godibile ma imprecisa.
Quindi non lo promuovo, ma nemmeno lo colpisco indiscriminatamente.
Yawn


 Yawn
Sinceramente non ci trovo niente di male.
Nel libro del C non spiegava bene la differenza tra le due cose cosě gli 
utenti cercavano di modificare le stringhe in entrambi i casi. Con 
alcuni compilatori era possibile, mentre altri le salvavano in memoria 
di sola lettura.
Tutto qui.
Kiuhnm

 penso che sia comprensibile no?
Sta solo a te fare in modo che non sia piu' cosi ;-)
Ciao,
Nicola

 ?
Al di la' della comodita' del sizeof sul primo, la la differenza 
principale non e' in che sezione viene allocato il buffer?
Nel secondo caso su qualunque OS moderno scrivere:
*s = 'Z';
Dovrebbe causare un bel segmentation fault, non ho idea tuttavia se e` 
lo standard che prevede questo o se sono semplicemente i compilatori a 
farlo.
Nel GCC dal 4 hanno tolto l'opzione -fwritable-strings quindi mi sa che 
e` lo standard a dirlo :)
Bye,
  Gabry

 e` lo standard a dirlo :)
2.13.4
1. [...] An ordinary string literal has type "array of n const char" and 
static storage duration, [...]
2. Whether all string literals are distinct (that is, are stored in 
nonoverlapping objects) is implementation-defined. The effect of 
attempting to modify a string literal is undefined.
Kiuhnm