Operator new[] für abgeleitete Klassen

[Quiche Lorraine]

@RudiMBM sagte in Operator new[] für abgeleitete Klassen:

Weil der neue auch nichts taugt, wende ich mich nun Linux und Phyton zu.

Python ist aber leider nicht für seine Schnelligkeit bekannt. Denkbar das du zu deinem Problem ein Performanceproblem bekommt.

Warum nutzt du nicht einen neuere Compiler ala GCC der von Compiler von Visual Studio?

[wob]

Bevor ihr über potentielle Geschwindigkeitsprobleme sinniert: ich verstehe nicht, warum @RudiMBM nicht einfach erstmal einen vector<BaseClass*> nimmt. Meinetwegen auch mit owning raw ptr, wenn der Compiler kein C++11 kann. Das wird in >99% der Fälle schon nicht zu langsam sein.

[*john 0]

@DocShoe sagte in Operator new[] für abgeleitete Klassen:

Ohne C++11 hast du leider keine vernünftigen smart_ptr. Ich habe damals für das RAD Studio 2007 die boost Bibliotheken selbst übersetzt, das war nicht trivial, und nur für boost::shared_ptr würde ich das nicht versuchen.

Unter UNIX ging das ganze sehr gut mit C++98 Compiler (GCC und MIPSPro). Für einen shared_ptr braucht es kein C++11, für unqiue_ptr ist C++11 oder neuer hingegen Pflicht.

@RudiMBM sagte in Operator new[] für abgeleitete Klassen:

Danke an alle für die Ratschläge.
Ich glaube nun ist an der Zeit meinen alten launenhaften C++Builder zu verschrotten. Weil der neue auch nichts taugt, wende ich mich nun Linux und Phyton zu. Hier gibts noch Aufbruchslaune. Obwohl ich schon 1980 mit einem UNIX-Mainframe und 1990 mit Unix-Sun-Sparc rummachte, konnte ich mich noch nicht für Linux entscheiden.

UNIX lief traditionell nicht auf Mainframes sondern auf Minicomputern. Mittlerweile kann man auf IBMs zSeries z/Linux betreiben, aber nicht IBMs eigenes UNIX AIX. Das läuft nur auf der Power Hardware, die die konsolidierte gemeinsame Plattform für IBMs UNIX AIX und dem Nachfolger des Mini Computer OS der AS/400 sind, und natürlich läuft darauf auch Linux für Power. IMHO ist BS2000 die einzige nicht IBM Mainframe Plattform, die bis heute überlebt hat.

Unter Linux gibt es ein Sammelsurium von freien bzw. frei verfügbaren C und C++ Compilern: GCC, clang, Intel, nVidia (vormals PGI), AMD, … Bei Deinen Problembeschreibungen erscheint mir NumPy eine sinnvoller Einstieg zu sein, wenn Du denn wechseln willst. Mein Rat wäre zuerst einen freien neueren C++ Compiler unter Windows zu probieren. Ein Wechsel zieht so einiges nach sich, so dass es da nicht nur ums Programmieren geht.

[DocShoe]

@john-0

Jups, deswegen schrub ich auch shared_ptr. Ohne Move-Semantik kein unique_ptr. Und es gibt zwei große Probleme, wenn man mit dem RAD Studio/Builder arbeitet:

1. der bcc32 C++ Compiler, der nicht mal zu sich selbst kompatibel ist. Ok, das ist übertrieben, aber die ganze Toolchain hat schon ordentliche Macken.
2. die Visual Component Framework (VCL). Grafische Komponenten in Delphi, die sich mit dem C++ Builder nutzen lassen. Wird von keinem anderen C++ Compiler unterstützt. D.h., wenn man sich vom C++ Builder trennt, dann trennt man sich auch von seinem GUI. Andererseits ist der bcc32 Compiler auch so schlecht, dass sich Open Source Frameworks nicht damit übersetzen lassen.

[RudiMBM]

Hallo, hier noch einen Nachtrag.....

Meine Idee war einen ClassPointer zu haben, mit dem ich in der gesamten Anwendung zugriff auf die ausgewählte Subklasse C_RechenXX habe.
Das kann natürlich nur ein Ptr auf die Basisklasse sein. Soweit funktioniert das.
Damit aber handele ich mir die Nachteile ein:

1. Kein direkter Zugriff auf public Eigenschaften der Subklassen.
2. Alle public Subklassen-Methoden müßen abgeleitete sein.
3. Zeigerarithmetik des Pointers bezieht sich immer auf die Size der Basisklasse. Sowas geht schwer in die Hose und war auch mein ursprüngliches Problem.

Warum kann ich das trotzdem anwenden?:

1. Meine Subklassen haben keine public Eigenschaften
2. Ist eh so.
3. Die Zeigerarithmetik mußte ich mir selber basteln, war aber erstaunlich leicht.

Also, das Programm läuft, auch wenn es so nicht "State of the Art" ist

Nun sieht es so aus.:

class C_Rechnen {
public:
	C_Rechnen() ;
	~C_Rechnen();
	virtual     void NeueAuswertung() = 0;
	virtual	void Erstellen(int) = 0;
        virtual     C_Rechnen*    Next() = 0;
        virtual     C_Rechnen*    ArrPos( int ) = 0;
        
	long double	innermax, innermin, outermax, outermin;
	long int	       ax, ay;
	int			itercount;
};

C_Rechnen::~C_Rechnen() {}

class C_RechnenMB : public C_Rechnen {
public:
	C_RechnenMB(); 
	~C_RechnenMB() {};
        C_Rechnen*    Next() {    __int8  *aa = (__int8*)this;
                                                   aa += sizeof(C_RechnenMB);
                                                   return (C_Rechen*)aa; }
         C_Rechnen*    ArrPos( int ix) {    __int8  *aa = (__int8*)this;
                                                                  aa += sizeof(C_RechnenMB) * ix;
                                                                 return (C_Rechen*)aa; }
	void NeueAuswertung() {};
	void Erstellen(int) {};
};


class C_RechnenBB : public C_Rechnen {
public:
	C_RechnenBB();
	~C_RechnenBB() {};
        C_Rechnen*    Next() {    __int8  *aa = (__int8*)this;
                                                   aa += sizeof(C_RechnenBB);
                                                   return (C_Rechen*)aa; }
         C_Rechnen*    ArrPos( int ix) {    __int8  *aa = (__int8*)this;
                                                                  aa += sizeof(C_RechnenBB) * ix;
                                                                 return (C_Rechen*)aa; }
	void NeueAuswertung() {};
	void Erstellen(int) {};
       
       int    BBdaten;                                  // Kein zugriff mit BasisPtr, wird aber bei sizeof(C_RechnenBB) mitgezählt.
};
int main () {
	int Mode = 1;
	size_t Anzahl = 10;
       C_Rechnen     *ErgAnzArray, *ErgAnz;

	switch (Mode) {
		case 1:			ErgAnzArray = new C_RechnenMB[Anzahl]; break;
		case 2:			ErgAnzArray = new C_RechnenBB[Anzahl]; break;
		default			ErgAnzArray = new C_RechnenXX[Anzahl]; break;
	}
}

ErgAnz = ErgAnzArray;
for ( ................) {
          ErgAnz->ax = 656565;
          ErgAnz->Erstellen();
          ErgAnz = ErgAnz->Next();
          }

........
ErgAnz = ErgAnzArray->ArrPos(  nth-Element );     // entspricht ErgAnz[ nth-Element ]

Ist ne' Hauruck-Methode, aber läuft!
Gruß Rudi

[DocShoe]

Sowas hab ich doch vor Tagen schon gepostet, nur in typsicher:

class C_Rechnen
{
   virtual C_Rechnen* advance( C_Rechnen* current ) const = 0;
};

class C_RechnenMB
{
   C_Rechnen* advance( C_Rechnen* current ) const override
   {
      // Pointer wird um die Größe der konkreten Klasse verschoben
      C_RechnenMB* tmp = dynamic_cast<C_RechnenMB*>( current );
      return tmp ? ++tmp : nullptr;
   }
}

// Pointer auf nächstes Element wird durch das Element selbst bestimmt.
C_Rechnen* arr = new C_RechnenMB[2];
arr = arr->advance( arr );

[RudiMBM]

@DocShoe pow! bis du schnell.

[DocShoe]

@RudiMBM

Zwei Monitore und ein großes Projekt zu übersetzen

[RudiMBM]

@DocShoe Drei Monitore, und ich spiel blos rum.

[DocShoe]

@RudiMBM

Aber jetzt reichts auch bis Montag. Schönes Wochenende!