Newsgroup: it.comp.lang.c++
Titolo: Problema con struct

Ho un problemino :
struct Comando{
    char CMD[3];
}mystruct;
------------------------
void Funzione(){
  Comando cmd[2];
  strcpy(cmd[0].CMD,"220");
  strcpy(cmd[1].CMD,"331");
  ShowMessage(cmd[0].CMD);//<------------------Qui sta l'errrore
}
in pratica invece che visualizzarmi solo 220 mi visualizza 220331 tutto
insomma ! Perche   questo ?

 insomma ! Perche   questo ?
Prota il buffer a size=4, altrimenti non c'è spazio per il terminatore 
di stringa.
-- 
Luc

 ha scritto nel messaggio
news:MPG.1aad22af1...@tornado.fastwebnet.it...


Oki mancava , ora tutto oki ! TNX

 ha scritto nel messaggio
news:vwD0c.42580$gk.18...@news3.tin.it...

ora ho un'altro problemino !!!
Come faccio a confrontare un char di 4 (3comando+1carattereterminatore) con
una variabile di tipo string in cui sono memorizzati 4 caratteri ?

Stai parlando delle STL string? Allora hanno un metodo, c_str(), che
restituisce la stringa al loro interno... Poi ci fai quello che vuoi!
Oppure! La string (in realtà basic_string) definisce un compare che ha
l'overload per le cstringhe (char *). Quindi se hai
string a("Pippo");
char *b = "Pippo";
puoi fare un a.Compare(b)
--- bye

Cmq se ti interessano tanto le stringhe, STUDIATELE! Cavolo, non si parla di
un argomento astruso e complesso come capire una mappa RB... Si parla di una
cosa fondamentale come le stringhe! Ti studi quelle 6/7 funzioni essenziali
del C (strcpy, strncpy, strcat, strstr, strcmp, stricmp, strlen) e magari la
classe string. Se usi il Visual Studio ti studi la CString e sei felice!
Se ti vuoi bulleggiare con gli amici poi ti studi le versioni Unicode (wcs*)
e se programmi per windows ti studi le magnificenze di LPSTR, LPCSTR,
LPTSTR, LPCTSTR, LPWSTR, LPCWSTR e cosa sia un TCHAR e tutte le funzioni
_tcs.
Tanto se programmi in C, prima o poi queste cose ti serviranno!

 ha scritto nel messaggio
news:PXD0c.42689$gk.18...@news3.tin.it...

Ecco ho risolto , avevo sbagliato un if e perciò non mi riportava, le
stringhe le so abb. le ho studiate a scuola era solo quell'if maledetto che
mi faceva sbagliare !
Senti un'altra domanda ,sui puntatori adesso!
Che differenza c'è a dichiarare un puntatore cosi : int* p_x    e cosi :
int *p_x ?

 int *p_x ?
Che se lo dichiari in una maniera metà del mondo ti dirà che sei
disordinato, se lo dichiari nell'altra te lo dirà l'altra metà :-)
Io preferisco la seconda notazione, per questo problema:
int *a, b;
a è un puntatore, b è un intero. Mettendo l'asterisco vicino ad a lo fai
notare meglio. Se tu lo avessi scritto così:
int* a, b
allora uno poteva pensare che b era un puntatore.
Però per esempio secondo me se usi la & è terribile.
int &c = b è bruttino da vedersi (questione di gusti)
Se preferisci la notazione int* puoi risolvere non mescolando mai puntatori
e variabili normali sulla stessa riga:
int* a;
int b;
Così è chiarissimo! :-)
Per esempio i parametri di una funzione non hanno questo problema (pensa
come li scrivi... Non puoi scriere
void MiaFunc(int a, b) :-)
--- bye

 ha scritto nel messaggio
news:vbE0c.42748$gk.18...@news3.tin.it...

Grazie ho capito!
Un'altra cosa , se ho char *Buffer = new char[Size];   e in una funzione ho
dichiarato come parametro char *array[];   come mai mi da un errore di
conversione ?
std::string SubStr(char *array[],int start,int n){
----.
----.
----.
}
void main(){
    char *Buffer = new char[Size];
    SubStr(Buffer,0,2);
}
mi da errore come mai ?

Perchè char *array[] è (circa) un char **array!
La tua funzione probabilmente doveva ricevere un char *array o un char
array[] (probabilmente meglio la prima notazione) e restituire una stringa.

 ha scritto nel messaggio
news:dnE0c.42815$gk.18...@news3.tin.it...

ok ora pero ho un'altro problemino
std::string SubStr(char *array,int start,int n){
  int Size=strlen(array);
  int i;
  std::string temp;
  for (i=start;i=start+n;i++){
    temp+=array[i];
  }
  return temp;
}
questa è la funzione, ora il problema è che parte in loop infinito e non so
il perche !
Ho provato con degli showmessage a vedere un po ed ho notato che se gli dico
di visualizzare la locazione array[i] non visualizza niente , se invece gli
dico di visualizzare tutto l'array allora me lo visualizza ! Come mai ?


niente ho risolto scusate la mia coglionagine ! sul for i=start+n invece che
i<=start+n sorry :) !

>   for (i=start;i=start+n;i++){
for (i=start;i<=start+n;i++){
Senti, cmq non pui chiedere tutto in un newsgroup, sai? Se tu pensi al tempo
che perdi tu, alla banda mondiale che consumi etc, ti rendiconto che
"aiutati e il ciel ti aiuta". Usa un debugger, per giove! (spero che non ci
sia un pagano qui che la considera una bestemmia)
--- bye

 ha scritto nel messaggio
news:ZvE0c.42853$gk.18...@news3.tin.it...

lo so lo so sono un tipo che prima chiede aiuto e poi si ricapa da se sono
fatto cosi prevenisco !!!

 insomma ! Perche   questo ?
L'errore e` che insisti a non utilizzare le stringhe, ma tenti di
usare array come se fossero stringhe andando per tentativi.
Se vuoi programmare in C++ usa le stringhe.
Se sei masochista e vuoi scoprire per tenatativi come funzionano gli
array, i puntatori, le funzioni obsolete strxxx, ... fai pure, ma
*NON* POSTARE SUL NG TUTTI I TENTATIVI FALLITI.
        Mauro

 lo so lo so sono un tipo che prima chiede aiuto e poi si ricapa da se
Non andrai molto avanti, allora, nella programmazione... 
-- 
Luc

 }
 std::string SubStr( const char *array,int start,int n)
 {
    return std::string( array + start, n );
 }
M

 ha scritto nel messaggio
news:MPG.1aad3cd14...@tornado.fastwebnet.it...


 Così è chiarissimo! :-)
Te lo concedo, anche se per la perfezione manca uno spazio ;-)
Ciao,
Nicola

 int b;
Io faccio cosi. Soprattuto per mostrare che "a" è di tipo "INTPOINTER".
-- 
Luc

In effetti volendo la soluzione definitiva č quella fatta dalla MS. Usare
tante typedef...
Loro hanno LONG e PLONG (pointer a long), CHAR e PCHAR. E ogni volta che
dichiarano una struttura MyStruct, dichiarano anche il puntatore PMyStruct
(e anche LPMyStruct per motivi storici).
Cosě puoi scrivere:
CHAR a, b;
PCHAR p, q;
E' sicuramente molto chiaro.
La cosa inoltre č sicuramente portabile, perchč č solo una collezione di
typedef.
--- bye

 In effetti volendo la soluzione definitiva è quella fatta dalla MS.
Si, è quella che poi si usa nella programmazione standard Windows... 
-- 
Luc

 fatto cosi prevenisco !!!
preveniscere e' meglio che curare!

Si, è quella che poi si usa nella programmazione standard Windows...
In effetti parlavo di quella :-)
--- bye

...

Personalmente la trovo una porcheria, perche' maschera dietro nomi
artificiali costrutti di base del linguaggio e perche' impone di
includere header di sistema per qualunque stupidaggine.
Insieme alla notazione ungherese sono due fondamentali indicazioni di
come *non* programmare in C++.
Ciao,
Nicola

 come *non* programmare in C++.
In genere quello che dici è giusto, ma se programmi win32/MFC quei tipi 
li DEVI usare. Avevamo un collega che si rifiutava, per "purezza"... 
Avevamo... Ora è sempre un casino mettere le mani nel suo codice... ;( 
-- 
Luc

Nono. E' sbagliato di principio. Usando quel principio la typedef andrebbe
eliminata perchč inutile. Se si puņ descrivere meglio cos'č una variabile,
ben venga (anche se purtroppo non č typesafe).
Riallacciandosi a un altro thread, se chiamiamo LPSTR un char*, sappiamo che
č una sz stringa. Invece un PBYTE č una raccolta di bytes non terminati. La
notazione ungherese invece č un'arma a doppio taglio. Per lo meno il sapere
se una cosa č un puntatore oppure no aiuta tantissimo a sapere se bisogna
usare . o -> .
--- bye

 Avevamo... Ora   sempre un casino mettere le mani nel suo codice... ;(
Non ne dubito. In concreto programmare C++ in ambiente win32/MFC
corrisponde a programmare in un linguaggio *diverso* dal C++ standard,
che semmai assomiglia di piu' al linguaggio descritto da TC++PL 2
Edizione.
In questo caso e' meglio tutto brutto ma uniforme che in parte brutto
e in parte bello.
Ciao,
Nicola

 usare . o -> .
Ma su questo hai gia' il supporto del compilatore. L'informazione
della notazione ungherese e' ridondante e anche questa non garantita
dagli strumenti.
Tra l'altro i typedef se non altro costituiscono un vago supporto al
refactoring, la notazione ungherese lo rende piu' complicato.
Ciao,
Nicola

 dagli strumenti.
Quindi chiamiamo tutte le variabili a, b, c e pippo? Tanto il compilatore sa
cosa sono, non è in grado di controllare se il contenuto è logicamente
associato al nome del contenente...
Se tu vedi un Cliente tu immagini che sia una struct... Ma sarà una struct o
una struct*? 50% e 50% che ci imbrocchi. Se sbagli il compilatore ti
avviserà, ma intanto avrai perso tempo. Se invece avevi Cliente e pCliente
sapevi che pCliente era un pointer a un Cliente (qualunque cosa sia)... Che
poi talvolta gli editor "fighi" ti diano una mano suggerendoti le cose
(spesso sbagliando fra . e ->, soprattutto se ci sono templates, liste e
auto_ptr in giro) è un altro paio di maniche. E' comunque verissimo che
quando io scrivo parpCliente è abbastanza brutto da vedersi (ma avendo un
glossario della mia notazione si evince chiaramente cos'è)... (è un
puntatore a un array di puntatori a Clienti. Questo perchè originalmente era
un arpClienti, ma poi è stato passato a una funzione (e per questioni mie ho
preferito passarlo come puntatore) :-)
--- bye

 una struct*?
Quoto e sottoscrivo. Ad esempio da noi le struct hanno tutte nome 
iniziante per T (es: TClient), come le classi iniziano per C (es: 
CMyClass)...
E' una norma che dobbiamo per forza mantenere, essendo in più persone a 
potersi trovare sullo stesso codice.
-- 
Luc

 e in parte bello.
Preferiamo "LPCSTR" a "const char *", è molto più leggibile... E cosi 
altre decine di esempi...
-- 
Luc

 sapevi che pCliente era un pointer a un Cliente (qualunque cosa sia)...
Poi decidi di cambiare la struttura dei tuoi dati e devi andare a
cambiare il nome a tutti i pCliente. Continuiamo cosi', facciamoci del
male...
Ciao,
Nicola

O magari è una variabile membro contenuta in un header mentre io sto
scrivendo il corrispondente file cpp :-) Per rintracciarla devo "solo"
aprire il file .h, scrollarlo fino alla posizione giusta e guardare.
--- bye

 Preferiamo "LPCSTR" a "const char *",   molto pi  leggibile... E cosi
A me veramente LPCSTR non dice assolutamente niente, mentre const char
* so esattamente cosa significa, e' rigorosamente specificato in due
standard internazionali e se sbaglio ad usarlo (entro certi limiti) il
compilatore me lo dice.
Ciao,
Nicola

 A me veramente LPCSTR non dice assolutamente niente [CUT]
Sono 6 caratteri invece di 12, tra l'altro... ;)
Prova a pensare ad un metodo che accetta 3/4 di questi parametri... :-O
-- 
Luc

 aprire il file .h, scrollarlo fino alla posizione giusta e guardare.
Se e' un membro dato, e' privato. Quindi sei nel codice della classe
corrispondente ed il suo header e' "vicino". Una volta aperto l'header
voglio sperare che qualsiasi dichiarazione di membri dati si trovi
nella prima schermata o poco piu' giu', no?
Altrimenti hai dei problemi a strutturare il codice piu' gravi di
quelli che hai con la nomenclatura ;-)
Ciao,
Nicola

...

Lo so che le API ne sono piene, ma e' colpa mia se in Microsoft non
sanno programmare? :-P
Ciao,
Nicola