Backup.

main.cpp

@@ -39,13 +39,174 @@
 
 #include <bcmainwindow.h>
 
+/*
+#ifdef _WIN32
+#include <stdlib.h> // Stellt sicher, dass die Makros __argc und __argv bekannt sind
+
+extern "C" {
+// Wir definieren die fehlenden Import-Pointer manuell und
+// leiten sie auf die echten Variablen der neuen MinGW-Laufzeitumgebung um.
+int* __imp___argc = &__argc;
+char*** __imp___argv = &__argv;
+}
+#endif
+*/
+
+/*
+// Intermediäre CRTP-Schicht übernimmt die generische Implementierung
+template <typename Derived, typename Base>
+struct cloneable : public Base
+{
+  Derived* clone() override
+  {
+    return new Derived(static_cast<Derived const&>(*this));
+  }
+};
+
+
+// Base bleibt sauber – nur pure virtual
+struct base
+{
+  virtual base* clone() = 0;
+  virtual void  moo() const = 0;
+  virtual ~base() = default;
+};
+
+// Abgeleitete Klassen erben clone() automatisch
+struct derived1 : public cloneable<derived1, base>
+{
+  void  moo() const override { qDebug() << " -- derived1 moo"; }
+};
+
+struct derived2 : public cloneable<derived2, base>
+{
+  void  moo() const override { qDebug() << " -- derived2 moo"; }
+};
+*/
+
+// ---
+
+/*
+struct base
+{
+  virtual base* clone() = 0;
+  virtual void moo() const = 0;
+  virtual ~base() = default;
+};
+
+
+// CRTP-Schicht
+template <typename Derived, typename Base>
+struct cloneable : public Base
+{
+  Base* clone() override  // Base* statt Derived*
+  {
+    return new Derived(static_cast<Derived const&>(*this));
+  }
+};
+*/
+
+/*
+ // Der Rückgabetyp wird exakt nach deinen Vorgaben zur Kompilierzeit ermittelt
+ template <typename Self>
+ auto makeD3(this Self&& self) -> std::conditional_t<
+   std::is_const_v<std::remove_reference_t<Self>>,
+   const derived3&,
+   derived3&>
+ {
+   // Da der Rückgabetyp in der Signatur festgeschrieben ist,
+   // reicht ein einfaches return. Der Compiler bindet die Referenz automatisch korrekt.
+   return self;
+ }
+
+ - 2. Der CRTP-Klon-Automatismus
+
+ - Das NVI-Pattern (Non-Virtual Interface) in Kombination mit CRTP ist eine der elegantesten Architekturen im modernen C++, um dieses Problem zu lösen.
+ */
+
+/*
+// Abgeleitete Klassen erben clone() automatisch
+struct derived1 //: public cloneable<derived1, base>
+{
+
+  // Eine einzige Methode für beide Value Categories
+  auto& nimmMich(this auto& self)
+  {
+    return self;
+  }
+
+};
+
+
+struct derived2 : public cloneable<derived2, base>
+{
+  void moo() const override { qDebug() << " -- derived2 moo"; }
+
+  void mooDerived2() const { qDebug() << " -- derived2 moo"; }
 
 
 
 
+
+
+  void machWasKonstantes() const
+  {
+
+    const derived1& d3 = d1.nimmMich();
+  }
+
+  void machWasSchmutziges()
+  {
+    derived1& d3 = d1.nimmMich();
+  }
+
+
+private:
+
+  derived1 d1;
+
+};
+
+
+
+struct derived3 : public cloneable<derived3, base>
+{
+  void moo() const override { qDebug() << " -- derived3 moo"; }
+
+  derived3* clone() override  // Base* statt Derived*
+  {
+    return new derived3;
+  }
+
+
+  derived2 m_myD2;
+
+};
+*/
+
+/*
+  Das NVI-Pattern (Non-Virtual Interface) in Kombination mit CRTP ist eine der elegantesten Architekturen
+  im modernen C++, um dieses Problem zu lösen. Der Trick dabei beruht auf einer C++-Eigenheit: Die Sprache unterstützt "Kovarianz"
+  (Covariant Return Types) nativ nur bei rohen Zeigern und Referenzen, nicht aber bei Templates wie std::unique_ptr.
+*/
+
 int main(int argc, char *argv[])
 {
 
+  qDebug() << "Starting NtxNode XML Test Suite...";
+
+  /*
+  derived2 myDerived2;
+  base& d2 = *myDerived2.clone();
+  d2.moo();
+
+  derived3 myDerived3;
+  derived3& d3 = *myDerived3.clone();
+  d3.moo();
+
+  return 0;
+*/
+
   QApplication app(argc, argv);