Newsgroup: it.comp.lang.c++
Titolo: Esiste nel linguaggio C uno statement analogo al "CVI" del Basic?

Devo utilizzare in un programma scritto in Visual C++ degli archivi
scritti utilizzando un programma in Basic. Conosco perfettamente il
tracciato dei records, ma il problema sorge quando incontro dei numeri
trasformati in strighe create non la funzione MKI$ (o MKI ??). Per
riottenere il numero occorrerebbe la funzione CVI, ma non ho trovato
in C una funzione analoga. La funzione "atoi" non funziona su questo
tipo di stringhe che potremmo definire "simboliche", in quanto si
presentano costituite da simboli. C'č qualche anima buona che ha
qualche suggerimento ????
Grazie in anticipo a chi mi potrą aiutare.
Ciao.          Marco 

Ciao,
Questo newsgroup si occupa del linguaggio C++ in quanto tale, e non di
aspetti specifici di particolari implementazioni. Per questo non e' il
posto piu' adatto per porre domande specifiche come la tua.
Potresti avere piu' fortuna su uno dei seguenti gruppi:
Per Win32 (95, 98, NT): it.comp.programmare.win32
Per Linux:      it.comp.os.linux.development
Per C++Builder: i gruppi borland.public.cppbuilder.*, disponibili sul
                server 
forums.borland.com
 (in inglese)
Grazie,
Nicola Musatti

aspetti specifici di particolari implementazioni.
Questa domanda non era totalmente OT. Se non ricordo male la MKI/CVI
era equivalente a creare/leggere una stringa di 4 byte che conteneva
la rappresentazione binaria del valore intero.
Per leggere il valore di un dato scritto con MKI$ penso che bisogna
allocare un "int valore" e leggere 4 byte dal file piazzandoli in
&valore.
Ovviamente è nettamente platform-dependent.
Luc.

 trasformati in strighe create non la funzione MKI$ (o MKI ??).
Se ricordo bene MKI$ creava una stringa di due caratteri composta
con i byte basso/alto dell'intero 16 bit passato come parametro.
Una soluzione C++ di decodifica di una tale stringa potrebbe essere
   int cvi(const char *buf)
   {
     int l=(buf[0]&255);
     int h=(buf[1]&255);
     int v=l+h*256;
     if (v>32767) v=-65536;
     return v;
   }
La dovrebbe essere leggermente modificata nel caso
che gli interi salvati dalla versione fossero senza segno
(togliere test e sottrazione) oppure fossero a 32 bit.
Ad essere onesti non sono neanche sicurissimo dell'ordinamento
low/high (se fosse errato bisogna scambiare buf[0]/buf[1]).
Nota che un record contenente campi creati con MKI$ non e'
gestibile con le stringhe C (strcpy/strlen e compagni) visto
che possono essere presenti dei caratteri NUL interni.
HTH
Andrea
--
----------------------------------------------------------------
 <\___/>  Andrea        email: agriff at tin dot it
 / . . \  "6502"          irc: _6502_@EFNET#italia
(  (")  ) Griffini   homepage: 
http://www.netservers.com/~agriff
Sent via Deja.com
http://www.deja.com/

    }
Per come la vedo io, il problema maggiore e' dovuto al fatto che il
tutto e' terribilmente platform dependent. Fatto salvo questo basta
una piccola forzatura a livello di cast.
Supponiamo che il sistema basic avesse interi di 16 bit con segno e
che il sistema C++ abbia il tipo corrispondente sott forma di short
int.
O leggi direttamente da file (in modalita' binaria, ovvio) dentro al
tuo short int oppure, se per altri motivi hai letto i tuoi 16 bit in
un buffer puoi convertire semplicemente con una macro o una funzione
inline. L'unico altro problema puo' derivare da un cambio di
piattaforma che implica una differenza di "endianity". Solo in tal
caso bisogna invertire i dati. Ma dato che sappiamo che il sistema di
destinazione e' windows (dato che il compilatore C++ dato e' VC) e
dato che siamo comunque system dependent possiamo stare quasi
tranquilli:
// se il file viene da un programma basic su piattaforma little-endian
(come intel)
inline short int cvi( const char buf[2] )
{
    return *static_cast<const short int*>(buf);
}
// se il file viene da un programma basic su piattaforma big-endian
#include <stdlib.h>
inline short int cvi( const char buf[2] )
{
    short int ret;
    _swab( const_cast<char*>(buf), static_cast<char*>(&ret), 2 );
    return ret;
}
Occhio che quanto sopra vale solo se stiamo parlando di interi a 16
bit.
E solo se il target e' VC (soprattutto nel secondo caso do uso una
funzione MS).
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556