Behandlung der anonymen Methoden von Delphi in C++

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Behandlung von Delphi-Features in C++Builder - Index


In diesem Thema wird beschrieben, wie anonyme Delphi-Methoden in C++-Code behandelt werden.

Implementierung von anonymen Delphi-Methodentypen

Delphi implementiert anonyme Methodentypen (auch Methodenreferenzen genannt) über ein Interface, das eine Invoke(...)-Methode implementiert.

Daher wird eine Methode, die einen Methodenreferenzparameter in Delphi übernimmt, für C++ als eine Methode bereitgestellt, die ein Interface übernimmt. Hierzu ein Beispiel:

interface

type
    TFilterPredicate = reference to function(const Path: string;
        const SearchRec: TSearchRec): Boolean;
// …

class function GetFiles(const Path: string; const Predicate: TFilterPredicate):
    TStringDynArray; overload; inline; static;

Im Folgenden finden Sie die C++-Header-Datei, die RAD Studio für den obigen Quelltext bereitstellt:

typedef System::DelphiInterface<TFilterPredicate> _di_TFilterPredicate;
__interface TFilterPredicate  : public System::IInterface 
{
    virtual bool __fastcall Invoke(const System::UnicodeString Path,
        const System::Sysutils::TSearchRec &SearchRec) = 0 ;
};
// …
static System::TStringDynArray __fastcall GetFiles(const System::UnicodeString
    Path, const _di_TFilterPredicate Predicate)/* overload */;

Wie oben gezeigt, wird TFilterPredicate für C++ als Interface bereitgestellt. In C++-Code, der eine Funktion oder eine Member-Funktion als einen Methodenreferenzparameter festlegt, muss der Parameter nach einem Interface angegeben werden, das die Invoke()-Methode bereitgestellt.

Behandlung von anonymen Methodentypen in C++

Verwenden eines Lambda-Ausdrucks

Wenn Sie einen durch Clang erweiterte C++-Compiler verwenden, können Sie einen Lambda-Ausdruck überall dort verwenden, wo eine Delphi-API eine anonyme Delphi-Methode erwartet. Die DelphiInterface-Klasse wird automatisch zu einem Lambda-Ausdruck konvertiert.

Zum Beispiel:

#include <System.hpp>
#include <System.IOUtils.hpp>
#include <iostream>
 
int main()
{
  String ext(".cpp");                   
  TStringDynArray files = TDirectory::GetFiles(TDirectory::GetCurrentDirectory(),
                          [ext](const String Path, const System::Sysutils::TSearchRec &SearchRec) -> bool
                          {
                            return ExtractFileExt(SearchRec.Name) == ext;
                          });
  std::cout << "Found " << files.Length 
            << " files with ext: '" << AnsiString(ext).c_str() << "'\n";
  for (int i=0; i<files.Length; ++i)
    std::cout << AnsiString(files[i]).c_str() << std::endl;
}

Verwenden eines Funktors (Funktionsobjekts)

Eine C++-Template kann zum Kapseln eines Interface, das eine Invoke()-Methode bereitstellt, verwendet werden.

Der folgende C++-Code zeigt ein Beispiel einer Template, mit der C++-Methoden oder Member-Funktionen als Methodenreferenzen an Delphi übergeben werden können:

#include <System.hpp>
 
enum _DummyType{};      // Parameter used as default
 
template <typename INTF, // Interface with Invoke
          typename F,    // Functor type
          typename R,    // Return type
          typename P1 = _DummyType,  // Param #1
          typename P2 = _DummyType,  // Param #2
          typename P3 = _DummyType,  // Param #3
          typename P4 = _DummyType,  // Param #4
          typename P5 = _DummyType>  // Param #5
class TMethodRef : public TCppInterfacedObject<INTF>
{
private:
  F callback;
public:
  TMethodRef(F _callback) : callback(_callback) {}
  INTFOBJECT_IMPL_IUNKNOWN(TInterfacedObject);
 
  R __fastcall Invoke(P1 p1) {
    return callback(p1);
  }
  R __fastcall Invoke(P1 p1, P2 p2) {
    return callback(p1, p2);
  }
  R __fastcall Invoke(P1 p1, P2 p2, P3 p3) {
    return callback(p1, p2, p3);
  }
  R __fastcall Invoke(P1 p1, P2 p2, P3 p3, P4 p4) {
    return callback(p1, p2, p3, p4);
  }
  R __fastcall Invoke(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) {
    return callback(p1, p2, p3, p4, p5);
  }
};

Der folgende Code zeigt, wie mit der oben genannten Vorlage GetFiles aufgerufen wird:

#include <System.IOUtils.hpp>
#include <iostream>
 
struct Filter {
  Filter(String _ext) : ext(_ext)
  {}
  bool operator()(const System::UnicodeString, const System::Sysutils::TSearchRec &SearchRec) {
    return ExtractFileExt(SearchRec.Name) == ext;
  }
  String ext;
};
 
int main()
{
  typedef TMethodRef<TDirectory::TFilterPredicate,
                     Filter,
                     bool,
                     const System::UnicodeString,
                     const System::Sysutils::TSearchRec&> MyMethRef;
  String ext(".cpp");                   
  TStringDynArray files = TDirectory::GetFiles(TDirectory::GetCurrentDirectory(),
                          TDirectory::_di_TFilterPredicate(new MyMethRef(Filter(ext))));
  std::cout << "Found " << files.Length 
            << " files with ext: '" << AnsiString(ext).c_str() << "'\n";
  for (int i=0; i<files.Length; ++i)
    std::cout << AnsiString(files[i]).c_str() << std::endl;
}

Siehe auch