3. Überladen und AR-Drone Programmierung

Überladen und AR-Drone Programmierung

  • V

    Guten Sonntag alle zusammen.
    Ich beschäftige mich seit diesem Semester mit der Programmiersprache C++(Informationstechnik für Ingenieure).
    An sich macht es Spaß mit Cpp zu programmieren, dennoch habe ich diverse Probleme beim Objektorientierten Programmieren.

    Zu meiner ersten Frage:
    Ich versuche seit gut einer Woche mit dem Überladen von Operatoren, leider verstehe ich nicht ganz wie es von statten gehen soll.
    Die Aufgabe ist vom letzten Teilbereich meiner Hausaufgabe, die ich bis dahin gelöst habe.
    Aufgabe 2.1

    Implementieren Sie mindestens zwei Operatoren + und * um einen Bruch der Klasse
    Fraction mit einem anderen Bruch der Klasse Fraction zu addieren. Bei Belieben
    können Sie auch Operatoren für - und / implementieren.

    Aufgabe 2.2

    Implementieren Sie mindestens zwei Operatoren + und * um eine Zahl des Typs float
    mit einem Bruch der Klasse Fraction zu addieren. Bei Belieben können Sie auch
    Operatoren für - und / implementieren.

    Meine Headerdatei sieht wie folgt aus:

    #pragma once

#ifndef FRACTION_H
#define FRACTION_H

#include<string>
using namespace std;

class fraction{
//Definition der Membervarialblen als private
private:
	int    m_Zaehler;
	int    m_Nenner;

//	
public:
	//Standardkonstruktor
    fraction(){
        m_Nenner = 1;
        m_Zaehler = 1;
    };
	// weiterer Konstruktor
    fraction(int Zaehler, int Nenner);
	//Destruktor
    ~fraction();
	//Namen der einzelen Methoden; Programmcode in fraction.ccp
    int getZaehler();
    int getNenner();

    void add(fraction fracToAdd);
    void sub(fraction fracToSub);
    void mul(fraction fracToMul);
    void div(fraction fracToDiv);

    void cancel();
    void expand(int a);
    void print();

    float getFPNum();

};

#endif

    Die Fraction Cpp

    #include <iostream>
#include "fraction.h"
using namespace std;

//Konstruktor
fraction::fraction(int Zaehler, int Nenner){
	m_Zaehler=Zaehler;
	m_Nenner=Nenner;
}
//Zählerausgabefunktion
int fraction::getZaehler(){
	return m_Zaehler;
}
//Nennerausgabefunktion
int fraction::getNenner(){
	return m_Nenner;
}

//---------------------------------------------------
//Addition von zwei Brüchen ((Zähler1*Nenner2+Zähler2*Nenner1)/Nenner1*Nenner2)
void fraction::add(fraction fracToAdd){
	cout <<"\t\tAddition: ";
    cout << (m_Zaehler * fracToAdd.m_Nenner) + (fracToAdd.m_Zaehler * m_Nenner);

	if (m_Zaehler * fracToAdd.m_Nenner+fracToAdd.m_Zaehler * m_Nenner == 0)
	cout <<"\t\t  0 \n";
	else
	cout << "\t\t  " << m_Nenner * fracToAdd.m_Nenner << "\n";
}

//Subtraktion von zwei Brüchen((Zähler1*Nenner2-Zähler2*Nenner1)/Nenner1*Nenner2)
void fraction::sub(fraction fracToSub){
	cout <<"\t      Subraktion: ";
    cout <<(m_Zaehler * fracToSub.m_Nenner)-(fracToSub.m_Zaehler * m_Nenner);

	if (m_Zaehler * fracToSub.m_Nenner - fracToSub.m_Zaehler * m_Nenner == 0)
    cout <<"\t\t  0 \n";
	else 
	cout <<"\t\t  " << m_Nenner * fracToSub.m_Nenner << "\n";
}

//Multiplikation von zwei Brüchen (Zähler1*Zähler2/Nenner1*Nenner2)
void fraction::mul(fraction fracToMul){
	cout <<"\t  Multiplikation: ";
    cout << m_Zaehler * fracToMul.m_Zaehler;
    cout <<  "\t\t  " <<m_Nenner * fracToMul.m_Nenner << "\n";
}

//Division von zwei Brüchen (Zähler1*Nenner2/Nenner1*Zähler2)
void fraction::div(fraction fracToDiv){
	cout <<"\t\t Divison: ";
    cout << m_Zaehler * fracToDiv.m_Nenner;
    cout << "\t\t  " << m_Nenner * fracToDiv.m_Zaehler << "\n\n";
}

//---------------------------------------------------

//Algorithmus für das ggt von Zähler und Nenner
 int ggT( int a, int b){
    if(b == 0)
        return a;
    else return ggT(b, a % b);
}

//Methode Kürzen
void fraction::cancel(){
   int tmp(ggT(m_Zaehler,m_Nenner));
   m_Zaehler /= tmp;
   m_Nenner  /= tmp;
   cout<<"   " <<m_Zaehler;
   cout<<"\t\t  " <<m_Nenner<<"\n\n";
}

// Methode Erweitern
void fraction::expand(int a){

    cout <<"\t   " << m_Zaehler*a;
    cout <<"\t\t  " << m_Nenner*a  << "\n\n";
}
//Ausgabefunktion in Bruchschreibweise
void fraction::print(){
    cout << "\t\t\t " << m_Zaehler <<endl;
	cout << "\t\t\t----" <<endl;
	cout << "\t\t\t " <<m_Nenner <<endl;
	cout<<endl;
}
//---------------------------------------------------
//Ausgabefunktion in Dezimalbruchschreibweise
float fraction::getFPNum(){
	float a = m_Zaehler;
    float b = m_Nenner;
    return a/b;
}
//Destruktor
fraction::~fraction(){}

    Wäre echt Dankbar wenn ihr mir helfen könntet, muss es bis zum 22.1 fertig haben , da ich sonst keine Klausurzulassung bekomme.

    Meine zweite Problem ist, dass wir eine AR-Drone Programmieren müssen und für einen 40 Mann Kurs nur eine Drone haben und nur für eine Person einen Server für die Simulation haben. Was im Endeffekt heißt man hat kaum eine Chance selbst zu testen was man da programmiert.

    Wir haben folgende Dateien bekommen:
    AR-Drone.rar (Boost Dateien und einen Drone Client)
    http://www46.zippyshare.com/v/vMHUyDaN/file.html

    So nun zu meiner Frage:
    1)Habt ihr ne Idee wie ich die Simulation auf meinen eigenen Rechner starten kann, da ich gerne mich weiter beschäftigen würde.
    2) Und wie kann ich eine erbende Klasse von DroneClient schreiben welche dann eine Ausgabe erzeugt wenn vor der Drohne ein buter Tag(Markierung) erscheint. Danach soll sich die Drohne so drehen, dass sie mittig auf den Tag schaut.

    Vielen Dank im Voraus, hoffe das ich keine zu dummen Fragen gestellt habe.

    0
  • ?

    In deinem Code kommt kein Operator vor.

    0
  • V

    Habe jetzt auch die cpp Datei eingefügt mit den ganzen Funktionen, wenn nötig füge ich auch die Main.cpp ein. Habe nur bedenken, dass die Hausaufgabe gefunden wird und Plagiat vorgeworfen wird.
    Vielen Dank.

    0
  • ?

    Es ist immer noch kein operator vorhanden.

    Ein Operator sieht so aus

    const X operator+(X const& lhs, X const& rhs);

    Und ist keine Memberfunktion.

    Siehe auch
    https://www.c-plusplus.net/forum/232010-full

    0

  • s. Überladung von Operatoren in C++ (Teil 1)

    0
  • V
     

    //Überladung
fraction  operator+(const fraction& lhs, const fraction& rhs);
{

};

    Habe in die Headerdatei ganz unten dies eingefügt, Visual Studio zeigt mir dass bei dem ersten { eine Deklaration erwartet wurde.
    Ist mein Ansatz wenigstens richtig?

    0
  • ?

    Wie bei jeder anderen Funktion auch gehört keines der Semikolon dahin. Wenn alles ausserhalb der Klassendefinition steht, ist es im Prinzip richtig. Da du Funktionsdefinition in den Header schreiben willst, muss noch ein inline davor.

    0
  • F

    manni66 schrieb:

    Es ist immer noch kein operator vorhanden.

    Ein Operator sieht so aus

    const X operator+(X const& lhs, X const& rhs);

    Kleine Anmerkung am Rande:
    Es empfiehlt sich hier den Rückgabewert nicht const zu deklarieren, da es

    1. den Aufruf von nicht const-Memberfunktionen auf dem temporären, namenlosen Objekt verhindert (Ausdrücke wie c = ++(a + b); möchte man vielleicht erlauben).

    2. Move-Operationen verhindert: c = a + b führt so z.B. immer zu einer zusätzlichen Kopie, da eine Move-Operation üblicherweise das verschobene Objekt verändern muss (indem z.B. ein interner Pointer genullt wird). Move-Operatoren erwarten üblicherweise eine nicht-konstante rvalue-Referenz.

    Gruss,
    Finnegan

    0
  • T

    Weil mir das gerade so auffällt: Du verwendest keinen string. Daher lass das #include <string> einfach weg. Und ein using namespace std im Header geht gar nicht. Und in dem Fall verwendest Du noch nicht mal den Namespace std.

    Const correctness hast Du wahrscheinlich noch nicht gelernt. Solltest Du bei Gelegenheit mal anschauen.

    0
Anmelden zum Antworten