concatenazione di stringhe
Fumo Indiretto
Scusate la domanda forse banale, ma sono un novello con il c/c++ e mi
sto addentrando in un piccolo lavoro per apprendere meglio questi 2
linguaggi (anche se devo esser sincero preferirei dare maggiore
rilievo alla parte c, anche se al momento sto cercando di lavorare
direttamente in c++). Sto facendo degli esercizi legati alle stringhe
e alla loro concatenazione. Esercizio che prevede stringhe composte da
caratteri "esadecimali", nel senso che voglio costruire stringhe non
alfanumeriche ma composte dal corrispondente valore esadecimale della
tabella ascii. Mi spiego meglio, se ad esempio volessi registrare il
numero intero "185", avrei bisogno di 2 byte da memorizzare ovvero
dovrei registrare "B" e "9". Le difficoltà iniziano quando uno di
questi byte è "0". Lavorando con le stringhe , sia come char * che
come oggetti string, mi sono accorto che questo viene interpretato
come un terminatore di stringa, e quindi nel momento in cui faccio
concatenazioni va tutto a carte 48. Secondo voi per risolvere devo
passare per memcopy ovvero gestire le stringhe come un buffer di
memoria? Poi però il problema non rimane quando torno a visualizzare a
video il buffer come stringa troncandomi almeno a video la stringa?
Spero di essere stato chiaro e che possiate indirizzarmi verso una
possibile soluzione al problema. Ovviamente non vi chiedo codice da
implementare direttamente, devo e voglio imparare e se mi passate
direttamente del codice non imparerò mai :), ma solamente delle
indicazioni su come procedere e quale metodologia potrebbe essere +
vantaggiosa da seguire. Non vi nascondo di essere alle prime armi e
che quindi alcuni concetti di base potrebbero non essere molto solidi
in questa esposizione, comunque sia vi ringrazio tutti anticipatamente
per l'aiuto che potrete/vorrete offrirmi e spero di aver esposto in
maniera chiara il problema.
Un saluto
Costanzo
nameci
news:3738c278-64f6-44bc...@l13g2000yqb.googlegroups.com...
>[CUT]
>Esercizio che prevede stringhe composte da
>caratteri "esadecimali", nel senso che voglio costruire stringhe non
>alfanumeriche ma composte dal corrispondente valore esadecimale della
>tabella ascii. Mi spiego meglio, se ad esempio volessi registrare il
>numero intero "185", avrei bisogno di 2 byte da memorizzare ovvero
>questi byte � "0".
>[CUT]
Mi sembra un falso problema. Le stringhe sono un elenco di caratteri. Il
fatto che il tuo carattere e' un codice esadecimale lo sai tu e se ti
occorre lo dovrai trattare come tale nel momento opportuno ma nella stringa
ci finisce il carattere.
Quindi il tuo carattere zero non e' il codice ascii zero ma il codice ascii
48 che non viene interpretato come fine stringa.
Quindi se hai B0 i valori ascii dei corrispondenti caratteri sarebbero 66 e
48.
Se poi la stringa B0 deve assumere, in qualche parte del tuo programma il
valore esadecimale, dovrai convertirlo da carattere a valore, ma a quel
punto sarai fuori dalla stringa e non avrai problemi.
Spero di essermi spiegato perche' io non mi sono capito :-)
--
************** (.)_(.) *******************
Un amico � uno che sa tutto di te e,
nonostante questo, gli piaci
(E. Hobbard)
?manu*
> Lavorando con le stringhe , sia come char * che
> come oggetti string, mi sono accorto che questo viene interpretato
> come un terminatore di stringa,
Per i char* s�, ma per le std::string non mi risulta. Non dovresti avere
problemi ad inserire zeri in esse.
E.
Fumo Indiretto
Intanto grazie per la risposta veloce. Forse mi son espresso male io.
Se devo inserire nel mio vettore un carattere non c'è nessun problema,
ma se devo inserire un intero il problema c'è. Diciamo che per il mio
intero considero solo numeri interi di 2 byte (short int). Quando lo
vado a registrare devo inserire 2 char (appunto 2 byte) nel mio
vettore. Dovrò quindi tradurre i 2 byte dell'intero nei char relativi.
Per farlo utilizzo le 2 macro seguenti:
#define HIGHBYTE(w) ((unsigned char) (((short int) (w) >> 8) &
0xFF))
#define LOWBYTE(w) ((unsigned char) (w))
Con queste ricavo la parte alta e la parte bassa da inserire nel mio
vettore di caratteri. Se il numero che inserisco è minore di 256 (a
cui appunto basterebbe un solo byte x essere registrato) mi ritrovo
con la parte alta tutta nulla (sia come intero che come esadecimale, e
di conseguenza il relativo cast a char mi restituisce un carattere
"null"). Infatti se ho "0"come parte alta, il relativo and bit a bit è
tutto nullo e quindi mi ritrovo con un byte tutto di "zero" e come
risultato il casting a char risulta essere "null". In pratica io
traduco gli esadecimali in caratteri da inserire nel mio vettore per
poterlo trattare come vettore di caratteri e dunque come stringa.
Credo che a questo punto dovrò cambiare modo di trattare la
concatenazione di "stringhe" se voglio considerare ancora il vettore
risultante come tale. Spero che la spiegazione del mio problema sia +
completa ora. Ripeto non voglio del codice x risolvere il problema, ma
consigli. Io stavo appunto pensando di fare la concatenazione passando
x il buffer di memoria (mi faccio un buffer di char in pratica). In
quella maniera sicuro riesco a fare la concatenazione (so da dove a
dove copiare il buffer ad esempio), ma mi rimane comunque il problema
di quando provo poi a stampare a video la concatenazione.
Grazie a tutti per i consigli :)
nameci
>[CUT]
>Forse mi son espresso male io.
No avevo compreso il tuo problema ma non sono riuscito a spiegarmi.
Secondo me il tuo errore consiste nel voler gestire in una struttura dati
creata per contenere caratteri valori che non sono caratteri nel senso
stretto della parola. Se il carattere \0 non posso inserirlo in una char*
secondo me ho solo due strade:
1) Non uso la struttura char*
2) Adatto il valore alla struttura (quello che in modo disordinato ho cercto
di spiegare nel post precedente)
La 1) vuol dire invece di avere un char* usi una struttura int * (o come +
ti aggrada).
La 2) significa non scrivere il valore esadecimale rilevato ma il carattere
per del valore.
Cioe' se hai la struttura char ch[2] e devi mettergli 0B invece di avere
ch[0]=\x0 e ch[1]=\xB
inserisci
ch[0]='0' e ch[1]='B' (valore ascii dello '0' e' 48 quindi non termina la
stringa).
Usando questa seconda modalita' tu potrai inserire nel tuo array qualunque
carattere anche quelli non stampabili al costo di una routin di conversione
in ingresso ed una in uscita dall'array
Ciao
Kan
> ... Ripeto non voglio del codice x risolvere il problema, ma
> consigli. Io stavo appunto pensando di fare la concatenazione passando
> x il buffer di memoria (mi faccio un buffer di char in pratica). In
> quella maniera sicuro riesco a fare la concatenazione (so da dove a
> dove copiare il buffer ad esempio), ma mi rimane comunque il problema
> di quando provo poi a stampare a video la concatenazione.
> Grazie a tutti per i consigli :)
In quel modo, per concatenare non puoi utilizzare strcat e simili, che
considerano il carattere 0 come terminatore.
Se devi o vuoi per forza memorizzare come vettore di char, perch� non
usi un std::vector<unsigned char> ?
Per stampare a video la concatenzazione, poi ti dovresti ciclare in ogni
caso l'intero vettore.
Fumo Indiretto
Comunque sì, alla fin fine devo rinunciare alle fuzioni di
concatenazioni tra stringhe e farmele io "contando" le posizioni.
Grazie a tutti per l'aiuto e i consigli.
> In quel modo, per concatenare non puoi utilizzare strcat e simili, che
> considerano il carattere 0 come terminatore.
> Se devi o vuoi per forza memorizzare come vettore di char, perchè non
?manu*
> Giusto, non ci avevo pensato :)
> concatenazioni tra stringhe e farmele io "contando" le posizioni.
Non capisco perch� ignori il mio suggerimento di usare std::string.
E.
michelangelo giacomelli
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int main(int argc, char** argv)
{
ostringstream a;
a << "testo" << 0 << "000" << 0;
cout << a.str();
}
output:
testo00000