Datenmanagement einer einfachen GUI-App



  • @Estra

    Danke, das tut gut. Ich würde mal davon ausgehen mit einer etwas einfacheren Sprache eine steilere Lernkurve zu haben.



  • @Engineer sagte in Datenmanagement einer einfachen GUI-App:

    Aber mir ist noch nicht ganz klar, wie ich es bewerkstellige den Zeiger als Parameter weiterzureichen.

    Das lernst du hoffentlich in einem guten C++ Buch.
    Grundsätzlich bietet sich Forward Declaration an. Ist aber erstmal nur ein Begriff, es gehört schon einiges dazu, was man alles wissen/lernen sollte.



  • @Engineer sagte in Datenmanagement einer einfachen GUI-App:

    Aber ich habe einfach nur Klassen für konkrete Aufgaben/Teile. Deshalb fiel mit nur die main.cpp ein um das Objekt zu erstellen.

    Ist ja OK, dann erstell es in main().

    Aber main in den anderen Klassen einzubinden erscheint mir mehr als unlogisch

    Du musst dafür doch main() nirgends einbinden ...?

    #include "Datenobjekt.h"
    #include "AnderesObjekt.h"
    
    int main() {
        Datenobjekt daten;
        AnderesObjekt blub(&daten);
        blub.machWas();
    }
    

    Dafür braucht AnderesObjekt doch von main() nichts zu wissen...?



  • Du kannst dir die benötigten Daten auch mittels get-Methode aus dem Objekt heraus holen.



  • @hustbaer

    Danke, deine Antwort hat den Stein ins rollen gebracht. Ich hatte außer Acht gelassen, dass ich bei der Objekterstellung von Klassen Parameter mitgeben kann.

    Bei mir ist der Fall ein bisschen schwierig, weil viel QT-bezogener Code den Blick für's Wesentliche verstellt.

    #include "mainwindow.h"
    #include <QApplication>
    #include <QDesktopWidget>
    #include "DataStorage.h"
    
    
    int main(int argc, char *argv[])
    {
    
        // Making an Object for data in the heap
        DataStorage* StorageObj = new DataStorage();
    
        QApplication a(argc, argv);
        MainWindow w(nullptr, StorageObj); //passing the pointer of the data object into mainwindow
        w.show();
        return a.exec();
    }
    

    So leite ich das Datenobjekt in MainWindow und von da geht's analog weiter zu den Klassen, in welchen ich das Objekt brauche:

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent, DataStorage *StorageObj)
        : QMainWindow(parent)
        , ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
    
        //Inserting the Widgets for the tabs
        ReinforcementsView* reinforcementsview = new ReinforcementsView;
        ui->gridLayoutReinforcements->addWidget(reinforcementsview);
    
        EarthPressureView* earthpressureview = new EarthPressureView(this, StorageObj);
        ui->horizontalLayoutEarthPressure->addWidget(earthpressureview);
    
        FlexuralAspectRatioView* flexuralaspecratioview = new FlexuralAspectRatioView(this, StorageObj);
        ui->verticalLayoutFlexuralAspectRatio->addWidget(flexuralaspecratioview);
    
        //add close application
        connect(ui->actionExit, &QAction::triggered,
            this, &MainWindow::close);
    }
    
    MainWindow::~MainWindow()
    {
        delete ui;
    }
    

    Ich denke damit bin ich erstmal einen großen Schritt weiter (sofern dieser Vorgehensweise nichts entgegenspricht)!

    @Peter-Viehweger

    Genau so habe ich das vor, aber dazu brauchte ich erstmal generell Zugriff auf das Objekt.

    Vielen Dank für die zahlreichen Antworten! (auch wenn ich mir jetzt wieder ein Stück dümmer vorkomme)



  • Wenn du in Klasse A auf Methoden von Klasse B zugreifen möchtest, dann kannst du das tun, indem du einfach den entsprechenden Header von Klasse B in den Header von Klasse A einbindest.



  • @Peter-Viehweger sagte in Datenmanagement einer einfachen GUI-App:

    Wenn du in Klasse A auf Methoden von Klasse B zugreifen möchtest, dann kannst du das tun, indem du einfach den entsprechenden Header von Klasse B in den Header von Klasse A einbindest.

    Das habe ich (eigentlich) verstanden. Aber wie hilft mir das? Ich möchte ja nicht nur auf Methoden der Klasse DataStorage zugreifen sondern vor allem auf die Daten des speziellen Objekts (welches ich in main.cpp erstelle) zugreifen.



  • Meinst du sowas?

    int main()
    {
         ObjA obja;
         ObjB objb;
    
         obja.setData(objb.getData());
    
         return 0;
    }
    

    Damit holst du Daten aus objb raus und speicherst sie in obja. Also abhänging von der Implementierung und gängigen Konventionen würde getData() den Wert des (privaten) Attributs "data" zurück liefern und setData() den Wert setzen.



  • @Engineer sagte in Datenmanagement einer einfachen GUI-App:

    Ich hatte außer Acht gelassen, dass ich bei der Objekterstellung von Klassen Parameter mitgeben kann.

    😭

    Bei mir ist der Fall ein bisschen schwierig, weil viel QT-bezogener Code den Blick für's Wesentliche verstellt.

        // Making an Object for data in the heap
        DataStorage* StorageObj = new DataStorage();
    

    😭

    Bitte lass das!



  • @Engineer sagte in Datenmanagement einer einfachen GUI-App:

    Das habe ich (eigentlich) verstanden. Aber wie hilft mir das? Ich möchte ja nicht nur auf Methoden der Klasse DataStorage zugreifen sondern vor allem auf die Daten des speziellen Objekts (welches ich in main.cpp erstelle) zugreifen.

    foo.h

    #pragma once
    #include <iostream>
    
    // Bauplan:
    class foo
    {
        int data;
    
    public:
        foo(int data)
        : data{ data }
        {}
    
        void set(int new_data) { data = new_data; }
        int get() const { return data; }
    
        void bar() const { std::cout << "Hello from foo::bar()!\n"; }
    };
    

    hugo.h

    #pragma once
    #include <iostream>
    #include "foo.h"
    
    class hugo {
        foo *ptr_to_a_foo;
    
    public:
        hugo(foo *ptr_to_a_foo)
        : ptr_to_a_foo{ ptr_to_a_foo }
        {}
    
        void franz() const {
            std::cout << "Hello from hugo::franz(). The foo this hugo's pointing to contains data: "
                      << ptr_to_a_foo->get() << '\n';
            ptr_to_a_foo->bar();
        }
    };
    

    main.cpp

    #include "hugo.h"
    #include "foo.h"
    
    int main()
    {
        foo a_foo{ 42 };  // Konkrete Instanz im Speicher
        a_foo.set(36);
    
        hugo a_hugo{ &a_foo };
        a_hugo.franz();
    }
    

Anmelden zum Antworten