Ausgabe funktioniert leider Gottes nicht!

Hi, warum Funktioniert meine Ausgabe nicht? Ich verstehe es nicht. Sind dort Denkfehler drin?
Hier der Code:

#include <iostream>
#include <string>
#include <conio>
using namespace std;

//--------------------------------------------------------------------------------------------------

FILE *Verwaltungs_Datei;

class cd                // Klassenname                                                                                                                                                           
{
private:
        int cd1;     
        string datum;
        string titel;
        string interpret;
        string genre;

public:                        // Methoden (Funktionen)
        void menu();
        void eingabe();
        void speichern();
        void umschreiben();
        void ausgabe();

         cd();
         cd(string, string, string, string, int);
        ~cd();
};

//--------------------------------------------------------------------------------------------------

cd::cd()              // Standardkonstruktor
{}

cd::cd(string D, string T, string I, string G,int C)   // Definierter Konstruktor
{
        datum     =  D;
        titel     =  T;
        interpret =  I;
        genre     =  G;
        cd1       =  C;
}

cd::~cd()                          // Destruktor
{
}

//--------------------------------------------------------------------------------------------------

void cd::menu()
{
cout << "1. Eingabe" << endl;
cout << "2. Ausgabe" << endl;
cout << "3. Beenden" << endl;
cout << "Eingabe:";

int Start;
cin >> Start;
clrscr();

     switch (Start)                             // Switch-Case-Anweisung
     {
      case 1: eingabe(); break;         
      case 2: ausgabe(); break;         
      case 3: exit(1);   break;
      default  : cout << "Ungueltige Eingabe";           
     }
}

//--------------------------------------------------------------------------------------------------

void cd::eingabe()
{
string D, T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");

int insert;
cout << "Wieviel CD's: ";
cin >> insert;

int i;
cd *cd1[100];
for(i=0;i<insert;i++)
{
cd1[insert] = new cd[insert];

cout << "Bitte geben sie das Datum der CD " <<i+1 << " ein ?"<<endl;
cin>> D;
cout << "Bitte geben sie den Titel der CD " <<i+1 << "  ein ?"<<endl;
cin >> T;
cout << "Bitte geben sie den Interpret der CD " <<i+1 << "  ein ?"<<endl;
cin >> I;
cout << "Bitte geben sie den Genre der CD " <<i+1 << "  ein ?"<<endl;
cin >>G;

fwrite(&cd1[i],sizeof(cd1[i]),1,Verwaltungs_Datei);
}
fclose(Verwaltungs_Datei);
cout << "\nGespeichert";
getch();
clrscr();
menu();
}
//--------------------------------------------------------------------------------------------------

void cd::ausgabe()
{   
   int i,insert; 
   string D, T, I, G;
   Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");
   fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);

   for(i=0;i<insert;i++)
   {
   cout << "Ausgabe des Datums von CD " << insert << " :"       << cd1[i].D <<endl;
   cout << "Ausgabe des Titels von CD " << insert << " : "      << cd1[i].T <<endl;
   cout << "Ausgabe des Interpreten von CD " << insert << " : " << cd1[i].I <<endl;                             
   cout << "Ausgabe des Genres von CD " << insert << " : "      << cd1[i].G <<endl;
   i++;
   }
   //fread(&cd1[j], sizeof(cd1[j]), 1, Verwaltungs_Datei);                                                               
   fclose(Verwaltungs_Datei);
   cout<<"Weiter mit beliebiger Taste..."<<endl;
   getch();
   clrscr();
   menu();   
   }

//--------------------------------------------------------------------------------------------------

int main()
{  
  cd cd1;
  cd1.menu(); 
  cd1.eingabe();
  cd1.ausgabe();
  getchar();
  return 0;
}

Hier die Fehlermeldung meines Programms:

Fehler E2062 113: Unzulässiger Indirektionsoperator
Fehler E2062 113: Unzulässiger Indirektionsoperator
Fehler E2109 113: Unzulässiger Typ
Fehler E2062 117: Unzulässiger Indirektionsoperator
Fehler E2062 118: Unzulässiger Indirektionsoperator
Fehler E2062 119: Unzulässiger Indirektionsoperator
Fehler E2062 120: Unzulässiger Indirektionsoperator

otze

int cd1;
das ist kein array

randa

Achso, mal schnell c++ gelernt?

otze schrieb:

int cd1;
das ist kein array

Versteh ich nicht? Meinste das unter private:?

Bollek schrieb:

otze schrieb:

int cd1;
das ist kein array

Versteh ich nicht? Meinste das unter private:?

oben deklarierst du int cd1.
unten verwendest du ein (nichtexistentes) array cd1.

otze

arrgh
ändere bitte was an deiner namensgebung:

//ganz oben
int cd1; 
//etwas weiter drunter in cd eingabe
cd *cd1[100];
//noch weiter drunter in cd ausgabe:
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);//an der stelle ist cd1 wieder ein int
//und dann nochmal in der main
cd cd1;

fällt dir was auf?

otze schrieb:

arrgh
ändere bitte was an deiner namensgebung:

//ganz oben
int cd1; 
//etwas weiter drunter in cd eingabe
cd *cd1[100];
//noch weiter drunter in cd ausgabe:
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);//an der stelle ist cd1 wieder ein int
//und dann nochmal in der main
cd cd1;

fällt dir was auf?

Spontan fällt mir nichts auf! Aber Danke!

Hier, ich hab nen bissl gebastelt und nur noch EINEN Fehler!

#include <iostream>
#include <string>
#include <conio>
using namespace std;

//--------------------------------------------------------------------------------------------------

FILE *Verwaltungs_Datei;

class cd                       // Klassenname                                                                                                                                                           
{
private:
        int cd1;     
        string titel;
        string interpret;
        string genre;

public:                        // Methoden (Funktionen)
        void menu();
        void eingabe();
        void speichern();
        void umschreiben();
        void ausgabe();

         cd();
         cd(string, string, string);
        ~cd();
};

//--------------------------------------------------------------------------------------------------

cd::cd()                                               // Standardkonstruktor
{}

cd::cd(string T, string I, string G,)                  // Definierter Konstruktor
{
        titel     =  T;
        interpret =  I;
        genre     =  G;
}

cd::~cd()                                              // Destruktor
{
}

//--------------------------------------------------------------------------------------------------

void cd::menu()
{
cout << "1. Eingabe" << endl;
cout << "2. Ausgabe" << endl;
cout << "3. Beenden" << endl;
cout << "Eingabe:";

int Start;
cin >> Start;
clrscr();

     switch (Start)                             // Switch-Case-Anweisung
     {
      case 1: eingabe(); break;         
      case 2: ausgabe(); break;         
      case 3: exit(1);   break;
      default: cout << "Ungueltige Eingabe";           
     }
}

//--------------------------------------------------------------------------------------------------

void cd::eingabe()
{
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");

int insert;
cout << "Wieviel CD's: ";
cin >> insert;

int i;
cd *cd1[100];

   for(i=0;i<insert;i++)
   {
   cd1[insert] = new cd[insert];

   cout << "Bitte geben sie den Titel der CD "     <<i+1 << "  ein "<<endl;
   cin >> T;
   cout << "Bitte geben sie den Interpret der CD " <<i+1 << "  ein "<<endl;
   cin >> I;
   cout << "Bitte geben sie den Genre der CD "     <<i+1 << "  ein "<<endl;
   cin >> G;

   fwrite(&cd1[i],sizeof(cd1[i]),1,Verwaltungs_Datei);

   }
fclose(Verwaltungs_Datei);
cout << "\nGespeichert";
getch();
clrscr();
menu();
}
//--------------------------------------------------------------------------------------------------

void cd::ausgabe()
{   
int i,insert; 
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);

   for(i=0;i<insert;i++)
   {
   cout << "Ausgabe des Titels von CD " << insert << " : "      << cd1[i].T <<endl;
   cout << "Ausgabe des Interpreten von CD " << insert << " : " << cd1[i].I <<endl;                             
   cout << "Ausgabe des Genres von CD " << insert << " : "      << cd1[i].G <<endl;
   i++;
   }

fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);                                                               
fclose(Verwaltungs_Datei);
cout<<"Weiter mit beliebiger Taste..."<<endl;
getch();
clrscr();
menu();   
}

//--------------------------------------------------------------------------------------------------

int main()
{  
  cd cd1;
  cd1.menu(); 
  cd1.eingabe();
  cd1.ausgabe();
  getchar();
  return 0;
}

Als Fehler zeigt er an:

Fehler E2258 35: Deklaration erwartet

phlox81

Zeile 35 da ist ein Komma zuviel.

Danke dir... !

Ich fixe das halt so und will das starten kommen da die selben s***** Fehler

arrg Verdammt

Fehler E2062 110: Unzulässiger Indirektionsoperator
Fehler E2062 110: Unzulässiger Indirektionsoperator
Fehler E2109 110: Unzulässiger Typ
Fehler E2062 114: Unzulässiger Indirektionsoperator
Fehler E2062 115: Unzulässiger Indirektionsoperator
Fehler E2062 116: Unzulässiger Indirektionsoperator
Fehler E2062 120: Unzulässiger Indirektionsoperator
Fehler E2062 120: Unzulässiger Indirektionsoperator
Fehler E2109 120: Unzulässiger Typ

otze

*weist noch mal ganz dezent auf seine letzte aussage hin*

Hm.. ich hab mir nochmal Ueberlegt was du meinen koenntest. Meinst du vllt. das ich nicht! ueberall die selben Namen verwenden sollte?

Ansonsten klappt es bis jetzt, hab bei der Ausgabe bei fread die [i]`s weggenommen
ABER er gibt nicht wirklich was aus.!

#include <iostream>
#include <string>
#include <conio>
using namespace std;

//--------------------------------------------------------------------------------------------------

FILE *Verwaltungs_Datei;

class cd                       // Klassenname                                                                                                                                                           
{
private:
        int cd1;     
        string titel;
        string interpret;
        string genre;

public:                        // Methoden (Funktionen)
        void menu();
        void eingabe();
        void speichern();
        void umschreiben();
        void ausgabe();

         cd();
         cd(string, string, string);
        ~cd();
};

//--------------------------------------------------------------------------------------------------

cd::cd()                                               // Standardkonstruktor
{}

cd::cd(string T, string I, string G)                  // Definierter Konstruktor
{
        titel     =  T;
        interpret =  I;
        genre     =  G;
}

cd::~cd()                                              // Destruktor
{
}

//--------------------------------------------------------------------------------------------------

void cd::menu()
{
cout << "1. Eingabe" << endl;
cout << "2. Ausgabe" << endl;
cout << "3. Beenden" << endl;
cout << "Eingabe:";

int Start;
cin >> Start;
clrscr();

     switch (Start)                             // Switch-Case-Anweisung
     {
      case 1: eingabe(); break;         
      case 2: ausgabe(); break;         
      case 3: exit(1);   break;
      default: cout << "Ungueltige Eingabe";           
     }
}

//--------------------------------------------------------------------------------------------------

void cd::eingabe()
{
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");

int insert;
cout << "Wieviel CD's: ";
cin >> insert;

int i;
cd *cd1[100];

   for(i=0;i<insert;i++)
   {
   cd1[insert] = new cd[insert];

   cout << "Bitte geben sie den Titel der CD "     <<i+1 << "  ein "<<endl;
   cin >> T;
   cout << "Bitte geben sie den Interpret der CD " <<i+1 << "  ein "<<endl;
   cin >> I;
   cout << "Bitte geben sie den Genre der CD "     <<i+1 << "  ein "<<endl;
   cin >> G;

   fwrite(&cd1[i],sizeof(cd1[i]),1,Verwaltungs_Datei);

   }
fclose(Verwaltungs_Datei);
cout << "\nGespeichert";
getch();
clrscr();
menu();
}
//--------------------------------------------------------------------------------------------------

void cd::ausgabe()
{   
int i,insert;
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");
fread(&cd1, sizeof(cd1), 1, Verwaltungs_Datei);

   for(i=0;i<insert;i++)
   {
   cout << "Ausgabe des Titels von CD " << insert << " : " << cd1 <<endl;
   cout << "Ausgabe des Interpreten von CD " << insert << " : "<< cd1 <<endl;
   cout << "Ausgabe des Genres von CD " << insert << " : " << cd1<<endl;
   }

   fread(&cd1, sizeof(cd1), 1, Verwaltungs_Datei);
fclose(Verwaltungs_Datei);
cout<<"Weiter mit beliebiger Taste..."<<endl;
getch();
clrscr();
menu();
}

//--------------------------------------------------------------------------------------------------

int main()
{  
  cd cd1;
  cd1.menu(); 
  cd1.eingabe();
  cd1.ausgabe();
  getchar();
  return 0;
}

otze

der fehelr wäre auf jedenfall nicht passiert, wenn du eine anständige namensgebung hättest.

ok, ich erklärs dir:

class cd                       // Klassenname                                                                                                                                                          
{
private:
        int cd1; 
//...
};

hier sagst du, dass cd1 ein int wert sein soll, kein array oder was anderes.

void cd::eingabe()
{
//...
cd *cd1[100];
//...
}

hier deklarierst du eine neue Variable mit dem gleichen namen, und füllst dieses array mit werten. Am ende der Funktion gehen diese Werte unweigerlich verloren, weil cd1 dort nur LOKAL ist. Am ende der funktion ist es weg.
hättest du oben in der Klasse cd1 nicht als int, sondern gleich als cd* cd1[100] benannt, dann hättest du dieses problem jetzt nicht(im gegenteil, du hättest die variable gleich benutzen können)

aber es geht noch weiter:

void cd::ausgabe()
{  
//...   
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei); 
//...
}

du willst wahrscheinlich auf das array aus der eingabe zugreifen, das geht aber nicht, da cd1 hier nur als normales int deklariert ist, und somit auch kein array->Fehler E2062 110: Unzulässiger Indirektionsoperator.

Hallo,

da sind noch eine ganze Menge Fehler drin:
1. Was macht die Zeile?

cd1[insert] = new cd[insert];

Die legt in der Schleife jedesmal an der Stelle cdl[insert] ein neues Array mit insert Elementen an? Das ist sicherlich nicht gewollt.

Den ganzen Pointerkram weglassen und die Schleife so machen:

for(i=0;i<insert;i++)
   {
     cd neueCd;

   cout << "Bitte geben sie den Titel der CD "     <<i+1 << "  ein "<<endl;
   cin >> neueCd.T;
   cout << "Bitte geben sie den Interpret der CD " <<i+1 << "  ein "<<endl;
   cin >> neueCd.I;
   cout << "Bitte geben sie den Genre der CD "     <<i+1 << "  ein "<<endl;
   cin >> neueCd.G;

//   fwrite(&cd1[i],sizeof(cd1[i]),1,Verwaltungs_Datei); das geht sowieso nicht
   // hier eine neue Funktion zum schreiben der CD machen
   }

2. Wie schon gesehen, liest Du den Titel usw. in die private Elemente Deiner aktuellen Instanz ein. Schreiben tust Du aber irgendwas aus Deinem Array. Auf Deine aktuelle Instanz kannst Du mit

this

zugreifen. (Brauchst Du aber nicht, siehe oben)

3. fwrite/fread ist keine gute Idee. Das schreibt/liest die Daten wie sie im Speicher liegen. Wenn die Klasse std::string einen Pointer verwendet (und das wird sie), wird die Adresse weggeschrieben und nicht der Inhalt. Der ist dann beim Lesen futsch.
Funktionieren tut es, wenn Du die Daten als Text rausschreibst. Das Lesen ist dann ein bisschen schwieriger (Deine Titel/Interpreten könnten Leerzeichen enthalten). Ein mögliches Format wäre sowas wie CSV. Das könnte dann so aussehen:
"Titel";"Interpret";"Genre1"
"Titel2";"Interpret2";"Genre2"
Falls ein " in einem der Texte auftaucht, verdoppeln (muss natürlich beim Einlesen entfernt werden).

4. Trenn Deine Benutzerführung (menu,eingabe,ausgabe) von Deiner Datenhaltung (die Klasse cd). Die Klasse cd könnte so aussehen (nur als Beispiel und damit es überhaupt eine Klasse ist):

class Cd {
public:
  Cd( const std::string& derTitel, const std::string& derInterpreter,
      const std::string& dasGenre);
  void schreiben( ostream& out) const;
  void lesen( ostream& in);
private: 
  std::string title;  // bevorzuge _title, ist aber hier nicht gern gesehen
  std::string interpreter;
  std::string genre;
};

Nutzen kannst Du das dann z.B.

void eingabe()  // kein member von cd !!!
{
  // hier die Abfrage wieviele
  ofstream out( dateiname); // appendflag nicht vergessen
  for( int i = 0; i < insert; ++i) {
    string t, i, g;
    cin >> t;
    cin >> i;
    cin >> g;

    Cd neueCd( t, i, g);
    neueCd.schreibe( out);
  }
}

Die Benutzerführung kannst Du entweder als einfache Routinen machen, oder in eine zweite Klasse (die es aber nur genau einmal gibt; und die nicht allzuviel Sinn macht).

5. Variable insert in Deiner Routine cd::ausgabe ist nicht intialisiert (sollte eigentlich der Compiler merken und warnen) und wird benutzt.

6. das Verwirrspielchen mit cdl ist ja schon angesprochen worden.
Genaues Hinschauen verrät, dass Du in der Routine cd::ausgabe die Variable cdl einmal als Integer (this->cdl) verwendest und dann gerne als Zeiger auf eine cd verwenden möchtest (2. fread).

Danke euch.. aber ich bin mal bei otze`s Ansätzen geblieben
Ich hab etwas geändert:

#include <iostream>
#include <string>
#include <conio>
using namespace std;

//--------------------------------------------------------------------------------------------------

FILE *Verwaltungs_Datei;

class cd                       // Klassenname                                                                                                                                                           
{
private:
        cd *cd1[100];          // Zeiger erzeugt mit 100 dynam. Werten
        string titel;
        string interpret;
        string genre;

public:                        // Methoden (Funktionen)
        void menu();
        void eingabe();
        void speichern();
        void umschreiben();
        void ausgabe();

         cd();
         cd(string, string, string);
        ~cd();
};

//--------------------------------------------------------------------------------------------------

cd::cd()                                               // Standardkonstruktor
{}

cd::cd(string T, string I, string G)                  // Definierter Konstruktor
{
        titel     =  T;
        interpret =  I;
        genre     =  G;
}

cd::~cd()                                             // Destruktor
{
}

//--------------------------------------------------------------------------------------------------

void cd::menu()
{
cout << "1. Eingabe" << endl;
cout << "2. Ausgabe" << endl;
cout << "3. Beenden" << endl;
cout << "Eingabe:";

int Start;
cin >> Start;
clrscr();

     switch (Start)                             // Switch-Case-Anweisung
     {
      case 1: eingabe(); break;         
      case 2: ausgabe(); break;         
      case 3: exit(1);   break;
      default: cout << "Ungueltige Eingabe";           
     }
}

//--------------------------------------------------------------------------------------------------

void cd::eingabe()
{
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","w");

int insert;
cout << "Wieviel CD's: ";
cin >> insert;

int i;

   for(i=0;i<insert;i++)
   {
   cd1[insert] = new cd;
   cout << "Bitte geben sie den Titel der CD "     <<i+1 << "  ein "<<endl;
   cin >> T;
   cout << "Bitte geben sie den Interpret der CD " <<i+1 << "  ein "<<endl;
   cin >> I;
   cout << "Bitte geben sie den Genre der CD "     <<i+1 << "  ein "<<endl;
   cin >> G;
   fwrite(&cd1[i],sizeof(cd1[i]),1,Verwaltungs_Datei);
   }

fclose(Verwaltungs_Datei);
cout << "\nGespeichert";
getch();
clrscr();
menu();
}
//--------------------------------------------------------------------------------------------------

void cd::ausgabe()
{      
int i,insert; 
string T, I, G;
Verwaltungs_Datei=fopen("c:\\cd-datei.txt","a+");
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);

   for(i=0;i<insert;i++)
   {
   cout << "Ausgabe des Titels von CD "      << insert << " : " << cd1[i].T <<endl;
   cout << "Ausgabe des Interpreten von CD " << insert << " : " << cd1[i].I <<endl;                             
   cout << "Ausgabe des Genres von CD "      << insert << " : " << cd1[i].G <<endl;
   i++;
   }

//fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);                                                               
fclose(Verwaltungs_Datei);
cout<<"Weiter mit beliebiger Taste..."<<endl;
getch();
clrscr();
menu();   
}

//--------------------------------------------------------------------------------------------------

int main()
{  
  cd cd1;    // Zeiger erzeugen
  cd1.menu(); 
  cd1.eingabe();
  cd1.ausgabe();
  getchar();
  return 0;
}

Fehler:

Fehler E2294 111: Auf linker Seite der Struktur ist . oder .* erforderlich
Fehler E2294 112: Auf linker Seite der Struktur ist . oder .* erforderlich
Fehler E2294 113: Auf linker Seite der Struktur ist . oder .* erforderlich

Anscheinend ist es mit der Namengebung getan aber wir werden sehen.

Hilfe

evilissimo

cout << "Ausgabe des Titels von CD "      << insert << " : " << cd1[i]->T <<endl;
cout << "Ausgabe des Interpreten von CD " << insert << " : " << cd1[i]->I <<endl;                            
cout << "Ausgabe des Genres von CD "      << insert << " : " << cd1[i]->G <<endl;

Jetzt meinter das:

Fehler E2316 111: "T" ist kein Element von "cd"
Fehler E2316 112: "I" ist kein Element von "cd"
Fehler E2316 113: "G" ist kein Element von "cd"

otze schrieb:

arrgh
ändere bitte was an deiner namensgebung:

//ganz oben
int cd1; 
//etwas weiter drunter in cd eingabe
cd *cd1[100];
//noch weiter drunter in cd ausgabe:
fread(&cd1[i], sizeof(cd1[i]), 1, Verwaltungs_Datei);//an der stelle ist cd1 wieder ein int
//und dann nochmal in der main
cd cd1;

fällt dir was auf?

Mir fällt auf das ueberall die selben Namen sind.
Ganz oben habe ich ja schon gefixt aber ich weiß nicht weiter

Ich muss das Programm zum Montag fertig haben, bitte Leute sagt mir wie ich das richtig machen soll so wie otze das meint.

Help

klasse!