C++ (QT): Objekt, Zeiger, Referenz,.

[Julian W. (julian-w)]

Hallo,
irgendwie blick ich gerade nicht mehr ganz durch bei C++... evtl. 
könntet ihr mir hier mal auf die Sprünge helfen. Soweit bin ich 
schonmal:

Ein Objekt enthält quasi "alles", also Eigenschaften, Funktionen etc. 
und belegt dementsprechend auch Speicher.

Ein Zeiger enthält nur die Adresse auf ein Objekt. Wenn man den Zeiger 
ausliest, erhält man die Adresse. "Symbol": *

Eine Referenz enthält auch nur die Adresse eines Objektes. Jedoch kann 
man die Referenz wie ein Objekt behandeln. "Symbol": &

Nun würde ich gerne eine statische Klasse definieren, um Einstellungen 
zu speichern. Momentan sieht das wie folgt aus:

settings.h

#ifndef SETTINGS_H
#define SETTINGS_H

#include <QSettings>

class settings
{
public:
    static bool getSavingLoginData();
    static void setSavingLoginData(bool values);

    static void checkAviable();
    static bool settingsLoad;

    static QSettings access;
};

#endif // SETTINGS_H

settings.ccp

#include "settings.h"


bool settings::getSavingLoginData()
{
    checkAviable();
    // TODO: auslesen
    return false;
}

void settings::setSavingLoginData(bool value)
{
    checkAviable();
    // TODO: speichern
}

void settings::checkAviable()
{
    if(settingsLoad == false)
    {
        settingsLoad = true;
        access = new QSettings("C:/blablabla", QSettings::IniFormat);
    }
}

Nur leider erhalte ich hier einen Fehler vom kompilier:

settings.cpp:22: Fehler:no match for 'operator=' in 'settings::access = (((const QString&)(& QString(((const char*)"C:/blablabla")))), (operator new(8u), (<statement>, ((QSettings*)<anonymous>))))'

qsettings.h:304: candidate is: QSettings& QSettings::operator=(const QSettings&)

Ich hab schon alles mögliche probiert, also mit "*" und "&", aber 
irgendwie hat es nie funktioniert :/

Wie mache ich das am besten? Und der Umweg mit "settingsLoad" kann man 
doch bestimmt auch schöner machen und einfach direkt Prüfen, ob das 
Objekt exsistiert, oder?

In einer anderen Klasse hab ich das ganze z.B. so gelöst, was auch ohne 
Probleme funktioniert:

basic_storage.h

#ifndef BASIC_STORAGE_H
#define BASIC_STORAGE_H


#include "storage/sql_access.h"

namespace storage
{

class basic
{

public:
    basic();

    bool connect(int typ, QString server, QString db_name, QString user, QString passwd, int port);
    bool connect(QString path);

    bool isAuth();
    bool isCorrectDB();

private:
    storage::sql *_sql;
};

}

#endif // BASIC_STORAGE_H

basic_storage.cpp:

#include "basic_storage.h"
namespace storage
{

basic::basic()
{
}

bool basic::connect(QString path)
{
    this->_sql = new storage::sql(storage::sql::DB_SQLITE);
    return this->_sql->connect(path);
}

bool basic::connect(int typ, QString server, QString db_name, QString user, QString passwd, int port)
{
    this->_sql = new storage::sql(typ);
    return this->_sql->connect(server, db_name, user, passwd, port);
}

bool basic::isAuth()
{
    if(this->_sql == NULL)
    {
        return false;
    }
    return this->_sql->isConnected();
}

bool basic::isCorrectDB()
{
    QStringList *tables = this->_sql->getTables();
    //tables->contains("temp");
    return false;
}

}

Was mach ich also falsch???

Wäre nett, wenn mir da einer Helfen könnte...

Viele Grüße
Julian

[kaffeedoktor (Gast)]

Hallo Julian,

in Deiner settings-Klasse deklarierst Du access nicht als Zeiger sondern 
als "normale" Membervariable vom Typ QSettings. In 
sessings::checkAviable() erzeugst Du dann aber mit new ein neues 
QSettings-Objekt auf dem Heap und versuchst dann den Zeiger auf dieses 
an Deine Membervariable access zuzuweisen. Deswegen meckert der 
Compiler.

In Deiner Storage-Klasse wiederum machst Du es ja richtig: _sql ist ein 
Zeiger vom Typ storage::sql. Deswegen klappt es dort auch mit dem new 
;-)

kaffeedoktor

[Julian W. (julian-w)]

So, jetzt hab ich mal den Header wie folgt abgeändert:

#ifndef SETTINGS_H
#define SETTINGS_H

#include <QSettings>

class settings
{
public:
    static bool getSavingLoginData();
    static void setSavingLoginData(bool values);

    static void checkAviable();
    static bool settingsLoad;

    static QSettings *access;
};

#endif // SETTINGS_H

Doch jetzt erhalte ich folgende Fehler vom Compiler:

settings.cpp:19: Fehler:undefined reference to `settings::settingsLoad'

settings.cpp:21: Fehler:undefined reference to `settings::settingsLoad'

settings.cpp:22: Fehler:undefined reference to `settings::access'

:-1: Fehler:collect2: ld returned 1 exit status

Die ccp-Datei hab ich nicht verändert. Kann mir dass einer erklären!?

[kaffeedoktor (Gast)]

Hallo Julian,

für Deine statischen Membervarialben musst Du natürlich auch noch 
irgendwo Speicher reservieren. Bisher hast Du sie ja nur deklariert. 
Also am besten in die settings.cpp an den Anfang

bool settings::settingsLoad = false;
QSettings* settings::access = NULL;

So kannst Du sie auch gleich initialisieren.

kaffeedoktor

[Karl H. (kbuchegg)]

Wobei sich die Frage erhebt:
Wenn in deiner Klasse sowieso alles static ist, wozu dann überhaupt eine 
Klasse?

[Julian W. (julian-w)]

kaffeedoktor schrieb:
> bool settings::settingsLoad = false;
> QSettings* settings::access = NULL;

Danke, das war's gewesen :)
Hat mich nur gewundert, dass er über "settingsLoad" sich erst beschwert 
hatte, als ich "access" als Pointer anlegte...


Karl Heinz Buchegger schrieb:
> Wenn in deiner Klasse sowieso alles static ist, wozu dann überhaupt eine
> Klasse?

Nunja, der Übersichtlichkeit wegen halt ;)
So kann ich über "settings::blablabla" auf alles schön über die 
Autovervollständigung zugreifen.

[kaffeedoktor (Gast)]

Hallo Julian,

über settingsLoad hat sich der Linker beschwert, während beim Problem 
mit dem QSettings-Zeiger der Compiler gemeckert hat. Und solange der 
Compiler meckert, fängt der Linker erst garnicht das Arbeiten an.

kaffeedoktor

[Julian W. (julian-w)]

Noch ne Frage zu QSettings:
Ich hab das ganze jetzt mal so umgeschrieben:

settings.h

#ifndef SETTINGS_H
#define SETTINGS_H

#include <QSettings>

class settings
{
public:
    static bool getSavingLoginData();
    static void setSavingLoginData(bool toStorage);

    static QSettings *access;
};

#endif // SETTINGS_H

settings.ccp

#include "settings.h"

QSettings* settings::access = new QSettings("J:\\repo\\lucifer\\settings.ini", QSettings::IniFormat);

bool settings::getSavingLoginData()
{
    bool result;

    access->beginGroup("general");
    result = access->value("savelogin", false).toBool();
    access->endGroup();

    return result;
}

void settings::setSavingLoginData(bool toStorage)
{
    access->beginGroup("general");
    access->value("savelogin", toStorage);
    access->endGroup();
}

Doch leider funktioniert es nicht :/
Die Datei existiert. Ob ich \\ oder / beim Pfad verwende macht keinen 
Unterschied.
Weiß einer, was ich falsch mache?

[Karl H. (kbuchegg)]

Julian W. schrieb:
> Noch ne Frage zu QSettings:
> Ich hab das ganze jetzt mal so umgeschrieben:

Keine gute Idee


> QSettings* settings::access = new
> QSettings("J:\\repo\\lucifer\\settings.ini", QSettings::IniFormat);

Das wird ausgeführt, wenn das Programm hochfährt. Zu diesem Zeitpunkt 
ist aber noch lange nicht gewährleistet, dass QT überhaupt schon 
komplett und vollständig initialisiert und arbeitsfähig ist.

> Weiß einer, was ich falsch mache?

Dein Verständnis über C++ ist noch mangelhaft. Welche C++-Literatur 
benutzt du?

Wenn du von einer Klasse nur 1 einziges Objekt haben willst, dann macht 
man das nicht, indem man alle Member static macht, sondern indem man das 
Singleton Pattern anwendet (danach googeln). Dann hat man wieder im 
Konstruktor den perfekten Platz um derartige Initialisierungen 
unterzubringen.

[Julian W. (julian-w)]

Karl Heinz Buchegger schrieb:
> Das wird ausgeführt, wenn das Programm hochfährt. Zu diesem Zeitpunkt
> ist aber noch lange nicht gewährleistet, dass QT überhaupt schon
> komplett und vollständig initialisiert und arbeitsfähig ist.

Gut, ich habe es dann mal so umgeschrieben:

#include "settings.h"

QSettings* settings::access = NULL;

bool settings::getSavingLoginData()
{
    access = new QSettings("J:\\repo\\lucifer\\settings.ini", QSettings::IniFormat);

    bool result;

    access->beginGroup("general");
    result = access->value("savelogin", false).toBool();
    access->endGroup();

    return result;
}

void settings::setSavingLoginData(bool toStorage)
{
    access->beginGroup("general");
    access->value("savelogin", toStorage);
    access->endGroup();
}

Die Funktion "getSavingLoginData" wird definitiv nur einmal aufgerufen 
und dass auch erst, wenn bereits ein Fenster angezeigt wird, von daher 
sollte QT komplett initialisiert und arbeitsfähig sein.

Trotzdem funktioniert der Code nicht...

Um sicher zu gehen, dass die Funktionen wirklich aufgerufen werden, hab 
ich testweise folgenden Code in main eingefügt:

[...]

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

    settings::getSavingLoginData();
    settings::setSavingLoginData(true);

[...]

funktioniert aber auch nicht...

[Karl H. (kbuchegg)]

Julian W. schrieb:

> void settings::setSavingLoginData(bool toStorage)
> {
>     access->beginGroup("general");
>     access->value("savelogin", toStorage);

setValue

[Julian W. (julian-w)]

*kopf*tisch*kopf*tisch*

Danke für den rettenden Hinweis... :)

Ich glaub ich geh jetzt besser schlafen^^

[Rolf Magnus (Gast)]

Julian W. schrieb:

>> Wenn in deiner Klasse sowieso alles static ist, wozu dann überhaupt eine
>> Klasse?
>
> Nunja, der Übersichtlichkeit wegen halt ;)
> So kann ich über "settings::blablabla" auf alles schön über die
> Autovervollständigung zugreifen.

Dazu bietet sich ein Namespace an.
Solche Pseudo-Klassen sind eher in Java üblich, weil dort Funktionen 
zwangsweise immer in Klassen sein müssen.

[Klaus W. (mfgkw)]

Das kann in C++ auch Sinn machen.

Spätestens sobald in der statischen Klasse neben reinen Daten auch
zugehörige Methoden nützlich werden, wie z.B. Initialisierung,
Persistenz oder was auch immer.

[Rolf Magnus (Gast)]

Klaus Wachtler schrieb:
> Das kann in C++ auch Sinn machen.

Eine Klasse, bei der alles static ist, ist in meinen Augen immer 
unsinnig. Sie wird weder jemals instanziiert, noch bringt es was, davon 
abzuleiten, und damit fehlt alles, was eine Klasse im Sinne von 
Objektorientierung ausmacht.

> Spätestens sobald in der statischen Klasse neben reinen Daten auch
> zugehörige Methoden nützlich werden, wie z.B. Initialisierung,
> Persistenz oder was auch immer.

Ich weiß nicht genau, was du damit meinst.