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.

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

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?

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

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