| 11.10.2016, 18:04 |
Auf diesen Beitrag antworten » |
| Windows |
Wie greife ich darauf zu ? |
| |
| |
|
| 15.10.2016, 11:09 |
Auf diesen Beitrag antworten » |
| Windows |
ok habe jetzt zumindest die Fehler weg
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
|
#ifndef CTITLE_H_
#define CTITLE_H_
#include <string>
#include <iostream>
using namespace std;
/**
* Diese Klasse beschreibt einen MP3-kodierten Titel (Song).
*/
class CTitle
{
private:
/** Name (Titel) des Songs */
string m_name;
/** Ausführende(r) (Interpret, Gruppe, Orchester o. ä.) */
string m_performer;
/** Die Dauer des Titels in Sekunden. */
int m_duration;
/** Die Bitrate in bit/s. */
int m_bitRate;
/** Die Größe (Anzahl der Bytes) der Audiodaten. */
double m_contentSize;
public:
/**
* Erzeugt ein neues Objekt, dessen Attribute mit den angegebenen
* Werten initialisiert werden.
*
* Falls Name oder Ausführende(r) (performer) leer sind, werden
* die Default-Werte verwendet.
*
* Die Angabe der Bitrate erfolgt in bit/s.
*
* Die Bitrate muss zwischen 32000 und 320000 bit/s liegen.
* Falls diese Zusicherung verletzt wird, werden die Attribute
* m_bitRate, m_duration und m_contentSize auf 0 gesetzt.
*/
CTitle(int contentSize = 0, int duration = 0,
string name = "(Untitled)", string performer = "(Unknown)",
int bitRate = 128000);
/**
* Diese Methode liefert den Namen des Titels.
*/
string getName() const;
/**
* Diese Methode liefert den Ausführenden (Performer).
*/
string getPerformer() const;
/**
* Diese Methode liefert die Dauer (Länge) des Titels in Sekunden.
*/
int getDuration() const;
double getContentsize();
};
ostream& operator<< (ostream& lop, CTitle& rop);
#endif /* CTITLE_H_ */
|
|
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
CTitle::CTitle(int contentSize, int duration, string name, string performer, int bitRate)
{
//Die Bitrate muss zwischen 32000 und 320000 bit/s liegen.
if (bitRate >= 32000 && bitRate <= 320000)
{
m_contentSize = contentSize;
m_duration = duration;
m_bitRate = bitRate;
}
else
{
//Falls diese Zusicherung verletzt wird, werden die Attribute
//m_bitRate, m_duration und m_contentSize auf 0 gesetzt.
m_contentSize = 0;
m_duration = 0;
m_bitRate = 0;
}
}
string CTitle::getName() const
{
return m_name;
}
string CTitle::getPerformer() const
{
return m_performer;
}
int CTitle::getDuration() const
{
return m_duration;
}
double CTitle::getContentsize(){
return m_contentSize;
}
ostream& operator<< (ostream& lop, CTitle& rop){
lop<< &rop << " " << rop.getName();
lop<< "; " << rop.getPerformer();
lop<< " ; " << rop.getDuration();
lop << " s"; //Ausgabe um s erweitert
if (rop.getContentsize() > 9999 * 1024){ // > 9999 KiB
lop << rop.getContentsize() / (1024 * 1024) << " MiB";
}
else if (rop. getContentsize() > 9999){ // > 9999 B
lop << rop.getContentsize() / 1024 << " KiB";
}
else{
lop << rop.getContentsize() << " B";
}
return lop;
}
|
|
main
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
int main(){
CTitle a(0,2,"titlel","0",23456);
cout<< a <<endl;
}
|
|
Frage zu f)
Ich habe erst einmal jetzt ein Operator erstellt im Header:
CTitle operator+( CTitle right);
main 2 Titel erstellt
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
int main(){
CTitle a(0,2,"titlel","0",23456);
cout<< a <<endl;
CTitle b(0,3," BadBoy", "text", 66666);
|
|
Muss ich rgendwie auch den linken Operand erstellen ?
Wie ?
In der Aufgabe steht wenn die Bitrate nicht übereinstimmt ,den linken Operanden ausgeben .
WIe soll ich Bitrate vergleichen ?
So?
If( this.Bitrate != bitrate ???? |
| 15.10.2016, 16:47 |
Auf diesen Beitrag antworten » |
| Karlito |
Aufgabenteil f hast du nicht mit gepostet.
Gruß,
Karlito |
| 15.10.2016, 18:13 |
Auf diesen Beitrag antworten » |
| Windows |
Sorry gar nicht gemerkt 
|
| Anzeige |
| |
|
| 15.10.2016, 20:51 |
Auf diesen Beitrag antworten » |
| Karlito |
| Zitat: |
Original von Windows
Frage zu f)
Ich habe erst einmal jetzt ein Operator erstellt im Header:
CTitle operator+( CTitle right);
|
Schau dir noch mal an, wie Operatoren definiert sind und wie sie überladen werden. Teilweise kannst du bei "<<" spicken. Verstehe was lop und rop sind und wie Du das bei dem Operator + anwenden musst.
| Zitat: |
Original von Windows
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
int main(){
CTitle a(0,2,"titlel","0",23456);
cout<< a <<endl;
CTitle b(0,3," BadBoy", "text", 66666);
|
|
Muss ich rgendwie auch den linken Operand erstellen ?
Wie ?
In der Aufgabe steht wenn die Bitrate nicht übereinstimmt ,den linken Operanden ausgeben .
WIe soll ich Bitrate vergleichen ?
So?
If( this.Bitrate != bitrate ???? |
Der Operator "+" hat zwei Operanden. Du musst die Bitraten der beiden Operanden auslesen und vergleichen. Dazu zuerst, wie oben beschrieben, verstehen, wie Operatoren in C++ aufgebaut sind und wie man Operatoren überläd.
Gruß,
Karlito |
| 15.10.2016, 22:38 |
Auf diesen Beitrag antworten » |
| Windows |
Ja ich habe gelesen und verstanden das man z.B am ende auch a+b adieren kann .
Soll ich den linken operanden auch defineren so?
CTitle operator+( CTitle left);
Oder irgendwie mit this darauf zugreifen? |
| 16.10.2016, 17:48 |
Auf diesen Beitrag antworten » |
| Windows |
Hat jemand noch tipps ?
Weil selber komme ich leider nicht weiter und versuche programmieren zu lernen |
| 16.10.2016, 19:31 |
Auf diesen Beitrag antworten » |
| Karlito |
Du hast den <<-Operator mit zwei Operanden überladen. Überlade der Einfachheit halber doch den +-Operator auch mit zwei Operanden.
Gruß,
Karlito |
| 16.10.2016, 21:15 |
Auf diesen Beitrag antworten » |
| Windows |
Meinst du es so?
CTitle operator+( CTitle right);
CTitle operator-( CTitle left); |
| 16.10.2016, 21:36 |
Auf diesen Beitrag antworten » |
| Karlito |
Nee. Sowas:
| code: |
1:
2:
3:
|
CTitle& operator+(CTitle& lop, CTitle& rop);
|
|
Gruß,
Karlito |
| 16.10.2016, 22:03 |
Auf diesen Beitrag antworten » |
| Windows |
Wieso hat man das so gemacht Karlito?
Waren meine vorigen Ansätze falsch die ich gepostet hab ?
Sind das jetzt sozusagen die rechten und linken Operanden ?lop und rop? |
| 18.10.2016, 09:59 |
Auf diesen Beitrag antworten » |
| Karlito |
Es gibt mehere Möglichkeiten Operatoren zu überladen. Eine ist die, die Du gewählt hast. Dabei überläd man den Operator in der entsprechenden Klasse und bekommt nur einen Operanden übergeben. Der andere Operand ist ein Objekt der Klasse in der Du den Operator überlädst. Wichtig ist dabei wie gesagt, dass der Operator in der Klasse überladen wird.
Der allgemeine Weg Operatoren zu überladen ist außerhalb der Klasse. Dabei werden zwei Parameter übergeben. Der linke und der rechte Operand. Und ja, genau das sind lop und rop bei mir.
Gruß,
Karlito |
| 18.10.2016, 10:33 |
Auf diesen Beitrag antworten » |
| Windows |
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
|
Header:
CTitle& operator+(CTitle& lop, CTitle& rop);
cpp+:
CTitle::CTitle& operator+(CTitle& lop, CTitle& rop) {
if( wie soll ich in der Bedingung einbauen das die Bitrate nicht stimmt?
So ?( If bitrate!=bitrate ? wär ezu einfach :D
}
|
|
|
| 18.10.2016, 12:18 |
Auf diesen Beitrag antworten » |
| Karlito |
Greife auf die Getter für die entsprechenden Attribute der Operanden zu und vergleiche diese.
Gruß,
Karlito |
| 18.10.2016, 20:23 |
Auf diesen Beitrag antworten » |
| Windows |
Bin glaub ich fast fertig mit der f) .Nur noch zwei Probleme am Ende .
Warum werden die Fehler angezeigt?
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
|
/*
* CTitle.h
*
* Created on: 03.08.2016
* Author: VAIO
*/
#ifndef CTITLE_H_
#define CTITLE_H_
#include <string>
#include <iostream>
using namespace std;
/**
* Diese Klasse beschreibt einen MP3-kodierten Titel (Song).
*/
class CTitle
{
private:
/** Name (Titel) des Songs */
string m_name;
/** Ausführende(r) (Interpret, Gruppe, Orchester o. ä.) */
string m_performer;
/** Die Dauer des Titels in Sekunden. */
int m_duration;
/** Die Bitrate in bit/s. */
int m_bitRate;
/** Die Größe (Anzahl der Bytes) der Audiodaten. */
double m_contentSize;
public:
/**
* Erzeugt ein neues Objekt, dessen Attribute mit den angegebenen
* Werten initialisiert werden.
*
* Falls Name oder Ausführende(r) (performer) leer sind, werden
* die Default-Werte verwendet.
*
* Die Angabe der Bitrate erfolgt in bit/s.
*
* Die Bitrate muss zwischen 32000 und 320000 bit/s liegen.
* Falls diese Zusicherung verletzt wird, werden die Attribute
* m_bitRate, m_duration und m_contentSize auf 0 gesetzt.
*/
CTitle(int contentSize = 0, int duration = 0,
string name = "(Untitled)", string performer = "(Unknown)",
int bitRate = 128000);
/**
* Diese Methode liefert den Namen des Titels.
*/
string getName() const;
/**
* Diese Methode liefert den Ausführenden (Performer).
*/
string getPerformer() const;
/**
* Diese Methode liefert die Dauer (Länge) des Titels in Sekunden.
*/
int getDuration() const;
double getContentsize();
friend CTitle& operator+(CTitle& lop, CTitle& rop);
friend ostream& operator<< (ostream& lop, CTitle& rop);
};
#endif /* CTITLE_H_ */
|
|
cpp
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
CTitle::CTitle(int contentSize, int duration, string name, string performer, int bitRate)
{
//Die Bitrate muss zwischen 32000 und 320000 bit/s liegen.
if (bitRate >= 32000 && bitRate <= 320000)
{
m_contentSize = contentSize;
m_duration = duration;
m_bitRate = bitRate;
}
else
{
//Falls diese Zusicherung verletzt wird, werden die Attribute
//m_bitRate, m_duration und m_contentSize auf 0 gesetzt.
m_contentSize = 0;
m_duration = 0;
m_bitRate = 0;
}
}
string CTitle::getName() const
{
return m_name;
}
string CTitle::getPerformer() const
{
return m_performer;
}
int CTitle::getDuration() const
{
return m_duration;
}
double CTitle::getContentsize(){
return m_contentSize;
}
ostream& operator<< (ostream& lop, CTitle& rop){
lop<< &rop << " " << rop.getName();
lop<< "; " << rop.getPerformer();
lop<< " ; " << rop.getDuration();
lop << " s"; //Ausgabe um s erweitert
if (rop.getContentsize() > 9999 * 1024){ // > 9999 KiB
lop << rop.getContentsize() / (1024 * 1024) << " MiB";
}
else if (rop. getContentsize() > 9999){ // > 9999 B
lop << rop.getContentsize() / 1024 << " KiB";
}
else{
lop << rop.getContentsize() << " B";
}
return lop;
}
CTitle& operator+(CTitle& lop, CTitle& rop){
if(lop.m_bitRate != rop.m_bitRate){
cout << lop << endl;
}
if(lop.m_bitRate == rop.m_bitRate){
cout <<lop.m_name << endl;
}
if(lop.m_name == rop.m_name){
cout << lop.m_name+rop.m_name << endl;
}
if(lop.m_name != rop.m_name){
cout << lop.m_performer << ", "<< rop.m_performer;
}
m_duration = lop.m_duration + rop.m_duration;
m_contentSize = lop.m_contentSize + rop.m_contentSize;
}
|
|
main
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
|
#include "CTitle.h"
#include <string>
#include<iostream>
using namespace std;
int main(){
CTitle a(0,2,"titlel","0",23456);
cout<< a <<endl;
}
|
|
Description Resource Path Location Type
'm_contentSize' was not declared in this scope CTitle.cpp /CTitle line 107 C/C++ Problem
Description Resource Path Location Type
'm_duration' was not declared in this scope CTitle.cpp /CTitle line 106 C/C++ Problem
Description Resource Path Location Type
Symbol 'm_contentSize' could not be resolved CTitle.cpp /CTitle line 107 Semantic Error
Description Resource Path Location Type
Symbol 'm_duration' could not be resolved CTitle.cpp /CTitle line 106 Semantic Error |
| 19.10.2016, 12:21 |
Auf diesen Beitrag antworten » |
| Karlito |
Getter verwenden.
Gruß,
Karlito |
| 19.10.2016, 14:26 |
Auf diesen Beitrag antworten » |
| Windows |
Was meinst du mit getter ?
Die getter methode ist doch in der cpp eingebaut .
Soll ich irgendwie auf das getter zugreifen ? |
| 19.10.2016, 15:35 |
Auf diesen Beitrag antworten » |
| Karlito |
Schaue wie es bei << gemacht wird. |
| 19.10.2016, 15:50 |
Auf diesen Beitrag antworten » |
| Windows |
Was meinst du mit<<? |
| 19.10.2016, 16:07 |
Auf diesen Beitrag antworten » |
| Karlito |
Du hast den Operator << überladen. Schaue nach, wie es dort gemacht ist. |
| 19.10.2016, 16:22 |
Auf diesen Beitrag antworten » |
| Windows |
Soll ich einen lop davor << und dann ausgeben ? |
| 19.10.2016, 17:22 |
Auf diesen Beitrag antworten » |
| Karlito |
Nein, Du sollst schauen, wie Du beim Überladen des Operators getter verwendet hast. Wenn Du nicht weißt was ein getter ist, dann google es bitte.
Gruß,
Karlito |
| 19.10.2016, 17:30 |
Auf diesen Beitrag antworten » |
| Windows |
| code: |
1:
2:
3:
4:
5:
6:
|
m_duration = lop.getDuration() + rop.getDuration();
m_contentSize = lop.getContentsize()() + rop.getContentsize();
|
|
Funzt immer noch net 
|
| 19.10.2016, 17:49 |
Auf diesen Beitrag antworten » |
| Karlito |
Ich glaube das hat keinen Sinn. Wahrscheinlich ist es sinnvoller Du nimmst dir ein Buch und eine simplere Aufgabenstellung und wir klären hier Grundlagenfragen. Das hier läuft nur darauf hinaus, dass wir dir die Lösung zurechtbasteln, ohne dass Du es verstehst.
Wie auch schon euler sagte:
| Zitat: |
Original von eulerscheZahl
Es gibt da eine ziemlich große Lücke zwischen dem, was du kannst und dem, was du können sollst. |
Gruß,
Karlito |
| 19.10.2016, 17:59 |
Auf diesen Beitrag antworten » |
| Windows |
ja ich habe es ja probiert ,aber ich verstehe nicht so ganz wie ich den Fehler korriegieren kann 
|
| 20.10.2016, 08:22 |
Auf diesen Beitrag antworten » |
| Windows |
Einen kleinen Teil habe ich schon ipmlementiert :
const(CTitle operator+(const CTitle& duration,const CTitle&contentSize){
CTitle ret(duration);
ret+= contentSize;
return ret;
}
Bei += habe ich Probleme ? |
| 20.10.2016, 13:23 |
Auf diesen Beitrag antworten » |
| Windows |
Es ist auch in diesem Forum nicht gerade so ,dass man gerade von Fragen überschwemmt wird?
|
| 20.10.2016, 13:33 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Du machst einem das Helfen aber auch nicht gerade einfach. Du haust Syntaxfehler rein, die du eigentlich selbst erkennen solltest.
Hier z.B.:
| code: |
1:
|
m_contentSize = lop.getContentsize()() + rop.getContentsize(); |
|
Du schreibst bei getContentsize zwei Klammerpaare. Das ist einfach falsch. Ich weiß nicht, ob du das nicht besser kannst oder einfach unkonzentriert warst. Aber in beiden Fällen ist es problematisch - beim Programmieren muss eben jedes Zeichen richtig sein, damit das Programm funktioniert.
Deine Aufgabe ist Operatorüberladung (vom Schwierigkeitsgrad für Fortgeschrittene), aber du bringst immer wieder solche Anfängerfehler. Bei den Lücken in den Grundlagen sind solche Aufgaben eben schwierig.
Zu deiner letzten Frage:
ret+= contentSize;
du willst den + Operator überladen, da kannst du ihn nicht schon verwenden.
Und hier ist zwar nicht wirklich viel los, aber hauptsächlich werden die Fragen von Karlito und mir beantwortet. Wir haben eben auch noch andere Dinge zu tun. |
| 20.10.2016, 13:41 |
Auf diesen Beitrag antworten » |
| Windows |
Bei dem oberen Code war es ein Flüchtigkeitsfehler .
Aber na gut wenn niemand helfen möchte dann macht es auch keinen Sinn. |
| 20.10.2016, 21:12 |
Auf diesen Beitrag antworten » |
| WindowsisBack |
Zu deiner letzten Frage:
ret+= contentSize;
du willst den + Operator überladen, da kannst du ihn nicht schon verwenden.
Meinst du das ich das noch im Header definieren muss? |
| 21.10.2016, 06:11 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Nein.
Du schreibst in deinem Programm "man rechnet Plus, indem man Plus rechnet".
Ich habe nicht ausprobiert, was passiert. Entweder macht der Compiler das nicht mit oder das Programm ruft operator+ immer wieder auf, bis der Stack überläuft und das Programm abstürzt. |
| 21.10.2016, 08:44 |
Auf diesen Beitrag antworten » |
| Windows |
Was kann ich machen um das Problem zu beseitigen ?
Ich will jetzt einfach nur noch die Aufgabe abschließen
|
| 21.10.2016, 09:02 |
Auf diesen Beitrag antworten » |
| eulerscheZahl |
Ungetestet, ich habe das jetzt einfach im Texteditor geschrieben:
| code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
|
//warum nicht title1 und title2 als Namen? So finde ich das irreführend
const(CTitle operator+(const CTitle& duration,const CTitle& contentSize) {
//wenn die Bitraten nicht übereinstimmen, wird linker Operand zurückgegeben
if (duration.getBitRate() != contentSize.getBitRate()) return duration; //getBitRate musst du glaube ich noch implementieren
//der Name ist <name1>, <name2>
string newName = string(duration.getName()) + string(", ") + string(contentSize.getName());
string newPerformer = duration.getPerformer();
if (duration.getPerformer().compare(contentSize.getPerformer()) != 0) //strings sind verschieden
newPerformer += string(", ") + string(contentSize.getPerformer());
int length = duration.getDuration() + contentSize.getDuration();
int size = duration.getContentsize() + contentSize.getContentsize();
return new CTitle(size, length, newName, newPerformer, duration.getBitRate());
} |
|
Du musst schon explizit angeben, welche Variable welchen Inhalt kriegen soll. |
