Es ist allerdings noch nicht fertig also nicht wundern.

//Programm zum verschlüsseln von Texten

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>

using namespace std;
//-----------------------------------------
//Für den neustart
int neustart()
{
  int lange;

       //-------------------------------------------------
       //löschen der Daten fals fehler
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");
	    cout<<"Sie haben das Programm zum ersten mal gestartet oder daten wurden gelöscht.\n";
	    cout<<"Bitte geben sie die laenge des passworts ein: ";
	    cin>>lange;
	    //-----------------------------------------------
	    //Verschlüsseln und aus und einlesen
	    lange=lange+52;
	    ofstream outlange("langa.txt.crpt");
	    outlange<<lange;
	    ifstream inlange("langa.txt.crpt");
	    inlange>>lange;

	    lange=lange-52;
	    cout<<"Bitte geben sie ein Passwort(maximal "<<lange<<" buchstaben) ein da die Keys gespeichert werden: ";
	  //-------------------------------------------------------------------
	  //Das gleiche nochmal mit dem passwort
	   char pws5[lange];
	    fgets(pws5,lange,stdin);
	    fgets(pws5,lange,stdin);
	   int i=0;

	   while(i<=lange-1)
	   {
	       pws5[i]=pws5[i]+2;
	       i++;
	   }
        cout<<pws5;
        cin.get();
	    ofstream out("psw.txt.crpt");

	    out<<pws5;

        Sleep(1000);
	    cout<<"Passwort wurde eingestellt";
        cin.get();
	}

//--------------------------------------------
//Verschlüsslen
int crypt()
{

}

int decrypt()
{

}

int main()
{
    //-------------------------------------------------
    /*
    pws2=Passwort aus Datei
    pwse=Passwort eingabe
    Dateien:
    keys.txt.crpt = Keys die man benutzt hat
    psw.txt.crpt = Passwort
    langa.txt.crpt = länge des Passwortes
    */

   int lange2=0;

string pws2;
string pwse;
	ifstream in("psw.txt.crpt");
	//--------------------------------------------
	//Erster Start
	if(!in)
	{
    neustart();

	}
	//---------------------------------------------
	//Länge des passwortes einlesen
 ifstream inlange("langa.txt.crpt");
	    inlange>>lange2;
    //---------------------------------------------
    //entschlüsseln der länge
	    lange2=lange2-52;
	    //--------------------------------------
	    //Passwort einlesen
	    char pws[lange2];
        in>>pws;
       int f=lange2-1;
      //----------------------------------------------
      //entschlüsseln des Passwortes
       while(f>=0)
	   {
	       pws[f]=pws[f]-2;
	       f--;
	   }
  pws2=pws;
  int versuche=3;//Versuche für Passwort eingabe
 //-----------------------------------------------
 //Passwort eingabe
  cout<<"\nBitte Passwort eingeben: ";
  while(cin>>pwse)
  {

  if(pwse != pws2)
  {

      cout<<"\nFehler Falsches passwort noch "<<versuche<<" Versuche.";
      cout<<"\nBitte Passwort eingeben: ";
      //-------------------------------------------------
      //zu oft fasch....
      if(versuche==0)
      {
       cout<<"\nFehler:Keine Versuche mehr Keys und Passwort werden geloescht";
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");
       cin.get();
       return 0;
      }
versuche--;
  }
  else
  break;
  }
  //-------------------------------------------------------------------
  //Was man machen möchte
cout<<"\nPasswort akzeptiert!";
cout<<"\nWeiter bin ich noch nicht aber das groesste ist geschaft.";
cout<<"\nWas wollen sie machen:\n [V]erschlüsseln oder [E]ntschlüsseln";
char auswahl;
cin>>auswahl;
switch(auswahl)
{
  case 'v':
  case 'V':
   crypt();
   break;
  case 'E':
  case 'e':
    decrypt();
    break;
  defauft:
   cout<<"\nUnbekannte Eingabe!!";
}
cin.get();
cin.get();
	return 0;
}

Was meint ihr kann man das besser verstehen? Was kann ich noch besser machen?

du mischt c und c++. das ist nicht gut.

Was ist denn nicht C++ also C?

Und verzichte auf fgets.

Und mach nicht immer so viel Leerabstand, das macht alles nur noch unübersichtlicher!

//***INCLUDES***//
#include <iostream> 
using namespace std;

//***FUNCTIONS***//
int funktion()
{
	//...
}

//***MAIN FUNCTION***//
void main()
{
	//...
}

So würde ich es machen...

getline ist aber kein stan**** soviel ich weiß.

Falsch. Ist Standart!

http://www.pronix.de/pronix-793.html

Stefan311 schrieb:

Ich weiß nähmlich das es kein C stan**** ist:

Und daraus schließt du, dass es auch kein C++-Standard ist?

Also im C++ stan****?
Ich weiß nähmlich das es kein C stan**** ist:

http://www.pronix.de/pronix-793.html

Warum zensierst du "Standard"? Ich kann es nicht verstehen...

Außerdem nein ich lerne Volkards c++ kurs.

Und ich probiers jetzt doch mit klassen aber da kommt nur falsches heraus.

die main.cpp:

#include <iostream>
#include <string>
#include <fstream>
#include "Klassen.hpp"

using namespace std;

prog program;

int main()
{
	while(program.aus()==false)
	{
	    program.start();
	}
		return 0;
}

Die include mit klassen:

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>

using namespace std;

class prog
{
private:
int lange;
int i;
ifstream in;
ofstream out;

bool an;

public:
char pws[];
int erststart()
{
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");

        cout<<"Sie haben das Programm zum ersten mal gestartet oder daten wurden gelöscht.\n";
	    cout<<"Bitte geben sie die laenge des passworts ein: ";
	    cin>>lange;
	    //-----------------------------------------------
	    //Verschlüsseln und aus und einlesen
        lange=lange+52;
        out.open("langa.txt.crpt");
        out<<lange;
        out.clear();
        in.open("langa.txt.crpt");
        in>>lange;
        in.clear();
        lange=lange-52;
	    cout<<"Bitte geben sie ein Passwort(maximal "<<lange<<" buchstaben) ein da die Keys gespeichert werden: ";

       cin.clear();
        fgets(pws,(lange-1),stdin);

        i=0;
	    while(i<=lange-1)
	    {
	        pws[i]=pws[i]+2;
	        i++;
	    }
        cout<<pws;
        cin.get();
        cin.get();
        out.open("psw.txt.crpt");
        out<<pws;
        Sleep(1000);
	    cout<<"Passwort wurde eingestellt";
        cin.get();
};
int start()
{
an=true;
cout<<"Willkimmen";

 in.open("psw.txt.crpt");
 if(!in)
{
    in.clear();
    erststart();
}

else
{
}

};

bool aus(int d)
{
    bool ann;
    if(d==1)
    {
        ann=false;
    }
    else if(d==2)
    {
      ann=true;
    }
    else
    {
        return ann;
    }
};

};

Ich weiß alles ein bisschen undeutlich. aufjedenfall kommt bei der passwort eingabe ein Fehler:
und zwar hier:

Aus include:

lange=lange-52;
	    cout<<"Bitte geben sie ein Passwort(maximal "<<lange<<" buchstaben) ein da die Keys gespeichert werden: ";

       cin.clear();
        fgets(pws,(lange-1),stdin);

ich hab es mit getline,cin.getline,gets etc ausprobiert. immer sind dort
schon bevor man was eingibt smilies.Warum?
Ich hab mir überlegt vielleicht darf ich nicht direkt auf die Variabeln zugreifen mit denn Funktionen kann das sein?

Ps:Ich zensiere kein Standart. Das geht automatisch.

die main.cpp

#include <iostream>
#include <string>
#include <fstream>
#include "Klassen.hpp"

using namespace std;

int erststart();

prog program;

int main()
{
	int i;
	program.aus(1);
	while(program.aus(3)==false)//überprüfen ob Proggramm aus soll
	{
     if(program.dateipruefer()==true)//Dateien überprüfen(im momen verfäscht da man sonst nichts testen kann)
     {
         program.loescheall();
         erststart();
     }
     else
	cout<<"\nNochmer? 1 ja  2 nein\n";//nochmer?
    cin>>i;
    if(i==1)
     {
     int key;                          //Schlüssel
     char* dname;                       //Dateiname
     cout<<"\nDateiname: ";             
     cin>>dname;
     cout<<"\nKey: ";
     cin>>key;
     program.einlesen(dname,key);     //einlesen verschlüsseln speichern
     }
else
{
   program.aus(2);                      //aus einstellen

	}
	cout<<"Bis dann.";
	cin.get();
	cin.get();
	}
		return 0;
}

int erststart()
{

}

Die include:

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>

using namespace std;

class prog
{
private:
int lange;
int i;
ifstream in;
ofstream out;
char pws[];
bool an;

public:

int loescheall()
{
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");

};
bool dateipruefer()     //Datei prüfen
{
in.open("psw.txt.crpt");
if(!in)
{
    in.clear();         //Wenn sie nicht existiert wird false zurück gegeben
    return false;       
}
else
{
  in.clear();
  return true;          // ''  ''   ''     ''       ''  true    ''      ''
}
};

int aus(int d)              //Das ein auschalt modul
{
    bool ann;
    if(d==1)
    {
        ann=false;
    }
    else if(d==2)
    {
      ann=true;
    }
    else
    {
        return ann;
    }
};

char crypt(char ch,char key)//verschlüsseln
{
    return ch+key;
}
char einlesen(char* dname,char key)//einlesen
{
char* ende=".crpt";         
char infile;
in.open(dname);
strcat(dname,ende);              //.crpt dranhängen                       
out.open(dname);
while(!in.eof())                //verschlüsseln
{
 char ch=in.get();
out<<crypt(ch,key);
}
}

};

Jetzt ist es auch übersichtlicher. Ich glaube das wird mein erstes richtig gutes Programm mit oop in C++.

Jetzt ist es auch übersichtlicher. Ich glaube das wird mein erstes richtig gutes Programm mit oop in C++.

du wolltest es ja so (von gut oder gar oop kann wohl kaum die Rede sein):

die main.cpp

#include <iostream>
#include <string>
#include <fstream>
#include "Klassen.hpp"

using namespace std;

int erststart();

oop?

prog program;

oop?

int main()
{
	int i;
	program.aus(1);
	while(program.aus(3)==false)//überprüfen ob Proggramm aus soll
	{
     if(program.dateipruefer()==true)//Dateien überprüfen(im momen verfäscht da man sonst nichts testen kann)
     {
         program.loescheall();
         erststart();
     }
     else
	cout<<"\nNochmer? 1 ja  2 nein\n";//nochmer?
    cin>>i;
    if(i==1)
     {
     int key;                          //Schlüssel
     char* dname;                       //Dateiname
     cout<<"\nDateiname: ";             
     cin>>dname;
     cout<<"\nKey: ";
     cin>>key;
     program.einlesen(dname,key);     //einlesen verschlüsseln speichern
     }
else
{
   program.aus(2);                      //aus einstellen

	}
	cout<<"Bis dann.";
	cin.get();
	cin.get();
	}
		return 0;
}

int erststart()
{
}

Die include:

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>

using namespace std;

class prog
{
private:
int lange;
int i;
ifstream in;
ofstream out;
char pws[];

c++?

bool an;

public:

int loescheall()
{
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");

};
bool dateipruefer()     //Datei prüfen
{
in.open("psw.txt.crpt");
if(!in)
{
    in.clear();         //Wenn sie nicht existiert wird false zurück gegeben
    return false;       
}
else
{
  in.clear();
  return true;          // ''  ''   ''     ''       ''  true    ''      ''
}
};

int aus(int d)              //Das ein auschalt modul
{
    bool ann;
    if(d==1)
    {
        ann=false;
    }
    else if(d==2)
    {
      ann=true;
    }
    else
    {
        return ann;
    }
};

reicht nicht ein bool fuer ann?

char crypt(char ch,char key)//verschlüsseln
{
    return ch+key;
}

std::string?

char einlesen(char* dname,char key)//einlesen
{
char* ende=".crpt";         
char infile;
in.open(dname);
strcat(dname,ende);              //.crpt dranhängen                       
out.open(dname);
while(!in.eof())                //verschlüsseln
{
 char ch=in.get();
out<<crypt(ch,key);
}
}

std::string?

};

Schau dir nochmal das Design von Klassen an und ueberlege, ob hier eine Klasse sinnvoll ist. Warum gibt es hier kein Konstruktor? Was ist mit Kopieren der Klasse? Destruktor? Warum verwendest du ueberall char statt std::string? Du solltest anfangen deinen Code sauber einzuruecken. So faellt es einem schwer alles zu lesen.

Also Stings kanns du mir da eine Seite darüber empfehlen weil ich immer wenn
ich strings nutzen will mit gets,fgets und getline auf die nase gefallen weil
die nur chars wollen.
OOP ich komme irgendwie nicht dahinter. Das ist doch einfach um funktion
einfacher zu sehen,übersichtlicher. oder?

Nein. Einfach gesagt, ist es lediglich ein Abstraktionsmittel, um Gegenstände der realen Welt oder unserer Anschauung zu einem "Ding" in einem Programm zusammenzufassen. Du schaust dir an, was für Eigenschaften dein Betrachtungsgegenstand hat und welche Aktionen es ausführen kann. Eine Katze hat z.B. ein Gewicht, eine Augenfarbe, ein Alter usw. und kann fressen, schlafen, miauen usw. Also kapselst du das alles in eine Klasse Katze mit den Objektvariablen gewicht, augenfarbe und alter und den Methoden fressen(), schlafen und miauen(). (Sry für das Beispiel )

Du solltest jedoch nicht versuchen (wie du es gerade gemacht hast), auf Teufel komm raus Funktionen in eine Klasse zu pressen, nur um irgendwie OOP zu programmieren.

Nein. Einfach gesagt, ist es lediglich ein Abstraktionsmittel, um Gegenstände der realen Welt oder unserer Anschauung zu einem "Ding" in einem Programm zusammenzufassen. Du schaust dir an, was für Eigenschaften dein Betrachtungsgegenstand hat und welche Aktionen es ausführen kann. Eine Katze hat z.B. ein Gewicht, eine Augenfarbe, ein Alter usw. und kann fressen, schlafen, miauen usw. Also kapselst du das alles in eine Klasse Katze mit den Objektvariablen gewicht, augenfarbe und alter und den Methoden fressen(), schlafen und miauen(). (Sry für das Beispiel )

Also ich weiß ja wie du es meinst (so hab ich mir das mit den klassen auch gedacht).
Aber ich verstehe nicht wie ich das jetzt hier einsetzen soll?
Da jemand das auf der ersten seite erwähnte. OOP geht hier nicht ja.(?)

#include <iostream>
#include <string>
#include <fstream>
 #include "Klassen.hpp"

using namespace std;

int erststart();

prog program;

int main()
{
	int i;
	int a;

	while(a)//endloss schleife
	{
     if(program.dateipruefer()==true)//Dateien überprüfen(im momen verfäscht da man sonst nichts testen kann)
     {
         program.loescheall();
         erststart();
     }
     else
	cout<<"V0.1(alpha) (C) by Stefan Veuskens\nVerschluesslungstool fuer Texte(Sicherheit: Niedrig)\n [1] Ver- oder Entschluesseln | [2] Ende\n";
    cin.clear();
    cin>>i;//auswahl(wird bald ersetzt
    if(i==1)
     {
     int swit;          //Modus für crypter
     int key;                          //Schlüssel
     string dname;              //Datei name
     cout<<"\n[1]Ent- oder [2]Verschluesseln?\n";
     cin.clear();
     cin>>swit;                 //Modus auswählen,wird auch bald ersetzt
     cout<<"\nDateiname: ";
     getline(cin,dname);
     getline(cin,dname);        //Datei name einlesen(mit einmal klappt das nicht,warum weiß ich nicht)
     cout<<"\nKey: ";
     cin>>key;      //key eingebn
     if(program.einlesen(dname,key,swit)==false) //einlesen verschlüsseln speichern und fehler meldung
     {
         cout<<"Datei konnte nicht geoeffnet werden.\nTipp:Existiert sie?\nTippfehler?\nWenn die Datei sich in einem ander ordner\n";
         cout<<"befindet als das Verschluesslungstool muessen sie einen ganzen pfad angeben.\n";
     }
     else
     {
     cout<<"\nErfolgreich beendet\n";       //Hat geklappt
     }
     }
else
{

	cout<<"Bis dann.";
	cin.get();
	cin.get();
	break;      //Zum beenden.
}
	}
		return 0;
}

int erststart()//Hat noch keine aufgabe
{

}

die Include

#include <iostream>
#include <string>
#include <fstream>
#include <windows.h>

using namespace std;

class prog
{
private:
int lange;      //für V0.2
//int i;
ifstream in;    //einlesen
ofstream out;   //auslesen(eigentlich klar)
char pws[];     //für V0.2
//bool an;      //Wird nicht mehr gebraucht

public:

int loescheall()        //für V0.2
{
       remove("keys.txt.crpt");
       remove("psw.txt.crpt");
       remove("langa.txt.crpt");

};
bool dateipruefer()     //für V0.2
{
   in.open("psw.txt.crpt");
   if(!in)
{
    in.clear();         //Wenn sie nicht existiert wird false zurück gegeben
    return false;
}
else
{
  in.clear();
  return true;          // ''  ''   ''     ''       ''  true    ''      ''
}
};

char crypt(char ch,char key)//verschlüsseln/entschlüsseln
{
    cout<<".";
    return ch+key;
}
bool einlesen(string dname,char key,int swit)//einlesen
{
   string ende=".crpt";        //Datei ende für neue datei
   char ine[80];               //char für denn Datei namen
   strcpy(ine,dname.c_str());  //kopieren aus string in char
   in.open(ine);               //öffnen(Test)
   if(!in)                     //Fehler ob existiert
    {
    return false;
    }

if(swit == 1)               //modus (decrypten)
  {
    dname;                  //Dateiname
    key=key/-1;      //key negativ machen da ja entschlüsselt werden soll
    int pos=dname.rfind(ende);      //suche nach .crpt
    dname.erase(pos);               //löschen von .crpt
    char out2[80];                  //char für dateiname
    strcpy(out2,dname.c_str());     //kopieren string>>char

    out.open(out2);                 //öffnen(erstellen)
    while(!in.eof())                //verschlüsseln
     {
       char ch=in.get();
       out<<crypt(ch,key);         //decrypten

      }
   }
 else
   {

   dname=dname + ende;      //.crpt dranhängen
   char out2[80];              //char für dateinamen
   strcpy(out2,dname.c_str());//kopieren string>>char

   out.open(out2);             //öffnen(erstellen)
   while(!in.eof())                //verschlüsseln
      {
          char ch=in.get();
          out<<crypt(ch,key);         //crypten

       }

    }
    return true;//hat geklappt
 }

};

Nur so sollte man zeilen zwischen den Befehlen lassen?

Editiert:einnrückungen

ich nehm jetzt einfach mal zufälligerweise ein stückchen heraus...

// deutscher funktionsname ... hmm find ich nicht so praktisch
bool dateipruefer()
{
   in.open("psw.txt.crpt"); // ok
   if(!in) //... ok (gibt aber bessere methoden dafür soweit ich weiß)
   // ich kenn das eigentlich so, dass die { und } klammern unter 
   // das schlüsselwort (hier if) kommen, nicht ganz an den anfang der zeile...
   // man könnte meinen das hier gehört nicht mehr zu dateipruefer...
{
    in.clear();
    return false;
}
// das hier gehört immer noch zu "dateipruefer", sollte also auch so eingerückt  
// werden, das else sollte IMMER in der gleichen einrückung sein wie das
// zugehörige if, egal welchen komischen stil du hast, sowas ruiniert total die 
// übersichlichkeit
else
{
  // und auf einmal benutzt du wieder eine andere einrückung...
  // mitlerweile weiß wohl niemand mehr der den code liest wozu das hier gehört
  in.clear();

  // seltsamer kommentar...
  return true;          // ''  ''   ''     ''       ''  true    ''      ''
}

So wäre das doch schonmal besser:

// hab leider(gottseidank) nicht den gesammten quellcode gelesen, bennen die
// funktion einfach nach dem, was sie macht bzw. prüft in englisch.
// wenn ich das richtig sehe wird die datei hier geöffnet und zusätzlich geprüft
// oder wird die hier nur schnell geöffnet um geprüft zu werden? (und das
// mit einer membervariable vom typ fstream o.O??)
// wenn ja ist das 
// mist, denn man öffnet die datei nur einmal und prüft sie dann, aber das is ja 
// deine sache das zu verbessern...

// also:
bool open_file_whatever(std::string filename)
// dateinamen sollte man dynamisch halten...
{
   in.open(filename);
   if(!in) // hab keine lust mich darüber zu informieren, ich glaub .good() war
           // die beste methode um sowas zu checken, aber was solls
   {
      in.clear();
      return false;
   }

   // das else wird nicht benötigt, auf grund des return false'es
   in.clear();
   return true;
}

ich nehm jetzt einfach mal zufälligerweise ein stückchen heraus...

// deutscher funktionsname ... hmm find ich nicht so praktisch
bool dateipruefer()
{
   in.open("psw.txt.crpt"); // ok
   if(!in) //... ok (gibt aber bessere methoden dafür soweit ich weiß)
   // ich kenn das eigentlich so, dass die { und } klammern unter 
   // das schlüsselwort (hier if) kommen, nicht ganz an den anfang der zeile...
   // man könnte meinen das hier gehört nicht mehr zu dateipruefer...
{
    in.clear();
    return false;
}
// das hier gehört immer noch zu "dateipruefer", sollte also auch so eingerückt  
// werden, das else sollte IMMER in der gleichen einrückung sein wie das
// zugehörige if, egal welchen komischen stil du hast, sowas ruiniert total die 
// übersichlichkeit
else
{
  // und auf einmal benutzt du wieder eine andere einrückung...
  // mitlerweile weiß wohl niemand mehr der den code liest wozu das hier gehört
  in.clear();

  // seltsamer kommentar...
  return true;          // ''  ''   ''     ''       ''  true    ''      ''
}

So wäre das doch schonmal besser:

// hab leider(gottseidank) nicht den gesammten quellcode gelesen, bennen die
// funktion einfach nach dem, was sie macht bzw. prüft in englisch.
// wenn ich das richtig sehe wird die datei hier geöffnet und zusätzlich geprüft
// oder wird die hier nur schnell geöffnet um geprüft zu werden? (und das
// mit einer membervariable vom typ fstream o.O??)
// wenn ja ist das 
// mist, denn man öffnet die datei nur einmal und prüft sie dann, aber das is ja 
// deine sache das zu verbessern...

// also:
bool open_file_whatever(std::string filename)
// dateinamen sollte man dynamisch halten...
{
   in.open(filename);
   if(!in) // hab keine lust mich darüber zu informieren, ich glaub .good() war
           // die beste methode um sowas zu checken, aber was solls
   {
      in.clear();
      return false;
   }

   // das else wird nicht benötigt, auf grund des return false'es
   in.clear();
   return true;
}