Newsgroup: it.comp.lang.c++
Titolo: VC++ 5.0 ed excel

Vorrei scrivere dei dati in un file excel da un mio programma scritto in
VC++ 5.0.
Qualcuno sa se è possibile fare qualcosa di simile a VB o Delphi 3.0,
cioè accede ad excel via VBa o COM?
Se avete degli esempi mandatemeli.
Grazie

Se avete degli esempi mandatemeli.
Non per Excel, sorry.
Alex

Il file contenente la type library è Excel8.olb contenuto nella
sottocartella 'Office' di Office 97. Non posso scriverti esempi perché con
VC++ 4.0 non è così semplice.
Stefano.

Stefano A. wrote:

 L'ho già importato, ma vc5 importa solo i metodi delle classi, ma non le
variabili membro

Le interfacce COM non hanno variabili membro pubbliche; non capisco bene
cosa tu intenda, anche perché non avendo VC5, non ho mai avuto a che fare
con 'import'.
Stefano.

...

Non esistono, in realta`, "variabili-membro" in nessuna interfaccia
COM; quello che esistono, come "proprieta`", sono in realta` dei
metodi chiamati PutQualcosa e GetQualcosa a fronte di quella che
in VB vedi come una proprieta` chiamata "qualcosa" (il primo sara`
invece denominato PutrefQualcosa se tratta una "object reference",
quella che in VB assegneresti con SET [invece che con LET, o senza
niente come si fa di solito perche` LET e` il default:-)]).
In realta`, VC++5 applica anche un'estensione non-standard del
C++ (molto simile a una analoga di C++Builder 3, a dire il vero, ma
non per questo, a parer mio, meno brutta) per cui puoi "travestire"
le funzioni PutPippo e GetPippo in "assegnazioni" a/da una mitica
e inesistente variabile-membro Pippo.  Suggerisco caldamente di
evitare questo pessimo "zucchero sintattico", che in C++ non si
incastra, secondo me, per nulla bene... (Eiffel, Sather, Visual Basic,
ecc, ci si troveranno anche come pesci in barile, ma C++ no, a
parer mio).
Excel8.olb e` in realta` un poco "difficile" da importare, poiche`
fa uso di altre type-libraries e un paio dei suoi identificatori
vanno in conflitto con macro standard di Windows, comunque
ecco ad esempio una sequenza che funziona:
#import "mso97.dll"
using namespace Office;
#import "VBEEXT1.OLB"
using namespace VBIDE;
#undef DialogBox
#undef RGB
#import "Excel8.olb"
Questo permette di accedere a tutti gli identificatori
definiti nella type library di Excel con l'esplicita qualificazione
Excel::, comunque, naturalmente, si puo` anche aggiungere
un altro "using namespace" (le probabilita` di conflitti di
nomi diventano pero` molto, molto alte... vabbe`, vedete
un po' voi!).
Per mostrare che questo ci fa accedere anche alle
"proprieta`" (presumibilmente cio` che intende Guido
con "variabili membro"), esaminiamo ad esempio la
dichiarazione, nel file Excel8.tlh che ci viene generato
nel nostro directory di output (Debug, o Release, che
sia), della prima interfaccia specifica di Excel, cioe`
Excel::Adjustments...:
struct __declspec(uuid("000c0310-0000-0000-c000-000000000046"))
Adjustments : IDispatch
{
    //
    // Property data
    //
    __declspec(property(get=GetApplication))
    IDispatch * Application;
        [snip]
    IDispatch * GetApplication ( );
Questo significa che, se abbiamo un puntatore ad
una Excel::Adjustments, magari uno smart pointer
di tipo AdjustmentsPtr, possiamo accedere alla
sua proprieta` Application (che e` un puntatore a
IDispatch -- un oggetto) anche attraverso la sintassi
delle variabili-membro, anche se, in realta`, essa
verra` sempre ottenuta attraverso la funzione
GetApplication() -- questo significa quella declspec.
Ad esempio possiamo scrivere le due funzioni seguenti:
    Excel::_ApplicationPtr
    zuppa(Excel::AdjustmentsPtr pAdj) {
        return pAdj->Application;
    }
    Excel::_ApplicationPtr
    panbagnato(Excel::AdjustmentsPtr pAdj) {
        return pAdj->GetApplication();
    }
ebbene, esse saranno *esattamente* equivalenti...
nel senso che viene proprio generato lo stesso,
identico codice macchina per entrambe!
Application e` una property read-only, infatti ci
presenta solo un get=, ma in discorso e` identico
anche per le property read-write, che ci offriranno
anche un put= nella relativa declspec.  Ad esempio,
avendo un puntatore a un'interfaccia Excel::IWindow,
notiamo nella sua dichiarazione, sempre nel TLH,
questi dettagli...:
    __declspec(property(get=GetVisible,put=PutVisible))
    VARIANT_BOOL Visible;
            [snip]
    VARIANT_BOOL GetVisible ( );
    void PutVisible (VARIANT_BOOL RHS );
e quindi, per nascondere la finestra, possiamo
scrivere indifferentemente queste due funzioni:
    void nascondi(Excel::IWindowPtr pWin) {
        pWin->Visible = VARIANT_FALSE;
    }
    void cela(Excel::IWindowPtr pWin) {
        pWin->PutVisible(VARIANT_FALSE);
    }
e, ancora una volta, ottenere la _esatta_,
_assoluta_ equivalenza fra i due casi (lo
stesso identico codice macchina generato).
Alex