Newsgroup: it.comp.lang.c++
Titolo: concatenazione di stringhe

Salve a tutti.
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

[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) 

 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.

Ciao
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 :)

[CUT]
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


 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.

 Se devi o vuoi per forza memorizzare come vettore di char, perchè non


 concatenazioni tra stringhe e farmele io "contando" le posizioni.
Non capisco perch� ignori il mio suggerimento di usare std::string.
E.

usa uno string stream
#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