Ich bekomme die aufgabe einfach nicht hin..

Wenn du nicht sagst, woran genau es scheitert, wird das wohl auch so bleiben. Und wenn du denkst, dass du hier einfach eine komplette Lösung vorgekaut bekommst, bist du an der falschen Adresse. Eigeninitiative ist das Zauberwort. Bei Detailfragen kannst du dich dann natürlich ans Forum wenden.

/*
 * Interval.h
 *
 *  Created on: 15.09.2009
 *      Author: benn1
 */

#ifndef INTERVAL_H_
#define INTERVAL_H_

class Intervall
{
	double a,e;

	public:
		Intervall (double a, double e);
		int isEmpty();
		int contains(double wert);
		Intervall Operator_plus(intervall i);
		Intervall Operator_minus();

};

#endif /* INTERVAL_H_ */

und

/*
 * Intervall.cpp
 *
 *  Created on: 15.09.2009
 *      Author: benn1
 */

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

Intervall::Intervall(double a, double e)
{
	if (isEmpty != 0)
	{
		this ->a = a;
		this ->e = e;

	}
	else
	{
		cerr << "Leeres Intervall";
		this ->a = 0;
		this ->e = 0;
	}

}

int Intervall::isEmpty()
{
	if (a > e)
	{
		cout << "Intervall enthält keine Werte: -> leeres Intervall";
		return 1;
	}
	else
	{
		return 0;
	}
}

int Intervall::contains(double wert)
{
	if ((wert >= a) && (wert < e))
	{
		return 1;
		cout << "Wert liegt innerhalb des Intervalls";
	}
	else
	{
		return 0;
		cout << "Wert liegt außerhalb des Intervalls";
	}
}

gut in der main ist noch nicht viel ..

/*
 * main.cpp
 *
 *  Created on: 15.09.2009
 *      Author: benn1
 */

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

int main()
{
	Intervall v1(0,5), v2(6,20), v3(3,10);

	wert = 2;
	contains(wert);
}

soweit so gut..
kann man das überhaupt so machen ?

Beim Überfliegen ist mir schonmal Folgendes aufgefallen:

return 1;
        cout << "Wert liegt innerhalb des Intervalls";

Du springst hier mit return aus der Funktion raus. Das folgende Statement wird also nie ausgeführt. Sicher nicht in deinem Sinne.

wir haben einfach keinen plan wie man die operator richtig aufruft und benutzt..

class Name
{
   ....

   Datentyp operator+(argumentliste);
}

bekomms irgendwie nicht gebacken ..

so soweit sogut ..
ich weiß dennoch nicht wie ich damit umgehen soll,
ich mein, ich hab ja keine felder, ich soll doch nur mit den grenzen arbeiten..
wie mach ich das dann mit dem zweiten feld ?

Lies dir das hier mal durch: http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 1)

bb

Intervall operator+(const Intervall& i1);

geht

und

Intervall operator+(const Intervall& i1, const Intervall& i2);

will er nicht..
oder brauch ich das garnicht und nehme gleich i3 ?
und definiere i3 = i1 + i2 ?

Intervall operator+(const Intervall& i1);

geht

und

Intervall operator+(const Intervall& i1, const Intervall& i2);

will er nicht..

Das kommt darauf an, wo du das hinschreibst...
Entweder ist operator+ ein Klassenmember, dann

class Intervall {
  public:
  Intervall operator+(const Intervall& other);
};

Oder eben global:

class Intervall
{
  // Methoden
};

Intervall operator+( const Intervall& i1, const Intervall& i2);

Aber lies dir doch endlich den Artikel durch...

also das ist schonmal meine header datei:

/*
 * Interval.h
 *
 *  Created on: 15.09.2009
 *      Author: c.groupe
 */

#ifndef INTERVAL_H_
#define INTERVAL_H_

class Intervall
{
	double a,e;
	int wert[5];

	public:
		Intervall (double a, double e);
		int isEmpty();
		int contains(double wert);
		const Intervall Intervall::plus(Intervall const& i2) const;
		const Intervall Intervall::minus(Intervall const& i2) const;

};

#endif /* INTERVAL_H_ */

in der Intervall.cpp
hab ichs nun so eingebunden..

const Intervall operator+(Intervall const& i1, Intervall const& i2)
{
	return i1.plus(i2);
}

const Intervall operator-(Intervall const& i1, Interval const& i2)
{
	return i2.minus(i2);
}

Erstmal Kritik:

#include "Intervall.h"
#include <iostream.h>  // iostream.h ist kein Standardheader
using namespace std;

Intervall::Intervall(double a, double e)
{
/* Zwei Fehler: 
   1) Programmiertechnisch: isEmpty benutzt this->a und this->e, diese werden aber erst hier gesetzt
   2) Progrmmlopgik: Das Intervall [0,0] ist nicht leer, sondern enthält die 0
*/
    if (isEmpty != 0)
    {
        this ->a = a;
        this ->e = e;

    }
    else
    {
        cerr << "Leeres Intervall";
        this ->a = 0;
        this ->e = 0;
    }

}

int Intervall::isEmpty()  // const correctness nicht beachtet
{
    if (a > e)
    {
/* Hier überschreitet die Methode ihre vorgesehenen Kompetenzen. Sie soll 
nichts ausgeben, sondern nur wahr oder falsch zurückgeben. Ansonsten richtig, 
wenn auch ziemlich lang ausgeschrieben.
*/
        cout << "Intervall enthält keine Werte: -> leeres Intervall";
        return 1;
    }
    else
    {
        return 0;
    }
}

int Intervall::contains(double wert)  // const correctness nicht beachtet
{
/* gleiche Kritik wie bei isEmpty */

    if ((wert >= a) && (wert < e))
    {
        return 1;
        cout << "Wert liegt innerhalb des Intervalls";
    }
    else
    {
        return 0;
        cout << "Wert liegt außerhalb des Intervalls";
    }
}

Ein Verbesserungvorschlag:

#include "Intervall.h"

Intervall::Intervall(const double &a, const double &e): a(a), e(e)
{
/* Initialisierungslisten sind hier die bessere Lösung. Es interessiert in den 
anderen Programmteilen ja gar nicht, ob a oder e größer ist. Falls trotzdem 
eine Prüfung stattfinden soll, kann man nun auch this->a und this->e verwenden,
da sie schon initialisiert wurden. Sinnvoll wäre es zum Beispiel für das leere 
Intervall a sehr groß und e sehr klein zu setzen. */
}

bool Intervall::isEmpty() const   // bool ist hier angemessener als int.
{
return (a >= e);
/* So kurz kann man sich fassen. Kleine verbesserung: a darf nun auch gleich e sein (Intervall enthält nur 1 Element)
*/
}

bool Intervall::contains(const double & wert) const
{
return ((wert >= a) && (wert < e));
/* Siehe oben */
}

Was die Operatorüberladung angeht: Deiner Deklaration im Header nach zu schließen, weißt du nicht, was es mit Operatorüberladung auf sich hat. Das musst du dir angucken, um das weitere zu verstehen. Da in der Aufgabenstellung nur die Implementierung von Operator + verlangt wird, gebe ich dir als Beispiel mal den Operator minus. Ich werde aber hier nicht Operatorüberladung vollständig diskutieren, da musst du dir mal eine gute Beschreibung suchen (zum Beispiel den Artikel im Thread "Neue Artikel zu C++ im Magazin")

const Intervall Intervall::operator-(const Intervall &i, const Intervall &j){
/* Nun ist es doch wichtig, ob die Intervalle eventuell leer sind. Das hätte 
wohl doch besser im Konstruktor abgefangen werden müssen. Da ich das nicht 
gemacht habe, habe ich nun mehr Mühe. Du kannst das süäter sicherlich besser :-)
*/
if (i.isEmpty()) return Intervall(j.a,j.e);
if (j.isEmpty()) return Intervall(i.a,i.e);
/* Ok, alle Sonderfälle erledigt, jetzt geht es richtig los: */
double max_a = (i.a > j.a) ? i.a : j.a;
double min_e = (i.e < j.e) ? i.e : j.e;
return Intervall(max_a,min_e);
}

ungetestet (und unvollständig):

Intervall -> 2 Werte. Kommawerte -> double oder float

struct interval
{
private:
   float lower_bound;
   float upper_bound;
};

beim Instanzieren (-> Konstruktor) werden 2 Parameter angegeben (-> interval(float left, float right)). wenn der rechte kleiner ist, als der linke soll ein leeres interval angelegt werden:

struct interval
{
private:
  float lower_bound;
  float upper_bound;
public:
  interval(float lower, float upper)
  :  lower_bound(lower),
     upper_bound(upper)
  {
    if(lower_bound > upper_bound)
      upper_bound = lower_bound;
  }
};

Die Methode isEmpty gibt zurück, ob ein Intervall keine Werte beinhalten kann(ob es ein leeres Intervall ist):

struct interval
{
private:
  float lower_bound;
  float upper_bound;
public:
  interval(float lower, float upper)
  :  lower_bound(lower),
     upper_bound(upper)
  {
    if(lower_bound > upper_bound)
      upper_bound = lower_bound;
  }

  bool isEmpty() const //verändert nichts am objekt
  {
    return lower_bound > upper_bound;
  }
};

oh - das haben wir im konstruktor schon mal verwendet:

struct interval
{
private:
  float lower_bound;
  float upper_bound;
public:
  interval(float lower, float upper)
  :  lower_bound(lower),
     upper_bound(upper)
  {
    if(isEmpty())
      upper_bound = lower_bound;
  }

  bool isEmpty() const //verändert nichts am objekt
  {
    return lower_bound > upper_bound;
  }
};

Die Methode contains kontrolliert, ob ein gegebener Wert (->contains(float value)). rückgabewert ist true oder false -> bool contains(float value)
auch contains verändert wieder nichts an unserem objekt:

struct interval
{
private:
  float lower_bound;
  float upper_bound;
public:
  interval(float lower, float upper)
  :  lower_bound(lower),
     upper_bound(upper)
  {
    if(isEmpty())
      upper_bound = lower_bound;
  }

  bool isEmpty() const //verändert nichts am objekt
  {
    return lower_bound > upper_bound;
  }

  bool contains(float value) const
  {
    return (lower_bound <= value) && (value <= upper_bound);
  }
};

etc...

bb

tu mir ma pls den gefallen und schreib die aufgabenstellung hier hin - aus *.jpg`s kann ich nich ganz so gut copy&pasten^^
und dann beschreib ma pls, was für dich ein leeres intervall ist und dann noch mal, was du im konstruktor machen willst - da fehlt mindestens noch ein paar Klammern hinter isEmpty - was btw den rückgabewert bool haben sollte, wenn ichs richtig gelesen habe.
dein ctor hat so und so undefiniertes verhalten zur folge...

bb

habs selbst nur als jpg daher wirds wohl nicht, aber wenns nicht geht ist auch nicht schlimm.

warum kann ich die operatoren nur so initialisieren, dass 0 oder 1 argument übergeben wird ?

also so

const Intervall Intervall::minus(Intervall const &j) const;

und nicht so

const Intervall Intervall::operator-(const Intervall &i, const Intervall &j);

operatoren nur so initialisieren, dass 0 oder 1 argument

1. definieren
2. lies den ******* artikel! aber tip: es gibt nur 2 seiten und *this ist die eine...

bb

edit:
hier, fertiglösung:

#include <algorithm>

template<typename T>
struct interval
{
private:
	T lower_bound;
	T upper_bound;
public:
	interval(const T &lower, const T &upper)
	:	lower_bound(lower),
		upper_bound(upper)
	{
		if(isEmpty())
			upper_bound = lower_bound;
	}

	bool isEmpty() const //"Die Methode isEmpty gibt an, ob ein Intervall keine Werte enthalten kann"
	{	//[x, x] kann nicht keine Werte enthalten, da x dazu gehört
		return lower_bound > upper_bound;
	}

	bool contains(const T &value) const
	{
		return (value <= lower_bound) && (value <= upper_bound);
	}

	interval operator+ (const interval &other) const
	{
		T lower = std::min(lower_bound, other.lower_bound);
		T upper = std::max(upper_bound, other.upper_bound);
		return interval(lower, upper);
	}

	interval opertor- (const interval &other) const
	{
		T lower = std::max(lower_bound, other.lower_bound);
		T upper = std::min(upper_bound, other.upper_bound);
		return interval(lower, upper);
	}
};

allein für die Formulierung des Verhaltens der isEmpty()-Fkt gehört der Aufgabensteller verprügelt - hat mich mehr Zeit gekostet, darüber nachzudenken, was ein leeres abgeschlossenes Intervall sein sollte als den Rest zu tippen...

nun hab ich noch ne frage beim inizialisieren..

warum kann ich die operatoren nur so initialisieren, dass 0 oder 1 argument übergeben wird ?

also so

const Intervall Intervall::minus(Intervall const &j) const;

und nicht so

const Intervall Intervall::operator-(const Intervall &i, const Intervall &j);

Ups, da hatte ich einen kleinen Schreibfehler bei meinem Beispiel. Wenn man einen binären Operator als Klassenmethode implementiert, kann er nur ein Argument nehmen, die linke Seite ist dann "this". Will man die Variante mit zwei Argumenten verwenden, muss man den Operator als freie Funktion überladen. Die Pros und Contras beider Methoden kannst du in guten Texten zum Thema nachlesen.

gut werde ich dann machen, wird also meine bett lektüre!
wünsche allen eine gute nacht, und bis nacher

unskilled schrieb:

bool contains(const T &value) const
    {
        return (value <= lower_bound) && (value <= upper_bound);
    }

müsste es da nicht eher

return (value   >=   lower_bound) && (value <= upper_bound);

heißen, da ja geprüft werden soll, ob der Wert im Intervall ist ....

Gruß Simon

Nexus schrieb:

Bist du auch sicher, dass es klug ist, für Intervallvereinigung das Plus zu verwenden? Implementierst du das kommutativ?

Vereinigung ist kommutativ. Trotzdem ist es natürlich etwas merkwürdig dafür operator+ verwenden zu wollen..