Delphi-PRAXiS - Übergabe von einem selbdef. Type in C++

Seite 1 von 2

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Algorithmen, Datenstrukturen und Klassendesign (https://www.delphipraxis.net/78-algorithmen-datenstrukturen-und-klassendesign/)

- - Übergabe von einem selbdef. Type in C++ (https://www.delphipraxis.net/192347-uebergabe-von-einem-selbdef-type-c.html)

Übergabe von einem selbdef. Type in C++

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:

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

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

AW: Übergabe von einem selbdef. Type in C++

Geht das nicht

damit?

AW: Übergabe von einem selbdef. Type in C++

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...

AW: Übergabe von einem selbdef. Type in C++

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

AW: Übergabe von einem selbdef. Type in C++

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.

AW: Übergabe von einem selbdef. Type in C++

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:

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.

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.

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:

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:

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

AW: Übergabe von einem selbdef. Type in C++

Zitat:

Zitat von uligerhardt (Beitrag 1367137)

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?

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:

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.

AW: Übergabe von einem selbdef. Type in C++

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?

AW: Übergabe von einem selbdef. Type in C++

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 "&").

AW: Übergabe von einem selbdef. Type in C++

GESCHAFFT! :-D

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.

Seite 1 von 2