Übergabe von einem selbdef. Type in C++

[wschrabi]

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

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

[wschrabi]

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?

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.

[uligerhardt]

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?

[Der schöne Günther]

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

[wschrabi]

Danke Dir Günther!

Kannst mir sagen was ich da genau ändern müßte. Man lernt nie aus.
Wennst mir die Zeile hier korrigiert zeigt, weiß ich dann genau was Du meinst.
Sorry.

Zitat von Der schöne Günther:

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

[wschrabi]

DANKEEEE ! Ja das wars, einfach const un & weglassen.

Jetzt klappt auch die autom. Erstellung des Files wieder.
Hier das Fertige Resulat.

[wschrabi]

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.

[wschrabi]

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