P.roblem s.olved :)

[c.groupe]

unskilled schrieb:

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.

[c.groupe]

wow ihr seit ja echt spitze, ich muss mir das aber nun weiter mal in ruhe anschauen, kann es echt nicht so schnell nachvollziehen, also nicht sauer sein, wenn ich nicht gleich antworte. dennoch vielen dank schonmal an alle..

[c.groupe]

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);

[unskilled]

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...

[SeppJ]

c.groupe schrieb:

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.

[c.groupe]

ist ja gut ..

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

[varginator]

Kurze anmerkung:

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

[life]

Und die Zeilen 14-15 müssen in unskilled code auch noch weg

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..

[Sebastian Pizer]

unskilled schrieb:

#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;
	}
:
:

Das upper_bound = lower_bound; führt dazu, dass isEmpty() false liefert. Es scheint, als kann es keine Intervalle geben, die "empty" sind.

Der Aufgabensteller gehört dafür verprügelt, dass er für Vereinigung und Durchschnitt operator+ und operator- benutzen will.

[knivil]

//[x, x] kann nicht keine Werte enthalten, da x dazu gehört

Ich liebe doppelte Verneinungen ... wie waere es mit: [x,x] ist nicht leer, da x enthalten ist.

Ich empfinde den Operator + nicht als Fehlgriff. Ist halt 'ne Algebra auf Paare von reelen Zahlen.

[c.groupe]

So ich hab mir das durchgelesen aber verstehe es immer noch nicht,
es ist keine hausaufgabe oder sonst was ich lerne einfach nur für ne c++ klausur ..

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

#ifndef INTERVAL_H_
#define INTERVAL_H_

class Intervall
{

	public:
		double a,e;
		Intervall(const double &a, const double &e);
		bool isEmpty() const;
		bool contains(const double & wert) const;
		const Intervall Intervall::plus(Intervall const &j) const;
		const Intervall Intervall::minus(Intervall const &j) const;
};

#endif /* INTERVAL_H_ */

/*
 * Intervall.cpp
 *
 *  Created on: 15.09.2009
 *      Author: c.groupe
 */

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

Intervall::Intervall(const double &a, const double &e): a(a), e(e)
{
	if (e > a)
	{
		this ->a = a;
		this ->e = e;
	}
	else
	{
	cerr << "Leeres Intervall";
	this ->a = 100;
	this ->e = 0;
	}
}

bool Intervall::isEmpty() const
{
	return (a >= e);
}

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

const Intervall operator+(const Intervall &i, const Intervall &j)
{

	if (i.isEmpty()) return Intervall(j.a,j.e);
	if (j.isEmpty()) return Intervall(i.a,i.e);

	double min_a = (i.a < j.a) ? i.a : j.a;
	double max_e = (i.e > j.e) ? i.e : j.e;
	return 	Intervall(min_a,max_e);
}

const Intervall operator-(const Intervall &i, const Intervall &j)
{
	if (i.isEmpty()) return Intervall(j.a,j.e);
	if (j.isEmpty()) return Intervall(i.a,i.e);

	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);
}

/*
 * main.cpp
 *
 *  Created on: 16.09.2009
 *      Author: c.groupe
 */

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

int main()
{
    Intervall i(0,5), j(6,20);
}

edit:
es werden keine fehler mehr angezeigt, aber es ist sichern noch nicht ganz richtig, bin gerade am überlegen, wie ich es am besten testen kann.

[SeppJ]

c.groupe schrieb:

edit:
es werden keine fehler mehr angezeigt, aber es ist sichern noch nicht ganz richtig, bin gerade am überlegen, wie ich es am besten testen kann.

Die Frage ist leicht zu beantworten: Mit einem Debugger! Das beste Mittel um Fehler in der Programmlogik zu finden.

[_matze]

SeppJ schrieb:

c.groupe schrieb:

edit:
es werden keine fehler mehr angezeigt, aber es ist sichern noch nicht ganz richtig, bin gerade am überlegen, wie ich es am besten testen kann.

Die Frage ist leicht zu beantworten: Mit einem Debugger! Das beste Mittel um Fehler in der Programmlogik zu finden.

Genau. Für das Visual Studio gibt's zu dem Thema übrigens einen guten Artikel:

http://magazin.c-plusplus.net/artikel/Debuggen mit VCPlusPlus6
(bezieht sich zwar auf's VS6, das meiste kann man aber einfach auf neuere Versionen anwenden)

[unskilled]

@varginator
jopp

@life
ne, das is aufgabenstellung - nur ist das eben nicht anders zu machen, da isEmpty so komisch definiert wurde...

@c.groupe:
du hast viele fehler gemacht, die dir schon mal jmd berichtigt hatte...
außerdem hast du das mit der initialisierungsliste nicht ganz verstanden, wie mir scheint
und das geheimnisprinzip (was in der aufgabenstellung so gar iwo erwähnt wurde) hast du komplett ignoriert...
du könntest auch mal sprechende variablennamen nutzen
auch hatte ich nix von einer ausgabe im ctor gelesen...

op+ verstehe ich anders - es ist egal, ob das intervall leer ist oder nicht. aber wie gesagt: die aufgabenstellung ist extrem schwammig, also hier könntest du noch recht haben, allerdings kannst du das erste const mal wegmachen, das ist sinnlos^^

const Intervall operator+(const Intervall &i, const Intervall &j)
{

    if (i.isEmpty()) return Intervall(j.a,j.e);
    if (j.isEmpty()) return Intervall(i.a,i.e);

    double min_a = (i.a < j.a) ? i.a : j.a;
    double max_e = (i.e > j.e) ? i.e : j.e;
    return     Intervall(min_a,max_e);
}

das hier würde ich dagegen als falsch ansehen...
leeres intervall - nicht leeres intervall = nicht leeres intervall?
eher nicht... wieso versucht du überhaupt, diese fälle abzufangen?
es reicht absolut so, wie ich es oben gemacht habe...

const Intervall operator-(const Intervall &i, const Intervall &j)
{
    if (i.isEmpty()) return Intervall(j.a,j.e);
    if (j.isEmpty()) return Intervall(i.a,i.e);

    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);
}

op+ und op- zu benutzen find ich btw nicht so extrem schlimm - schlimmer ist der rest

bb

[c.groupe]

ich mach alles schoen mit eclipse aber danke!

[life]

unskilled schrieb:

@life
ne, das is aufgabenstellung - nur ist das eben nicht anders zu machen, da isEmpty so komisch definiert wurde...

Kannst du das erläutern? Finde in der Aufgabenstellung gerade kein Hinweis darauf, dass man aus z.B. dem Intervall [5,4] das Intervall [5,5] machen soll.

[unskilled]

life schrieb:

unskilled schrieb:

@life
ne, das is aufgabenstellung - nur ist das eben nicht anders zu machen, da isEmpty so komisch definiert wurde...

Kannst du das erläutern? Finde in der Aufgabenstellung gerade kein Hinweis darauf, dass man aus z.B. dem Intervall [5,4] das Intervall [5,5] machen soll.

"Wenn der rechte grenzwert kleiner als der linke Grenzwert ist, so soll dies ein leeres Intervall darstellen"
Das problem dabei ist eben nur, dass es kein leeres _abgeschlossenes_ Intervall gibt - also hab ichs so gemacht - kein Plan, was sich der Aufgabensteller dabei gedacht hatte...

[life]

unskilled schrieb:

"Wenn der rechte grenzwert kleiner als der linke Grenzwert ist, so soll dies ein leeres Intervall darstellen"
Das problem dabei ist eben nur, dass es kein leeres _abgeschlossenes_ Intervall gibt - also hab ichs so gemacht - kein Plan, was sich der Aufgabensteller dabei gedacht hatte...

Da steht doch garnichts von "abgeschlossen". Aber abgesehen davon, ist [5,4] = \emptyset durchaus abgeschlossen (+offen) und stellt offenbar ein leeres Intervall dar. Ich sehe da kein Problem.

[unskilled]

Da steht doch garnichts von "abgeschlossen".

Doch - [x, y] ist abgeschlossen

Hmm - stimmt... So hab ich das noch gar nicht gesehen : D
Dann hab ich ganz um sonst über die Aufgabenstellung geflamt, nur weil ich zu doof war, die zu verstehen... -.- Hat der OT mich mit seinem Code zu doll irritiert^^

#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)
	{}

	bool isEmpty() const
	{
		return lower_bound > upper_bound;
	}

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

	interval operator+ (const interval &other) const
	{
		if(isEmpty()) return other;
		if(other.isEmpty()) return *this;

		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
	{
		if(isEmpty()) return *this;
		if(other.isEmpty()) return other;

		T lower = std::max(lower_bound, other.lower_bound);
		T upper = std::min(upper_bound, other.upper_bound);
		return interval(lower, upper);
	}
};

bb

[Ergotherapeut]

life schrieb:

Da steht doch garnichts von "abgeschlossen".

Und genau hier sehe ich das Problem. Wie soll man ein "contains" implementieren, wenn man nicht weiß ob man ein abgeschlossenes oder offenes Intervall implementieren soll? Und mit dem doofen Beispiel ganz oben ("Das Intervall [3.3,47]") suggeriert man den Wunsch nach einem offenen Intervall.