✔ Operator << & >>

[Termos]

Ich möchte gern die Operatoren << und >> Überladen um in *proz Daten einzulesen.

Wie geh ich dabei vor? Habe nichts wirklich hilfreiches in der Suche gefunden.

Man soll in der Main dann solange Daten eingeben können bis man die Intervall grenze überschreitet ... und diese Dann auch wieder ausgeben ... Mein erster Ansatz war nen Array mit [anz] .. Die ist laut Aufgabe aber nicht bekannt ... Also dynamisch ;/

#include "stdafx.h"
#include <iostream>

using namespace std;


class fach{

private:

	int *proz;  //Intervall 0 - 100;
	unsigned long  *gew; // 0.0 - 10.0


public:
	fach(int a=0, unsigned long b=0.0):proz(a),gew(b){}

	fach &operator<<(const fach &f)
	{
		this->proz=new int[*proz];
		this->gew=new unsigned long[*gew];
	
	}

	

}

 

[ibafluss]

Die << und >> Operatoren musst du global erstellen und als friend. Also: friend fach& operator<<() und dann natürlich beide Argumente anschreiben (also den o/istream und das Fach).
Du kannst den Operator nicht als Member der class erstellen, da bei Memberoperatoren immer das linke Argument automatisch als this übergeben wird (d.h. links ist steht immer die class, in der der Operator definiert ist). Das linke Argument ist hier aber immer der i/ostream.

Lg

 

[Termos]

hab es jetzt so gemacht ->

#include "stdafx.h"
#include <iostream>

using namespace std;

class fach;
istream &operator>>(istream &cin,fach &x);

class fach{

private:
	int anz;
	int *proz;  //Intervall 0 - 100;
	double *gew; // 0.0 - 10.0


public:
	fach():proz(0),gew(0){}
	fach set_proz(int *s){this->proz = new int; proz=s; return *this;}
	fach set_gew(double *g){this->gew = new double; gew=g; return *this;}
	fach show(){

				cout<< "Zwischenausgabe: "<<'\t'<<proz<<'\t'<<gew;
		return *this;
	}

	

};







istream &operator>>(istream &cin,fach &x)
{
	int p;
	double g;
	do{
	
	cout<<"Eingabe proz: ";
	cin>>p;
	x.set_proz(p);
	cin.clear();cin.ignore(INT_MAX,'\n');

	cout<<"Eingabe gew: ";
	cin>>g;
	x.set_gew(g);
	cin.clear();cin.ignore(INT_MAX,'\n');
	}while(p>=0 && p<=100 && g>=0 && g<=10.0);
	return cin;
}

Nun hab ich ja für jedes eingegebene element nen neues angelegt ... die kann ich aber nicht einfach über den Index ansprechen .... !******! Ich weis aber auch vorher nicht wieviele eingegeben werden ... Wie kann ich das Lösen?

oder muss ist die static machen und einfach selber mit zählen wieviele es sind?


Das ist die Aufgabenstellung;(

Implementieren Sie die Klasse fach mit den private-Membern proz zum Speichern ganzzahliger vorzeichenloser
Prozentwerte aus dem Intervall [0 .. 100] und gew zum Speichern von reellen Gewichten aus dem Intervall [0.0
.. 10.0]. Der Konstruktor soll mit zwei Parametern und den Defaultwerten 0 und 0.0 beide Datenmember
initialisieren.
Ergänzen Sie die lesenden und schreibenden Methoden für die genannten Datenmember. Die Operatoren >>
bzw. << sollen zum Einlesen über cin bzw. zum Ausgeben über cout für Instanzen vom Typ fach überladen
werden. Beide Funktionen dürfen keine friends der Klasse fach sein ! Die Eingabe von proz bzw. gew soll so
lange wiederholt werden, bis 0<=proz<=100 bzw. 0.0<=gew<=10.0 gilt.

 

[sheel]

Hi

this->proz=new int[*proz];

ist Unsinn
Statt *proz gehört eine Zahl rein, die die Größe angibt.

Das this-> ist nur dann nötig, wenn es noch ein anderes proz gibt.
So ist es zwar kein Fehler, aber eben sinnlos.

this->proz = new int;

legt nur ein int an.
Du brauchst ja mehrere.


Unabhängig von der Anlegemethode kannst du danach nicht mit

proz = 123;

einen Wert zuweisen, sondern so:

*proz = 123;

Bei der Einzelmethode ist das eben für den einigen Wert,
eim Array für [0].
Sinnvoller für das Array wäre

proz[0] = 123;
proz[1] = 456;
...

Alles was mit new angelegt wird muss mit
delete bzw. delete[] für Arrays wieder gelöscht werden!
Konstruktor/Destruktor...


Zum Vergrößerungsproblem:
Wenn du unbedingt mit einem Array arbeiten willst
brauchst du zuerst mal eine weitere Variable,
in der du speicherst, wie groß dein Array ist.

Wenn es dann nicht mehr reicht legst du ein größeres Array an,
kopierst die vorhandene Werte vom Alten per Schleife in das Neue
und gibst auch noch den neuen Wert dazu. Dann entfernst du das Alte (zu kleine).

Das kann man auch geblockt machen, zB. bei der Vergrößerung gleich 100 Plätze mehr machen,
damit der Computer nicht so oft alles umkopieren muss. Gut für die Geschwindigkeit,
aber etwas schwieriger zu programmieren.
Dabei wird auch zusätzlich zu Arraygröße-Variable eine weiter nötig, wieviel Elemente eigentlich drin sind (bzw. wieviel freie Plätze es noch gibt, bevor wieder 100 dazugemacht müssen).


Eine schönere Lösung wäre da eine Liste...
Frage ist nur, ob ihr das schon kennengelernt habt bzw. verwenden dürft?

 

[Termos]

Jor Listen sind bekannt, allerdings ist die Aufgabenstellung, wie ich finde, nicht wirklich eineindeutig ;(

habe es nun ganz anders realisiert und bis zu dem Punkt ist es 80& lauffähig muss nur noch den Index operator Überladen und habe jetzt auch eine Anzahl mit der ich ein Array mit entsprechender größe Dynamisch Anlegen kann. Vielen Dank******************!

Hier noch meine Lösung für die Nachwelt (was die Operatoren angeht):

#include <iostream>
using namespace std;

//###############FACH#################
class Fach;
istream &operator>>(istream &cin ,Fach &x);
ostream &operator<<(ostream &cout, Fach &x);

class Fach{
private:
	int proz;
	double gew;

public:

	Fach()
	{
		this->proz=0;
		this->gew=0;
	}

	Fach(int p,double g):proz(0),gew(0.0)
	{
		proz=p;
		gew=g;
	}

	Fach get_values(){
		cout<<"Prozent: "<<proz<<'\n';
		cout<<"Gewicht: "<<gew<<'\n';

		return *this;
	}

	Fach set_values(int p,double g)
	{
		this->proz=p;
		this->gew=g;

		return *this;
	}

};


//#################Reihe##############

class Reihe
{
private:
	int anz;
	Fach *fv;
public:
	Reihe()
	{
		anz=0;
		cin>>*fv;
	}

	Reihe(size_t anz)
	{

		for(size_t i=0;i<anz;i++)
			cin>>fv[i];
	}

	~Reihe()
	{

		for(size_t i=0;i<anz;i++)
			delete [i]fv;
	}



};



//##############Globale Operatoren###############
istream &operator>>(istream &cin, Fach &x)
{
	int prozent;
	double gewicht;

	do
	{
	cout<<"Eingabe Prozent: ";
	cin>>prozent;
	cin.clear();cin.ignore(INT_MAX,'\n');
	}while(prozent<=0 || prozent>=100);
	do
	{
	cout<<"Eingabe Gewicht: ";
	cin>>gewicht;
	cin.clear();cin.ignore(INT_MAX,'\n');
	}while(gewicht<=0 || gewicht >=10);
	x.set_values(prozent,gewicht);

	return cin;

};


ostream &operator<<(ostream &cout, Fach &x)
{
	x.get_values();
	return cout;
}





void main()
{
	Fach x;
	cin>>x;
	cout<<x;
	cin.get();
}

 

[sheel]

Zu Fach:
Gib bei get_values und set_values ein Fach& zurück.

Fach &get_values()

Und bei Reihe kann einiges nicht funktionieren.

Fach *fv;
...
cin>>*fv; //Im Konstruktor

bringt einen Absturz, weil der Pointer auf nichts zeigt.
Ebenso

cin>>fv[i];

Und hier

delete [i]fv;

meinst du

delete[] fv;

oder

delete fv[i];

?

 

[Termos]

Kannst du mir das Fach &Values erklären? - der return wert bleibt *this?


Reihe hab ich erst mal nur hingeklatscht um was dastehen zu haben ... noch keine grundlegende iIdee wie ich das realisiere da laut Aufgabenstellung ->

Der parameterlose Konstruktor soll beide Datenmember mit 0 initialisieren und das aktuelle Objekt mittels
des überladenen Operators >> über cin einlesen.
Überladen Sie den Konstruktor seitens eines zweiten Konstruktors mit einem ganzzahligen vorzeichenlosen
Parameter, der die Anzahl anz der Vektorelemente initialisiert und fv mit dieser Anzahl dynamisch instantiiert.
Im Falle des Parameterwertes 0 soll fv mit dem Zeigerwert 0 initialisiert werden.

 

[ibafluss]

Rückgabewert Fach& bedeutet einfach, dass eine Fach-Referenz zurückgegeben wird (sieht gleich aus, wie die Rückgabe by value). Es wird also im main() kein neues Objekt erstellt, sondern weiter mit dem Objekt in der Funktion gearbeitet.

Lg