प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

निम्नलिखितम् एकं सरलं Qt-आधारितं MVC-रूपरेखा उदाहरणम् अस्ति, यस्मिन् मॉडल् (Model) इत्यस्मिन् क्रियाः बाल-धागेषु संसाधिताः भवन्ति । अस्मिन् उदाहरणे मूलभूतं View, Controller, Model च समाविष्टं भविष्यति ।

1. परियोजना संरचना

परियोजनासंरचना निम्नलिखितरूपेण अस्ति ।

MyMVCApp/
├── main.cpp
├── model.h
├── model.cpp
├── view.h
├── view.cpp
├── controller.h
├── controller.cpp
├── mainwindow.ui
├── mainwindow.h
├── mainwindow.cpp
1
2
3
4
5
6
7
8
9
10
11

2. मुख्य.cpp

#include <QApplication>
#include "mainwindow.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}
1
2
3
4
5
6
7
8
9
10

3. दृश्यम्।ह

दृश्यभागः मुख्यतया दत्तांशप्रदर्शनस्य उपयोक्तृपरस्परक्रियायाः च उत्तरदायी भवति ।वयं सरलस्य उपयोगं करिष्यामःQMainWindowदृश्यरूपेण अस्मिन् बटन्, लेबल् च भवति ।

#ifndef VIEW_H
#define VIEW_H

#include <QWidget>
#include <QPushButton>
#include <QLabel>
#include <QVBoxLayout>

class View : public QWidget
{
    Q_OBJECT

public:
    explicit View(QWidget *parent = nullptr);

    QPushButton *getButton() const;
    QLabel *getLabel() const;

private:
    QPushButton *button;
    QLabel *label;
    QVBoxLayout *layout;
};

#endif // VIEW_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. दृश्यम्।cpp

#include "view.h"

View::View(QWidget *parent) : QWidget(parent)
{
    button = new QPushButton("Click me", this);
    label = new QLabel("Initial text", this);
    layout = new QVBoxLayout(this);

    layout->addWidget(button);
    layout->addWidget(label);

    setLayout(layout);
}

QPushButton* View::getButton() const
{
    return button;
}

QLabel* View::getLabel() const
{
    return label;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5. मुख्यविण्डो।ह

अस्तिmainwindow.h, वयं समावेशयिष्यामःview.hतथा मुख्यजालकस्य भागं कुर्वन्तु।

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "controller.h"
#include "view.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private:
    Ui::MainWindow *ui;
    Controller *controller;
    View *view;
};

#endif // MAINWINDOW_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

6. मुख्यविण्डो.cpp

अस्तिmainwindow.cpp, वयं view इत्यस्य आरम्भं कृत्वा नियन्त्रकस्य दृश्यस्य च संकेतान् स्लॉट् च संयोजयामः ।

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    controller(new Controller(this)),
    view(new View(this))
{
    ui->setupUi(this);
    setCentralWidget(view);

    // Connect button click to controller slot
    connect(view->getButton(), &QPushButton::clicked, controller, &Controller::handleButtonClicked);
    
    // Connect controller signal to update label
    connect(controller, &Controller::updateLabel, view->getLabel(), &QLabel::setText);
}

MainWindow::~MainWindow()
{
    delete ui;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

7. नियन्त्रक.ह

#ifndef CONTROLLER_H
#define CONTROLLER_H

#include <QObject>
#include "model.h"

class Controller : public QObject
{
    Q_OBJECT

public:
    explicit Controller(QObject *parent = nullptr);

signals:
    void updateLabel(const QString &text);

public slots:
    void handleButtonClicked();

private:
    Model *model;
};

#endif // CONTROLLER_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

8. नियन्त्रकः.cpp

#include "controller.h"

Controller::Controller(QObject *parent) : QObject(parent), model(new Model(this))
{
    // Connect model signal to controller signal
    connect(model, &Model::dataProcessed, this, &Controller::updateLabel);
}

void Controller::handleButtonClicked()
{
    model->processData();
}
1
2
3
4
5
6
7
8
9
10
11
12

9. आदर्शः.ह

#ifndef MODEL_H
#define MODEL_H

#include <QObject>
#include <QThread>

class Model : public QObject
{
    Q_OBJECT

public:
    explicit Model(QObject *parent = nullptr);
    ~Model();

    void processData();

signals:
    void dataProcessed(const QString &result);

private:
    QThread workerThread;
};

#endif // MODEL_H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

10. मॉडल.cpp

#include "model.h"
#include <QTimer>

class Worker : public QObject
{
    Q_OBJECT

public slots:
    void doWork()
    {
        // Simulate long-running task
        QThread::sleep(2);
        emit resultReady("Data processed in background thread");
    }

signals:
    void resultReady(const QString &result);
};

Model::Model(QObject *parent) : QObject(parent)
{
    Worker *worker = new Worker;
    worker->moveToThread(&workerThread);

    connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
    connect(this, &Model::operate, worker, &Worker::doWork);
    connect(worker, &Worker::resultReady, this, &Model::dataProcessed);

    workerThread.start();
}

Model::~Model()
{
    workerThread.quit();
    workerThread.wait();
}

void Model::processData()
{
    emit operate();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

11. श्रमिकवर्गः

अस्तिmodel.cppएकं परिभाषयतुWorkerबालसूत्रेषु कार्याणि कर्तुं वर्गः।

class Worker : public QObject
{
    Q_OBJECT

public slots:
    void doWork()
    {
        // Simulate long-running task
        QThread::sleep(2);
        emit resultReady("Data processed in background thread");
    }

signals:
    void resultReady(const QString &result);
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

सारांशं कुरुत

अस्मिन् उदाहरणे View, Controller, Model च सन्ति ।
दृश्यं दत्तांशं उपयोक्तृपरस्परक्रियाञ्च प्रदर्शयितुं उत्तरदायी भवति, नियन्त्रकः उपयोक्तृनिवेशं संसाधयति तथा च दृश्यं अद्यतनं करोति, तथा च मॉडलः बालसूत्रे दत्तांशं संसाधयति तथा च दृश्यं अद्यतनीकर्तुं नियन्त्रकं सूचयति
आवश्यकतानुसारं भवान् एतत् ढाञ्चं विस्तारयितुं शक्नोति, अधिकं कार्यक्षमतां जटिलतां च योजयित्वा ।
आशास्ति यत् एतत् उदाहरणं भवतः सहायकं भवति!