Borland C++, jak dziedziczyc??

Mam problem z dzidziczeniem klas:
W ExcelServe.cpp mam cos takiego:

#pragma hdrstop
#include "ExcelServer.h"

//---------------------------------------------------------------------------
//** calss XlApplication:: declarations **//
     XlWorkbooks XlApplication::Workbooks(int byIndex)
     {
       SetWorkbooks(FxlApp.OlePropertyGet("Workbooks"));
       SetThisWorkbook(FxlApp.OlePropertyGet("Workbooks", byIndex));
     };
     XlWorkbooks XlApplication::Workbooks(void) {};
     XlWorkbooks XlApplication::Thisbook(void)  {};
     void XlApplication::Connect()
     {
       HWND wnd = FindWindowA("XLMAIN", 0);
       if (wnd)
        { FxlApp = Variant::GetActiveObject("Excel.Application");}
       else
        { FxlApp = Variant::CreateObject("Excel.Application");
          FxlApp.OlePropertySet("Visible", true);
          FxlApp.OlePropertyGet("Workbooks").OleProcedure("Add");
          SetWorkbooks(FxlApp.OlePropertyGet("Workbooks"));
          SetThisWorkbook(FxlApp.OlePropertyGet("Workbooks",1));
        }
     };
     void XlApplication::Connect(String xlPath)
     {
       HWND wnd = FindWindowA("XLMAIN", 0);
       if (wnd)
        { FxlApp = Variant::GetActiveObject("Excel.Application");}
       else
        { FxlApp = Variant::CreateObject("Excel.Application");
          FxlApp.OlePropertySet("Visible", true);
         Variant book =  FxlApp.OlePropertyGet("Workbooks", "Add");
           book.OleProcedure("Open", xlPath);
          SetThisWorkbook(book);
        }
     };
     void XlApplication::Deconnect(bool Close)
     {
        if (Close) {
          FxlApp.OleProcedure("Quit");
        }
        FxlApp = Unassigned();
     };
         XlApplication::XlApplication() : XlWorkbooks()
         {
           FxlApp = Unassigned();
         };
         XlApplication::~XlApplication()
         {
           FxlApp = Unassigned();
         };
#pragma package(smart_init)

w ExcelServe.h mam cos takiego:

#include <ComObj.hpp>
#include "XlWorkbooks.h"
//---------------------------------------------------------------------------


  class XlApplication: XlWorkbooks
  {
    public:
     void Connect();
     void Connect(String xlPath);
     void Deconnect(bool Close = false);
     XlWorkbooks Workbooks(int byIndex);
     XlWorkbooks Workbooks(void);
     XlWorkbooks Thisbook(void);
        XlApplication();
       ~XlApplication();
    protected:

    private:
     Variant FxlApp;
  };

teraz

#include "XlWorkbooks.h"

//---------------------------------------------------------------------------

//** calss XlWorkbooks:: declarations **//

     String XlWorkbooks::Name(void)
     {
       return ThisWorkbook.OlePropertyGet("Name");
     };
     int XlWorkbooks::Count(void)
     { Variant cos = FxlWorkbooks.OlePropertyGet("Count");
      String nbr = VarToStr(cos);
       return StrToInt(nbr);
   // i tu sie krzaczy. po zainicjalizowaniu FxlWorkbooks zawiera wartość,
   // potem przy odwolaniu sie do funkcji int XlWorkbooks::Count FxlWorkbooks jest puste
  // dlaczego? Co robie nie tak
     };
     XlWorksheets XlWorkbooks::Worksheets(int byIndex)
     {
       FxlSheets = ThisWorkbook.OlePropertyGet("Worksheets");
       ThisSheet = ThisWorkbook.OlePropertyGet("Worksheets", byIndex);
     };
       XlWorkbooks::XlWorkbooks() : XlWorksheets()
       {
         FxlWorkbooks = Unassigned();
         ThisWorkbook = Unassigned();
       };
       XlWorkbooks::~XlWorkbooks()
       {
         FxlWorkbooks = Unassigned();
         ThisWorkbook = Unassigned();
       };

i w *.h

#ifndef XlWorkbooksH
#define XlWorkbooksH
#include <ComObj.hpp>
#include "XlWorksheets.h"
//---------------------------------------------------------------------------
  class XlWorkbooks : XlWorksheets
  {
    private:
    Variant ThisWorkbook,
            FxlWorkbooks;
    public:
           String Name(void);
              int Count(void);
     XlWorksheets Worksheets(int byIndex);
        XlWorkbooks();
       ~XlWorkbooks();
    protected:
     void SetThisWorkbook(Variant AWorkbook)
     {
       ThisWorkbook = AWorkbook;  // i tu przy ustawianiu z XlApplucation nadawana jest warosc
     }
     void SetWorkbooks(Variant AWorkbooks)
     {
      FxlWorkbooks = AWorkbooks; // tu tez przy ustawianiu z XlApplucation nadawana jest warosc
     };
 };
#endif

potem w aplikacji mam gdzies:

  XlApplication App;
  App.Connect();
  int Result = App.Workbooks().Count(); 

i tu w ciele funkcji Count widze ze FxlWorkbooks nie jest zdefiniowany,
ort! analizujac step by step widzxialem jak zostala do niego przypisana warosc (interfejs excelowskiego Workbooks)

Prosze was o info co spierniczylem i co tu jest wbrew logice Borlan C++?

// popraw literówki ! Zacięło Ci się 't' w klawiaturze? - Q

przy korzystaniu z komponentow zewnetrznych, moze sie okazac ze blad byl zupelnei gdzies indziej, spowodowal odlaczenie komponentu (tu: np. zamkniecie excela) i wtedy wszystkie referencje na obiektu z tego komponentu sie resetuja.. dlatego piekielnie wazne jest sprawdzanie wszystkich HRESULTow jakie sie po drodze natrafiaja.. kazdy FAILED(hresult) moze spowodowac odpiecie Cie od excela i "czesc"..

poza tym zwroc uwage ze if (wnd) w obu Connect, jesli wnd zwroci true, to nie sa wywolywane SetWorkbooks i SetThisWorkbook - to jest zamierzone? masz pewnosc ze jak niebeda wywolane to zmienne beda ustawione poprawnie?

Dzieki, ze sie znalazla choc jedna osoba ktora sie tym zainteresowala.
Co do Twojego pytania: wariant z odpalonym Excelem nie jest skonczony, to nie ma prawa zadzialac.
Pytanie moje bardziej dotyczy rozumaowania dziedziczenia i wykorzystania go w celach ja ktu.
Czy sama logika klas dziedziczacych da sie zastosowac jak powyzej?
Dokladnie: Jesli A dziedziczy z B, B z C, to czy konstrukcja:
Cos cos = A.funkcjaB.FunkcjaC ; jest poprawne?, czy to ma byc tylko i wylacznie tak:
Cos cos = A.funkcjaC; pod warunkiem ze A to classA;

A.funkcjaB().funkcjaC() nie powinno Ci sie skompilowac, chyba ze funkcaB zwraca cos co ma metode funkcjaC przypadkiem

jak najbardziej powinno to byc A.funkcjaC(), dziedziczenie mowi ze obiekt dziedziczacy otrzymuje wszystkie pola i metody po rodzicu, to jest dosc lopatologiczne jesli chodzi po podstawowe efekty - takie jakby kopiuj-wklej.