Using objects

Cheerful Coder

Hey liebe Programming Community!

Ich steige grade auf c++ um und bin dabei OOP zu lernen.
Ich stecke bei einer Aufgabe fest und verstehe nicht so ganz wie ich das lösen kann.

Die Aufgabe in meinem Lehrbuch lautet ein Objekt zu erstellen, diesem zwei Werte zuzuteilen und dann dieses Objekt mit einem temporären zweiten Objekt zu addieren.

Eine weitere Funktion soll dann die aktuellen Werte auf zwei beliebige Werte zurücksetzen.

Das Problem ist, dass das Programm die Werte nicht addiert. Ich möchte jedoch nicht den const modifier weglassen, sondern ein neues Objekt erstellen in der add member funktion und dieses dann zurückgeben.

Kann mir jemand erklären, wie das am besten geht?

Vielen dank schonmal!

Hier ist mein Code:

Header.h

#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED

class Move
{

private:
double x;
double y;

public:
Move(double a = 0, double b = 0); // sets x, y to a, b
void showmove() const; // shows current x, y values

const Move & add(const Move & m) const;
// this function adds x of m to x of invoking object to get new x,
// adds y of m to y of invoking object to get new y, creates a new
// move object initialized to new x, y values and returns it
void reset(double a = 0, double b = 0); // resets x,y to a, b

};

#endif // HEADER_H_INCLUDED

Class definitions:

#include <iostream>
#include "header.h"

Move::Move(double a, double b)
{
  x = a;
  y = b;
}

void Move::showmove() const
{
  std::cout << x << std:: endl << y << std::endl;
}

const Move & Move::add(const Move & m) const
{
  Move nextMove(m.x, m.y);
  nextMove.x += m.x;
  nextMove.y += m.y;

return nextMove;
}
// this function adds x of m to x of invoking object to get new x,
// adds y of m to y of invoking object to get new y, creates a new
// move object initialized to new x, y values and returns it

void Move::reset(double a, double b) // resets x,y to a, b
{

  x = a;
  y = b;

}

Main

#include <iostream>
#include "header.h"

int main (void)
{

    double x, y;
    int input;
    std::cout << "Please type in two numbers" << std::endl;
    std::cin >> x >> y;
    Move object1(x, y);
    object1.showmove();

    std::cout << "Please choose one of the following options" << std::endl;
    std::cout << "1.Add numbers     2.Reset numbers to the following values\n3.Quit" << std::endl;
    std::cout <<"Input: ";
    std::cin >> input;

    while (input != 3)
    {

     switch(input)
     {

      case 1: {std::cout << "Please type in numbers to add" << std::endl;
              std::cin >> x >> y;
              Move buffermove(x, y);
              buffermove = object1.add(buffermove);
              object1.showmove();
              break;}

      case 2: {std::cout << "Please type in numbers to reset with" << std:: endl;
              std::cin >> x >> y;
              object1.reset(x, y); // resets x,y to a, b
              object1.showmove();
              break;}
     }

    std::cout << "Please choose one of the following options" << std::endl;
    std::cout << "1.Add numbers     2.Reset numbers to the following values\n3.Quit" << std::endl;
    std::cout <<"Input: ";
    std::cin >> input;

}
std::cout << "Quitting program, thank you!";
}

SeppJ

const Move & Move::add(const Move & m) const
{
  Move nextMove(m.x, m.y);
  nextMove.x += m.x;
  nextMove.y += m.y;
 
return nextMove;
}

Du benutzt beide Male die x und y aus dem übergebenen Objekt m. Du willst einmal die x und y aus m und einmal die x und y aus *this (also einfach nur x und y mit nichts davor schreiben, da das add eine Memberfunktion ist).

P.S.: Und das ist wirklich mal schönes, sauberes C++ für einen Anfänger. Darf ich fragen, wo du das gelernt hast?

Cheerful Coder

@SeppJ: Erstmal Dankeschön für das Kompliment und die schnelle Antwort
Hab mich sehr drüber gefreut.

Ich muss gestehen, dass ich schon Vorerfahrung in C habe :p. Habe
hobbymäßig aus dem Buch "C Primer Plus" von Stephen Prata gelernt. Das
Buch fand ich so strukturiert und klasse erklärt, dass ich danach auf
den gleichen Autor für C++ "C++ Primer Plus umgestiegen bin
Die Übungen in dem Buch haben es zwar in sich in Sachen Logik und
Aufbau, aber ich finde man lernt hervorragend dadurch.
Ich finde, dass der Autor ein Genie ist. Er erklärt Programmierung
einfach hervorragend.

Nochmal zu deinem Lösungsvorschlag. Gibt es da auch eine andere Lösung?
Das was du jetzt vorschlägst bedeutet ja, dass ich den const Modifier
rausnehmen müsste bei der add-Funktion, was ich im Prinzip nicht möchte.

Ginge es noch irgendwie anders?

Lieben Gruß!

const Move & Move::add(const Move & m) const // Hier müsste ich ja dann 
                                                     const rausnehmen, aber das 
                                                     möchte ich ja nicht.
{
  Move nextMove(m.x, m.y);
  nextMove.x += m.x;
  nextMove.y += m.y;

return nextMove;
}

SeppJ

Wieso müsstest du das const rausnehmen? Du willst die x und y doch bloß zu den anderen addieren, nicht ändern:

const Move & Move::add(const Move & m) const
{
  Move nextMove(x, y);
  nextMove.x += m.x;
  nextMove.y += m.y;

return nextMove;
}

Cheerful Coder

Also ich habe es jetzt so abgeändert, dass er x und y an nextMove übergibt.
Wenn ich das Programm jedoch jetzt starte, addiert er jeweils nur ein einziges Mal, wie kann ich es bewerkstelligen, dass er nicht immer vom Anfangswert ausgeht beim addieren?

SeppJ

Was soll es denn nun werden? Soll add ein Objekt zum anderen hinzuaddieren oder soll add ein neues Objekt erstellen, welches die Summe zweier anderer Objekte ist. Du musst dich entscheiden.

Wenn du etwas zum aufrufenden Objekt hinzuaddieren möchtest, dann brauchst du das temporäre Objekt nextMove nicht, dann kann die Methode aber auch nicht const sein.

Cheerful Coder

Ok, also im Prinzip ist die Aufgabe damit gelöst ja? Klasse!
Dann danke ich dir nochmal! Ich belasse es jetzt mal so dabei.
Ohne const weiß ich schon wie ich es mache. Dann werde ich mich mal an die nächste Aufgabe machen.

Vielen Dank

TyRoXx

SeppJ schrieb:

Wieso müsstest du das const rausnehmen? Du willst die x und y doch bloß zu den anderen addieren, nicht ändern:
const Move & Move::add(const Move & m) const
{
  Move nextMove(x, y);
  nextMove.x += m.x;
  nextMove.y += m.y;
 
return nextMove;
}

Cheerful Coder schrieb:

Ok, also im Prinzip ist die Aufgabe damit gelöst ja? Klasse!
Dann danke ich dir nochmal! Ich belasse es jetzt mal so dabei.
Ohne const weiß ich schon wie ich es mache. Dann werde ich mich mal an die nächste Aufgabe machen.

Vielen Dank

Damit ist gar nichts gelöst. Da wird eine Referenz auf ein lokales Objekt zurückgegeben, was einfach falsch ist.

Cheerful Coder schrieb:

Also ich habe es jetzt so abgeändert, dass er x und y an nextMove übergibt.
Wenn ich das Programm jedoch jetzt starte, addiert er jeweils nur ein einziges Mal, wie kann ich es bewerkstelligen, dass er nicht immer vom Anfangswert ausgeht beim addieren?

Aha

Cheerful Coder

Damit ist gar nichts gelöst. Da wird eine Referenz auf ein lokales Objekt zurückgegeben, was einfach falsch ist.

Kann man hier Auszeichnungen für dumme Kommentare vergeben?
Wie wärs denn mit ner Fehlerkorrektur + Lösungsvorschlag, wenn du das soviel besser kannst

Bashar

Cheerful Coder schrieb:

Kann man hier Auszeichnungen für dumme Kommentare vergeben?

Du hättest gern eine?

SeppJ

Cheerful Coder schrieb:

Damit ist gar nichts gelöst. Da wird eine Referenz auf ein lokales Objekt zurückgegeben, was einfach falsch ist.

Kann man hier Auszeichnungen für dumme Kommentare vergeben?
Wie wärs denn mit ner Fehlerkorrektur + Lösungsvorschlag, wenn du das soviel besser kannst

TyRoXx geht davon aus, dass du seinen Kommentar verstehst und danach handelst. Er sagt schließlich ganz eindeutig, was nicht stimmt und der Fehler ist ein einfacher Anfängerfehler. Wenn du das für einen dummen Kommentar hältst, dann hat TyRoXx deine Fähigkeiten überschätzt, der Fehler liegt jedoch bei deinem mangelndem Verständnis, nicht bei ihm.

const Move Move::add(const Move & m) const
{
  Move nextMove(x, y);
  nextMove.x += m.x;
  nextMove.y += m.y;

return nextMove;
}

(Wobei ich übrigens das const am Rückgabewert auch ein bisschen komisch finde)