Objectattribut als Parameter übergeben

[DerLernende]

hallo zusammen,

Ich habe folgendes Problem: Ich habe eine Klasse "Qsolver". Diese besitzt eine Deque namens "qrpSolBt2Step". In der Main möchte ich ein Object dieser Klasse erschaffen und mit der Deque arbeiten, dazu will ich sie als Parameter an die Methoden übergeben (Keine Klassenmethoden von Qsolver). Dies funktioniert aber nicht. Schaffe ich hingegen eine neue deque (hier Test). Funktioniert es. Woran liegt das?

#include "./qsolver.hpp"
#include <vector>
#include <deque>
#include <iostream>
std::deque<uint32_t> Test;
// forward delaration
void calculateSkolem(std::deque<uint32_t> myQsolver.qrpSolBt2Step);
void iterate_qrpSolBt2Step(std::deque<uint32_t> myQsolver.qrpSolBt2Step);
//Tests

//Main for tests
int main(int argc, char** argv) {
Qsolver myQsolver; // QSolverObject for Tests

// Test iterate_qrpSolBt2Step
// std::deque<uint32_t> Test = myQsolver.qrpSolBt2Step; // Mit dieser deque 
// klappt es
  myQsolver.qrpSolBt2Step.push_back(1);
  myQsolver.qrpSolBt2Step.push_back(2);
  myQsolver.qrpSolBt2Step.push_back(87);
  myQsolver.qrpSolBt2Step.push_back(44);
  Test = myQsolver.qrpSolBt2Step;
  myQsolver.calculateSkolem(myQsolver.qrpSolBt2Step);
}

void calculateSkolem(std::deque<uint32_t> myQsolver.qrpSolBt2Step) {
  myQsolver.iterate_qrpSolBt2Step(myQsolver.qrpSolBt2Step);
  }

void iterate_qrpSolBt2Step(std::deque<uint32_t> myQsolver.qrpSolBt2Step) {
    for (auto it = myQsolver.qrpSolBt2Step.begin();      
      it != myQsolver.qrpSolBt2Step.end(); ++it) {
      int sizeOfTree = *it;
      std::cout << sizeOfTree;
      // iterateqrpCubes(sizeOfTree);
    }
}

[manni66]

Funktioniert nicht ist keine Fehlerbeschreibung.
Es fehlt die Klassendefinition.

myQsolver.calculateSkolem(myQsolver.qrpSolBt2Step);

Hast du den Sinn von Objekten verstanden? Warum übergibst du die eigene Membervariable an die Memberfunktione?

void calculateSkolem(std::deque<uint32_t> myQsolver.qrpSolBt2Step) {

Das dürfte nicht übersetzt werden.

[Ein ehemaliger Benutzer]

normalerweise übergibt man keine einzelnen teile von objekten an unterprogramme, sondern immer das ganze objekt, genauer eine referenz oder einen zeiger darauf, und das unterprogramm ruft dann die entsprechenden methoden auf.

jedenfalls ziehst du in deinem programm eine bestimmte queue aus einem bestimmten objekt heraus und umgehst damit so ziemlich alles, was man sich irgendwann mal zu objektorientierung ausgedacht hat. wie heißt es so schön? kann man so machen, aber dann ist es halt kacke!

[theta]

HansKlaus schrieb:

...

[Ein ehemaliger Benutzer]

ja?

[HelPeRss]

HansKlaus schrieb:

normalerweise übergibt man keine einzelnen teile von objekten an unterprogramme, sondern immer das ganze objekt, genauer eine referenz oder einen zeiger darauf, und das unterprogramm ruft dann die entsprechenden methoden auf.

jedenfalls ziehst du in deinem programm eine bestimmte queue aus einem bestimmten objekt heraus und umgehst damit so ziemlich alles, was man sich irgendwann mal zu objektorientierung ausgedacht hat. wie heißt es so schön? kann man so machen, aber dann ist es halt kacke!

klar übergibt man auch einzelne teile...
warum das ganze objekt wenn man nur einen teil brauch?

ich weiß jetzt aber nich genau was du mit unterprogramm meinst?
denke mal funktionen/prozeduren? ...

wenn ja dann übergibt man lediglich keine membervariblen an memberfunktionen desselben objekts da dieses vorgehen vollständig gegen oop arbeietet...
(stichwort: public, private)

"z.b. aus Objekt der Klasse Test1 möchte ich lediglich die Zahl für einen Funktionsaufruf in der Klasse Test2, dann einfach Zahl aus Objekt Test1 in das der Klasse Test2 übergeben ... das ist oop warum sollte man das nicht können/dürfen...?
was hat es für nachteile und wie willst du soetwas sonst lösen? "

aber ansonsten ist ein zugriff auf eine membervariable des objektes zwar nicht "so schön" geht aber auch, schöner bzw. mehr oop wäre dann vll ein setter&getter aber auch das hat nachteile...

kann ja sein das ich mich irre, aber warum sollte ich das nicht machen?

class Test1
{
private:
int zahl;

public:
int getterZahl ();
void setterZahl (int eingabeZahl);
}

class Test2
{
private:
int zahl2;

public:
void setterZahl2 (int eingabeZahl2);
}

void machIrgendwas(int rechenZahl)
{
//irgendwelche rechnung ... oder was auch immer...
}

int main ()
{

// erstes objekt
Test1 objTest1 ();
// wert setzen
objTest1.setterZahl (1);

// zweites Objekt
Test2 objTest2 ();

// zahl wird übergeben... warum nicht?
objTest2.setterZahl2 (objTest1.getterZahl ());

// an funktion(unterprogramm?) ...
machIrgendwas (objTest1.getterZahl ());
}

[Ein ehemaliger Benutzer]

es macht eben einen unterschied, ob du schreibst

objTest2.setterZahl2 (objTest1.getterZahl ());

oder

objTest2.setterZahl2 (objTest1.zahl);

das hat imho nix mit schön oder nicht schön zu tun, sondern damit, dass man diesen ganzen oo-kram erfunden hat, um die fehlerquote zu verringern.
sonst brauchst du keine klassen und kannst die ganzen daten auch global in eine variablen.h knallen und direkt darauf zugreifen.

aber wo besteht denn jetzt das problem, eine solche funktion zu schreiben

void funktion(objekt &obj,int daten)
{
daten+=5; //halt noch irgendeine manipulation
obj.push(daten);
}

?

du hast da keine großartig zeitraubende kopiererei und alles ist schön gekapselt.

[HelPeRss]

HansKlaus schrieb:

es macht eben einen unterschied, ob du schreibst

objTest2.setterZahl2 (objTest1.getterZahl ());

oder

objTest2.setterZahl2 (objTest1.zahl);

das hat imho nix mit schön oder nicht schön zu tun, sondern damit, dass man diesen ganzen oo-kram erfunden hat, um die fehlerquote zu verringern.
sonst brauchst du keine klassen und kannst die ganzen daten auch global in eine variablen.h knallen und direkt darauf zugreifen.

welchen unterschied macht der zugriff denn konkret?

soweit ich weiß, macht der zugriff selber keinen unterschied...
(zumindest nicht so wie ich es oben im beispiel geschrieben habe ...)

lediglich die klasse - bei einer setter&getter methode können und sind meistens die variblen - als private deklariert (also für den klassen internen gebrauch, sollen aber von außen gelesen und gesetzt werden können) .
der zweite direkte zugriff auf die varible funktioniert sowie so nur wenn derjenige der die klasse geschrieben hat auch die variable als "public" deklariert hat, wenn das der fall ist wird es schon seinen sinn haben und ist "genauso oop" wie über getter&setter methoden.
gegen oop verstößt das auch nicht, ist ja ein objekt zugriff... warum sollte es das ?

außerdem oop senkt nicht die fehlerate, warum auch (höchstens weils dann evt übersichtlicher wird - aber es gibt aber auch sehr unübersichtlichen und schlecht dokumentierten, oop code den ich gesehen habe...) ?

du kannst genauso fehlerfreien code ohne oop schreiben.

jedoch wird dies bei großen programmen eher unübersichtlich (wie schon erwähnt).
deshalb steigert es in meinen augen eher die wartbarkeit und wiederverwendbarkeit des codes - bzw übersichtlichkeit.

HansKlaus schrieb:

aber wo besteht denn jetzt das problem, eine solche funktion zu schreiben

void funktion(objekt &obj,int daten)
{
daten+=5; //halt noch irgendeine manipulation
obj.push(daten);
}

?

du hast da keine großartig zeitraubende kopiererei und alles ist schön gekapselt.

da besteht kein problem wenn das so gebraucht wird ist es super aber warum sollte ich das ganze objekt nutzten wenn ich das nicht brauche...?
(d.h. wie ich oben schon im beispiel gezeigt habe obj1 - braucht nur 1 wert aus obj2 ... wie löst du das dann ?)

// das ist genau so oop 
int zahl = obj.variable;

// wie das !
int zahl = obj.getVariable();

du nutzt bei beiden ein objekt und wenn derjenige der die klasse geschrieben hat die variable als "public" definiert hat ist sie auch für einen zugriff von "außen " da.

was soll daran nicht oop sein?
weil ich das ganze objekt nicht übergebe weil ich nur einen wert brauche?

und wenn ich dann nur einen wert des obj1 in obj2 brauche dann übergibst du das ganze obj?
(solch ein vorgehen ist eher fehleranfälliger weil: wenn du das machst kann obj2 - obj1 komplett nutzen und nicht nur den einen wert, den obj2 benötigen würde... )
lg

[Ein ehemaliger Benutzer]

getter und setter hat man eben erfunden, um nicht einfach so von außen zugriff zu haben.
wenn man will, kann man seine daten ja auch direkt in den registern der cpu ablegen und damit arbeiten.

der sinn von oo ist ja, alles sauber zu strukturieren und durch getter und setter verhinderst du den zugriff auf daten, die nicht außerhalb der klasse benötigt werden. warum sich die arbeit machen, eine klasse zu erstellen, wenn du die dequeue auch direkt in die main schreiben und als parameter an die funktion übergeben kannst?

ja du kannst immer fehlerfreien code schreiben. das heißt, angeblich kann man mathematisch beweisen, dass es eben keinen fehlerfreien code gibt.

du nutzt bei beiden ein objekt und wenn derjenige der die klasse geschrieben hat die variable als "public" definiert hat ist sie auch für einen zugriff von "außen " da.

was soll daran nicht oop sein?
weil ich das ganze objekt nicht übergebe weil ich nur einen wert brauche?

warum packst du gemeinsam genutzte daten in ein objekt? jedenfalls verletzt du damit das prinzip der datenkapselung und zumindest in der prüfung gibt es für sowas 0 punkte. wir haben ja nicht umsonst ein ganzes semester mit oop verbracht, bevor wir überhaupt mit c++ angefangen haben.

[Belli]

HelPeRss schrieb:

HansKlaus schrieb:

es macht eben einen unterschied, ob du schreibst

objTest2.setterZahl2 (objTest1.getterZahl ());

oder

objTest2.setterZahl2 (objTest1.zahl);

das hat imho nix mit schön oder nicht schön zu tun, sondern damit, dass man diesen ganzen oo-kram erfunden hat, um die fehlerquote zu verringern.
sonst brauchst du keine klassen und kannst die ganzen daten auch global in eine variablen.h knallen und direkt darauf zugreifen.

welchen unterschied macht der zugriff denn konkret?

Der zweite Zugriff funktioniert nur dann, wenn zahl public ist, was in Deinem Beispiel aber korrekterweise nicht der Fall ist.

[HelPeRss]

HansKlaus schrieb:

getter und setter hat man eben erfunden, um nicht einfach so von außen zugriff zu haben.
wenn man will, kann man seine daten ja auch direkt in den registern der cpu ablegen und damit arbeiten.

der sinn von oo ist ja, alles sauber zu strukturieren und durch getter und setter verhinderst du den zugriff auf daten, die nicht außerhalb der klasse benötigt werden. warum sich die arbeit machen, eine klasse zu erstellen, wenn du die dequeue auch direkt in die main schreiben und als parameter an die funktion übergeben kannst?

ja du kannst immer fehlerfreien code schreiben. das heißt, angeblich kann man mathematisch beweisen, dass es eben keinen fehlerfreien code gibt.

du nutzt bei beiden ein objekt und wenn derjenige der die klasse geschrieben hat die variable als "public" definiert hat ist sie auch für einen zugriff von "außen " da.

was soll daran nicht oop sein?
weil ich das ganze objekt nicht übergebe weil ich nur einen wert brauche?

warum packst du gemeinsam genutzte daten in ein objekt? jedenfalls verletzt du damit das prinzip der datenkapselung und zumindest in der prüfung gibt es für sowas 0 punkte. wir haben ja nicht umsonst ein ganzes semester mit oop verbracht, bevor wir überhaupt mit c++ angefangen haben.

wohin packst du dann gemeinsam genutze daten in globale variablen?
warum verletze ich damit das prinzip (welches konkret?) der datenkapselung?

oop besagt sogar das daten in objekten gekapselt werden sollen...

das ist ja nur eine frage der strukturierung, ich kann ein objekt basteln was nur für die daten übergabe ist (wie du ja schon erwähntest) ich kann auch einzelne werte eines objektes abfragen um darauf hin diese daten in anderen objekte zu nutzen wie soll das sonst gehen ?

getter & setter und ein public zugriff ist beides ein zugriff auf das objekt --> oop ... hast du denn das nicht in einem jahr oop gelernt? ...

außerdem schreibst du das gemeinsam genutze variablen nicht in objekten "sein sollen" aber wo dann?

oop ist datenkapselung ...
also alle daten soweit es geht und sinn macht zu kapseln...
wenn ich jedoch trozdem einen einzelnen wert brauche schreibe ich ja nicht gleich eine neue klasse ...

wenn das objekt im programmverlauf den wert verändert muss ich ihn von außen abfragen oder wie amchst du das?

Belli schrieb:

HelPeRss schrieb:

HansKlaus schrieb:

es macht eben einen unterschied, ob du schreibst

objTest2.setterZahl2 (objTest1.getterZahl ());

oder

objTest2.setterZahl2 (objTest1.zahl);

das hat imho nix mit schön oder nicht schön zu tun, sondern damit, dass man diesen ganzen oo-kram erfunden hat, um die fehlerquote zu verringern.
sonst brauchst du keine klassen und kannst die ganzen daten auch global in eine variablen.h knallen und direkt darauf zugreifen.

welchen unterschied macht der zugriff denn konkret?

Der zweite Zugriff funktioniert nur dann, wenn zahl public ist, was in Deinem Beispiel aber korrekterweise nicht der Fall ist.

ja das sag ich ja...
ups, da hast du recht, mein fehler .
aber ich hatte es ja auch eindeutig im text geschrieben... (auch wenns in meinem beispiel leider nicht so war...)

lg