Nested class in Qt5

[Juancinho_cardecan]

This post is deleted!

[Juancinho_cardecan]

@sierdzio Thanks for the reply.
In my cpp, I want to display the variable brightValue inside the method rgbRecive that belongs to rgbLed class, brightValue belongs to brightness class and my final porpouse is to call this variable from the function rgbRecive .
This is the following code:

void rgbLed::rgbRecive(const QString &in)
{
 
    QStringList listNew = in.split(",");
    QStringList a_list = listNew[0].split("(");
    QStringList b_list = listNew[2].split(")");
    /
 
    red = a_list[1].toInt(&flag);
    green = listNew[1].toInt(&flag);
    blue = b_list[0].toInt(&flag);
 
    r2 = regresion_red(red);
    g2 = regresion_green(green);
    b2 = regresion_blue(blue);
 
    r = (brightValue * r2) / 10 ;
    g = (brightValue * g2) / 10 ;
    b = (brightValue * b2) / 10 ;
 
    qDebug() << "BrightValue from other class:" << brightValue;
 
}
 
 
void rgbLed::brightness::brightnessText(const QString &in)
{
;
    QString Bright = in;
    int brightValue;
    brightValue = Bright.toInt(&flag);
}

If I nest in my .h the class brightness inside the rgbLed class the code looks like this:

class rgbLed : public QObject
{
    Q_OBJECT
    class brightness : public QObject
    {
        Q_OBJECT
    public:
        explicit brightness(QObject *parent = 0);
 
    public slots:
        void brightnessText(const QString& in);
    private:
        bool flag = 0;
    };
 
    Q_PROPERTY(int bright READ bright WRITE setBright NOTIFY brightChanged)
public:
    explicit rgbLed(QObject *parent = nullptr);
    int regresion_red(int red);
    int regresion_green(int green);
    int regresion_blue(int blue);
 
    Q_INVOKABLE int bright();
    Q_INVOKABLE int setBright(int x);
    Q_INVOKABLE void add(rgbLed *x);
 
 
    int r;
    int g;
    int b;
    int r2;
    int g2;
    int b2;
    int brightValue;
    int myBrightness;
    QStringList list;
    QString my_in;
 
    int red = 0;
    int green = 0;
    int blue = 0;
    int pos = 0 ;
    bool flag = 0;
    int x;
 
signals:
    void brightChanged(int x);
 
public slots:
    void rgbRecive(const QString &in);
};

After I implemented the code, I tried to compiled and got the following error
Error: Meta object features not supported for nested classes
[Makefile:821: moc_rgbLed.cpp] Error 1

[jsulm]

@Juancinho_cardecan Why do you want to use nested classes? Especially if both are QObject?

[sierdzio]

Oh that kind of nesting. Your original post has different code.

MOC does not support that. You need to use another solution, maybe some some namespaces etc. if you really need it.

[mrjj]

Hi
Move the class brightness : public QObject to its own .h and .cpp files
instead and just include it in class rgbLed.
If you doing the nested class for easy access, you can just make the classes friends or
simply provide access functions. Adding access function with Creator is fast. Just right click it and go to the refacor menu.

[Juancinho_cardecan]

@jsulm I'm doing nested class for easy access to the variable brightValue inside a different class (In this case brightness class)

[mrjj]

@Juancinho_cardecan
Since nested classes will never fly with MOC then you have to use other design.
Use Friends classes
https://www.geeksforgeeks.org/friend-class-function-cpp/
For same level of easy access even its bad for encapsulation
Using access functions is also a possibility as that is just more clean.

[Juancinho_cardecan]

@Juancinho_cardecan Tanks for your support.
In mi case the variables that I would want to manage are in a public slot.
Could i change my function brightnessText as a friend in order to take values inside the function belonging to a slot?

Something such as:

#ifndef RGBLED_H
#define RGBLED_H

class brightness : public QObject
{
    Q_OBJECT

public slots:
    friend void brightnessText(const QString& in);

and then accesss to the variables inside that function in my .cpp calling those variables from the other method rgbRecive:

void rgbLed::brightness::brightnessText(const QString &in)
{
    QString Bright = in;
    int brightValue;
    brightValue = Bright.toInt(&flag);
}
void rgbLed::rgbRecive(const QString &in)
{
 
    QStringList listNew = in.split(",");
    QStringList a_list = listNew[0].split("(");
    QStringList b_list = listNew[2].split(")");
    /
 
    red = a_list[1].toInt(&flag);
    green = listNew[1].toInt(&flag);
    blue = b_list[0].toInt(&flag);
 
    r2 = regresion_red(red);
    g2 = regresion_green(green);
    b2 = regresion_blue(blue);
 
    r = (brightValue * r2) / 10 ;
    g = (brightValue * g2) / 10 ;
    b = (brightValue * b2) / 10 ;
 
    qDebug() << "BrightValue from other class:" << brightValue;
 
}
 
 
void brightness::brightnessText(const QString &in)
{
;
    QString Bright = in;
    int brightValue;
    brightValue = Bright.toInt(&flag);
}

[mrjj]

Hi
Actually i want you to make the outer class a friend of the inner class so when inner class
is moved to own files, the outer class can access all private variables also in the (was) nested class
so that the effect is the same as a nested class.

Doing
friend void brightnessText(const QString& in);
allows that function to access private members (in brightness class) when defined outside but im not sure that is what you want/need
since a normal slot can do that already.

I though you wanted something like

class B;

class A
{
    int val; // this is private
    friend B;
};

class B
{
    A obj; // like the nested class.
    void func()
    {
        obj.val = 100; // this is not possible without friend
    }
};

[jsulm]

@Juancinho_cardecan said in Nested class in Qt5:

I'm doing nested class for easy access to the variable brightValue inside a different class

This is really not a reason to use nested classes. You should think about clean design instead. Why not use getter/setter to access private fields?

[Juancinho_cardecan]

@mrjj Hi

I've been tried to implement your recommendation and also with setters/getters but at time that I want to pass the brightValue from the function void brightness::brightnessText(const QString &in) into the function void rgbLed::rgbRecive(const QString &in) unfortunately the variable b takes a random value inside the method rgbRecive:

This is the following code:

class rgbLed;

class brightness : public QObject
{
    Q_OBJECT
public:
    explicit brightness(QObject *parent = 0);
    friend rgbLed;
    void setBrightValue(int newbrightValueMember)
    {
        brightValueMember = newbrightValueMember;
    };
    int getBrightValue()
    {
        return brightValueMember;
    }

    bool flag = 0;
    int brightValueMember;

public slots:
    void brightnessText(const QString& in);
};

class rgbLed : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int bright READ brigfht WRITE setBright NOTIFY brightChanged)
public:
    explicit rgbLed(QObject *parent = nullptr);
    brightness obj;
    int regresion_red(int red);
    int regresion_green(int green);
    int regresion_blue(int blue);

    Q_INVOKABLE int bright();
    Q_INVOKABLE int setBright(int x);
    Q_INVOKABLE void add(rgbLed *x);


    int r;
    int g;
    int b;
    int r2;
    int g2;
    int b2;
    int brightValue;
    int myBrightness;
    QStringList list;
    QString my_in;

    int red = 0;
    int green = 0;
    int blue = 0;
    int pos = 0 ;
    bool flag = 0;
    int x;

signals:
    void brightChanged(int x);

public slots:
    void rgbRecive(const QString &in);
};

and in my .cpp:

void brightness::brightnessText(const QString &in)
{

    QString Bright = in;
    int brightValue;
    brightValue = Bright.toInt(&flag);
    setBrightValue(brightValue);

    qDebug() << "bright: " << brightValue;
}

void rgbLed::rgbRecive(const QString &in)
{
    qDebug() << "ColorPicked:" << in;

    QStringList listNew = in.split(",");
    QStringList a_list = listNew[0].split("(");
    QStringList b_list = listNew[2].split(")");

    int b = obj.getBrightValue();
    qDebug() << "Value: " << b;
}

Could anyone see why b is taken a random value?

[jsulm]

@Juancinho_cardecan Where do you call brightness::brightnessText?
Do you call it on rgbLed::obj or maybe on another brightness instance?

[Juancinho_cardecan]

@jsulm I called here after your words but the value doesn't change:

void rgbLed::rgbRecive(const QString &in)
{
qDebug() << "ColorPicked:" << in;

QStringList listNew = in.split(",");
QStringList a_list = listNew[0].split("(");
QStringList b_list = listNew[2].split(")");

obj.brightnessText(in);
int b = obj.getBrightValue();
qDebug() << "Value: " << b;

}

[jsulm]

@Juancinho_cardecan Called where? And did you call it on rgbLed::obj?

[Juancinho_cardecan]

This post is deleted!

[Juancinho_cardecan]

@jsulm No I din't call it on rgbLed::obj, I called it inside the function void rgbLed::rgbRecive

[mrjj]

Hi
So here

void rgbLed::rgbRecive(const QString &in)
{
obj.brightnessText(in);
int b = obj.getBrightValue();

b is not what you expect ?

[Juancinho_cardecan]

@mrjj yes it's not what I'm expecting, it might be changing all the time but the value is zero always.

[mrjj]

@Juancinho_cardecan
I would check

brightValue = Bright.toInt(&flag);
(in void brightness::brightnessText(const QString &in))
and see if flag is false as that mean text to Int failed.

[Juancinho_cardecan]

@mrjj the flag is true and the value of brightValue is passing correctly, then the text to Int didn't failed, i dont know what is happening because if the values from QML are passing correctly, I'm calling in the wrong way the function brightnessText inside:

cpp file:

void rgbLed::rgbRecive(const QString &in)
{
     my_brightness.brightnessText(in);
    int b = my_brightness.getBrightValue();
    qDebug() << "Value: " << b;
}

void brightness::brightnessText(const QString &in)
{
    QString Bright = in;
    int brightValue;
    brightValue = Bright.toInt(&flag);
    qDebug() << "brightValue: " << brightValue;
    qDebug() << "flag: " << flag;
    setBrightValue(brightValue);

    qDebug() << "bright: " << brightValue;
}

main.cpp:

int main(int argc, char *argv[])
{

    QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
    QGuiApplication app(argc, argv);
   

    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
    if (engine.rootObjects().isEmpty())
            return -1;

    //Root Object to find Items in QML
    QObject* root = engine.rootObjects()[0];
    assert(root != nullptr);

    // The QML Item to which we want to inject our QML-Item-loaded-from-file
    QQuickItem* colorSelector = qobject_cast<QQuickItem*>(root->findChild<QObject*>("colorSelector"));
    assert(colorSelector != nullptr);


    // Load the QML file to a component
    QString qml_path = "ColorSelector.qml";
    QQmlComponent comp(&engine, QUrl::fromLocalFile(qml_path));

    QScopedPointer<rgbLed> slider (new rgbLed);
    engine.rootContext()->setContextProperty("slider", slider.data());
    QObject *topLevel = engine.rootObjects().value(0);
    QQuickWindow *window = qobject_cast<QQuickWindow *>(topLevel);

    // Create an instance of the component
    rgbLed my_rgbLed;//Creation an Object instance
    brightness my_brightness;

    //Code to conecct a signal with the slot
    QObject::connect(colorSelector, SIGNAL(colorChanged(QString)), &my_rgbLed, SLOT(rgbRecive(QString)));

    // connect our QML signal to our C++ slot
      QObject::connect(window, SIGNAL(submitTextField(QString)), &my_brightness, SLOT(brightnessText(QString)));

    return app.exec();
}

header file:

class rgbLed;

class brightness : public QObject
{
    Q_OBJECT
public:
    explicit brightness(QObject *parent = 0);
    friend rgbLed;
    void setBrightValue(int newbrightValueMember)
    {
        brightValueMember = newbrightValueMember;
    };
    int getBrightValue()
    {
        return brightValueMember;
    }

    bool flag = 0;
    int brightValueMember;

public slots:
    void brightnessText(const QString& in);
};


class rgbLed : public QObject
{
    Q_OBJECT
    Q_PROPERTY(int bright READ brigfht WRITE setBright NOTIFY brightChanged)
public:
    explicit rgbLed(QObject *parent = nullptr);
    brightness my_brightness;
    int regresion_red(int red);
    int regresion_green(int green);
    int regresion_blue(int blue);

    Q_INVOKABLE int bright();
    Q_INVOKABLE int setBright(int x);
    Q_INVOKABLE void add(rgbLed *x);


    int r;
    int g;
    int b;
    int r2;
    int g2;
    int b2;
    int brightValue;
    int myBrightness;
    QStringList list;
    QString my_in;

    int red = 0;
    int green = 0;
    int blue = 0;
    int pos = 0 ;
    bool flag = 0;
    int x;

signals:
    void brightChanged(int x);

public slots:
    void rgbRecive(const QString &in);
}