Hallo Freunde,
neues Problem mit der Bitte um Rat.
Enstsprechend dem tutorial: https://community.embarcadero.com/bl...g-delphi-and-c

Möchte ich jetzt ein integer array einer C++ routine übergeben. Da ja in Delphi Pascal man das so macht:

markieren

Delphi-Quellcode:

type
  Tinputvec = array of integer;

..

  private
    { Private declarations }
   procedure Split(Delimiter: Char; Str: string; ListOfStrings: TStrings) ;
   function readTTSetting(): Tinputvec ;

habe ich jetzt das Problem, dass in C++ die Typdef von

markieren

Code:

std::vector <int>

nicht dem delphi type Tinputvec übereinstimmt.
Wie kann ich auf C++ Seite auch dort den Type Tinputvec verwenden oder casten?

Danke
Walter

Geht das nicht damit?

Ich will kein Miesmacher sein, aber du darfst wirklich nicht zu viel erwarten. Der std::vector ist eine eigene C++-Klasse, kein Array. Der vector<> ist in der Delphi-Welt noch am ähnlichsten zu einer TList<> aber nicht dasselbe!

Wenn du mit Delphi-Code interagieren willst kannst du kein Standard-C++ durchhalten sondern musst ständig Klassen und Strukturen aus der Delphi-Welt verwenden. Das angesprochene DynamicArray<> ist ein Beispiel dafür. Das gibt es nur in der Borland/Embarcadero-Welt...

Wenn deine C++-Routine fest einen std::vector<> erwartet und du daran nicht rütteln kannst müsstest du dir eine Zwischenroutine bauen welche z.B. ein DynamicArray<> entgegennimmt und daraus dann einen std::vector<> macht um diesen dann endlich in die Routine reinzustecken...

Danke Ihr beiden, jetzt weiß ich mehr doch hab noch nicht die Lösung und bin am Knobeln.
Melde mich:

Vielleicht kannst du es dir auch einfacher machen: Wenn die Länge des Arrays fix ist, kannst du ein Pärchen aus Zeiger auf's erste Arrayelement und Arraylänge übergeben.

So also ich konnte compilieren, doch wenn ich was ändere und abspeichere dann ändert er automatisch immer mein Abstractclass.hpp file

so sieht es aus wo das kompilieren nicht mehr geht:

zusammenfalten · markieren

Delphi-Quellcode:

unit DelphiAbstractClass;


interface

uses
   UnitTyp;

type
  TAbstractClass = class
  protected
    function GetDummy : integer; virtual; abstract;
    procedure SetDummy(Value : integer); virtual; abstract;
    function GetMTCount : integer; virtual; abstract;
    procedure SetMTCount(Value : integer); virtual; abstract;
    function GetText : ansistring; virtual; abstract;
    procedure SetText(Value : ansistring); virtual; abstract;
    function GetTTT : ansistring; virtual; abstract;
    procedure SetTTT (Value : ansistring); virtual; abstract;
    function GetTTInput : Tinputvec; virtual; abstract;
    procedure SetTTInput (Value : tinputvec); virtual; abstract;
    
  public
    procedure DoSomething; virtual; abstract;
    procedure DoTTable; virtual; abstract;
    property Text : ansistring read GetText write SetText;
    property TTT : ansistring read GetTTT write SetTTT;
    property TTInput :tinputvec read GetTTInput write SetTTInput;
    property Dummy : integer read GetDummy write SetDummy;
    property MTCount : integer read GetMTCount write SetMTCount;
  end;

  function CreateCppDescendant : TAbstractClass; stdcall; external 'CPPPackage.bpl';

implementation

end.

Dieses File wird dann autmo. erstellt.

markieren

Code:

// CodeGear C++Builder
// Copyright (c) 1995, 2016 by Embarcadero Technologies, Inc.
// All rights reserved

// (DO NOT EDIT: machine generated header) 'DelphiAbstractClass.pas' rev: 32.00 (Windows)

#ifndef DelphiabstractclassHPP
#define DelphiabstractclassHPP

#pragma delphiheader begin
#pragma option push
#pragma option -w-      // All warnings off
#pragma option -Vx     // Zero-length empty class member
#pragma pack(push,8)
#include <System.hpp>
#include <SysInit.hpp>
#include <UnitTyp.hpp>

//-- user supplied -----------------------------------------------------------

namespace Delphiabstractclass
{
//-- forward type declarations -----------------------------------------------
class DELPHICLASS TAbstractClass;
//-- type declarations -------------------------------------------------------
#pragma pack(push,4)
class PASCALIMPLEMENTATION TAbstractClass : public System::TObject
{
   typedef System::TObject inherited;
   
protected:
   virtual int __fastcall GetDummy(void) = 0 ;
   virtual void __fastcall SetDummy(int Value) = 0 ;
   virtual int __fastcall GetMTCount(void) = 0 ;
   virtual void __fastcall SetMTCount(int Value) = 0 ;
   virtual System::AnsiString __fastcall GetText(void) = 0 ;
   virtual void __fastcall SetText(System::AnsiString Value) = 0 ;
   virtual System::AnsiString __fastcall GetTTT(void) = 0 ;
   virtual void __fastcall SetTTT(System::AnsiString Value) = 0 ;
   virtual Unittyp::Tinputvec __fastcall GetTTInput(void) = 0 ;
   [I]virtual void __fastcall SetTTInput(const Unittyp::Tinputvec Value) = 0 ;[/I]
   
public:
   virtual void __fastcall DoSomething(void) = 0 ;
   virtual void __fastcall DoTTable(void) = 0 ;
   __property System::AnsiString Text = {read=GetText, write=SetText};
   __property System::AnsiString TTT = {read=GetTTT, write=SetTTT};
   __property Unittyp::Tinputvec TTInput = {read=GetTTInput, write=SetTTInput};
   __property int Dummy = {read=GetDummy, write=SetDummy, nodefault};
   __property int MTCount = {read=GetMTCount, write=SetMTCount, nodefault};
public:
   /* TObject.Create */ inline __fastcall TAbstractClass(void) : System::TObject() { }
   /* TObject.Destroy */ inline __fastcall virtual ~TAbstractClass(void) { }
   
};

#pragma pack(pop)

//-- var, const, procedure ---------------------------------------------------
extern "C" TAbstractClass* __stdcall CreateCppDescendant(void);
}   /* namespace Delphiabstractclass */
#if !defined(DELPHIHEADER_NO_IMPLICIT_NAMESPACE_USE) && !defined(NO_USING_NAMESPACE_DELPHIABSTRACTCLASS)
using namespace Delphiabstractclass;
#endif
#pragma pack(pop)
#pragma option pop

#pragma delphiheader end.
//-- end unit ----------------------------------------------------------------
#endif   // DelphiabstractclassHPP

Wenn ich die Zeile dann manuale in das abändere kann ich wieder compilieren.

markieren

Code:

   virtual void __fastcall SetTTInput(const DynamicArray<int>& Value) = 0 ;

Gibts da eine Lösung, auch habe ich in dem File: CPPClass.cpp die INit von m_DVector drin, daher habe ich immer 5 Elemente in der Abrage:

markieren

Code:

__fastcall TCppClass::TCppClass() :
   TAbstractClass(),
   m_Dummy (0),
   m_MTCount (0),
   m_Text(L"Initialised in C++___________________________"),
   m_TTT (L"Initialised in C++___________________________"),
   //m_TTT(L"__;xy#"),
   m_Vector { 1, 2, 3, 4, 5 },
   m_DVector{ 1, 2, 3, 4, 5 } 
{

}

Abfrage:

markieren

Code:

void __fastcall TCppClass::DoSomething() {

   //System::AnsiString qmc_result;
   //qmc_result=calcmain(m_MTCount).c_str();
   if (GetDummy() == 1) {
     //   MessageBox(0, L"Now Dummy-String", L"Delphi/C++ interaction", 0);
      TCppClass::SetText(L"My DUMMY:RESULT");
      TCppClass::SetTTT(L"__ __;DUMMY#");
     
      }
   else
      {   
      TCppClass::SetText(calcmain(m_MTCount).c_str());    // does work
      }
   //TCppClass::SetText(L"myreslut:x");           // works fine
   
   std::wstringstream strMessage;
   strMessage << L"Hello from a C++ class. Result of QMC is: " << m_Text.c_str()
      << std::endl
      << L"InputVector contains " << std::to_wstring(m_DVector.Length) << " elements";

   MessageBox(0, strMessage.str().c_str(), L"Delphi/C++ interaction", 0);
   //TCppClass::SetText(qmc_result);           // works NOT fine
   
}

Danke für die TIPS.
Walter

Zitat von uligerhardt:

Vielleicht kannst du es dir auch einfacher machen: Wenn die Länge des Arrays fix ist, kannst du ein Pärchen aus Zeiger auf's erste Arrayelement und Arraylänge übergeben.

Naja die Länge wird im Delphi File individual gehalten, die kann sich ändern.
Dann wird das Array der Class übergeben und in C++ bleibt es dann fix.

Bei mir stimmt was noch nicht, es ist immer 5 Elemente lang.

Es wird die SetTTInput Forschleife nicht durchgeführt. Stimmt da was mit dem & nicht?

markieren

Code:

void __fastcall TCppClass::SetTTInput(const DynamicArray<int>& Value) {
  for (int i=Value.Low; i<=Value.High; i++)
     {
    m_DVector[i] = Value[i];
   std::wstringstream strMessage;
   strMessage << L"Hello from a C++ class. Set now DVector: DVector[" << std::to_wstring(i)
   << L"] is " << std::to_wstring(m_DVector[i])
      << std::endl
      << L"InputVector contains " << std::to_wstring(m_DVector.Length) << L" elements";

   MessageBox(0, strMessage.str().c_str(), L"Delphi/C++ interaction", 0);
   
   }
}

Interessanterweise klappt in C++ der Call:

markieren

Code:

    TCppClass::SetTTInput({1, 2, 3});

Also hier der PAscal call als bild, wo die richtingen Werte drin stehen und der Debug in C++ wo ein NULL Array da ist.
Was ist da falsch?
DANKE HERZLICHST.

Sorry, ich kann mir jetzt nicht den ganzen Code durchlesen. Bin auch nicht der C++-Builder-Profi.
Die Antworten auf deine Fragen hängen davon ab, was du eigentlich machen willst... Willst du bestehenden C++-Code in Delphi nutzen oder umgedreht? Ist das C++ standardkonform oder darf und soll es C++-Builder sein?

Ich habe es jetzt nur kurz überflogen, aber in deiner abstrakten Delphi-Klasse sind die Setter-Methoden "call by value". In der C++-Implementierung haben die Methoden aber konstante Referenzen (dein "const" und "&").

GESCHAFFT!

Anbei für Leute die sich auch dafür interessieren.
Wie gesagt bei Neuem Erstellen, muss man die Zeile in AbstractClass.hpp

Zitat:

virtual void __fastcall SetTTInput(const DynamicArray<int>& Value) = 0 ;

nachtraglich korrigieren, weil das File autom. von RAD Studio generiert wird.
Nach dem Korrig. kann man F9 Drücken und mit /ohne Debugger laufen lassen.

Danke an alle die geholfen haben.