P.roblem s.olved :)

[_matze]

Sorry, aber noch immer fehlt eine konkrete Fragestellung.

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.

[c.groupe]

stimmt.. gut ist gefixt, aber das ist auch nicht grad mein problem

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

class Name
{
   ....

   Datentyp operator+(argumentliste);
}

bekomms irgendwie nicht gebacken ..

[c.groupe]

/*
 * 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);
		Intervall operator+();
		Intervall operator-();

};

#endif /* INTERVAL_H_ */

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 ?

[lalilo]

Intervall operator+(const Intervall& other);

... So wird das dann verwendet:
Intervall i1, i2;
Intervall i3 = i1 + i2;

[Nexus]

Auf dieser Seite gibts einen Artikel zur Operatorüberladung, der eine gute Einführung in die Thematik liefert und sowohl syntaktische als auch stilistische Aspekte anspricht. Zum Beispiel steht dort, dass man den binären operator+ im Allgemeinen global deklarieren sollte.

[_matze]

Aha, deine Frage ist also, wie man Operatoren überlädt? Also das mit dem Fragenstellen musst du echt noch üben...

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

[unskilled]

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

[c.groupe]

gut das hab ich grad auch rausgekommen, danke für die hilfe.
aber ich muss doch zwei intervalle damit verarbeiten oder ist das nun ein denkfehler meinerseits ?

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 ?

[Nexus]

Lies bitte den Artikel, das sind wirklich Grundlagen. Bist du auch sicher, dass es klug ist, für Intervallvereinigung das Plus zu verwenden? Implementierst du das kommutativ? Denke einfach an den verwirrten Anwender, der sich mit der Bedeutung zurechtfinden muss (und wenn das nur du selbst bist).

[lodiladi]

c.groupe schrieb:

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

[c.groupe]

okay der artikel ist echt nicht schlecht ..

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

[SeppJ]

Hast ein paar Fehler, sieht aber prinzipiell nach einem guten Ansatz aus.

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

[unskilled]

sry, dass ich jz wieder HAs mach, aber die lange Weile...

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

[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