Problem beim Umwandeln char <-> int

5cript

bei einem Zeilenumbruch gibts Probleme: (wenn Zeichen ein Umbruch ist)

unsigned char ASCIITABEL;
std::stringstream Uberbrucken;
Uberbrucken << Zeichen;
Uberbrucken >> ASCIITABEL;
Uberbrucken.str("");
Num = static_cast<int>(ASCIITABEL);

welch Grund kann das haben ist der Stream schuld ?
Auf jeden Fall kommt was falsches raus ! Beispiel: (funzt)

Ì˜Ð…¤§^~už<,)Cq]Zýùñ˜Þªü¦Åaf£-ˆ”dŒ¿òˆh.ÉëŠ0ñZàr•ÙËÉc2r¦fe)¬ïp8¯ì›|Þ¼°M³±·Ð

Entschlüsselt:

Hier könnte ihr Text stehen (dies benötigt mindestens eine erweiterten Zeichensatz)

Beispiel (funzt nicht)

¦·%KÊ`BÞÚ(À\û±ÂZ`¶,rÒ*[z³!½ýÐ3Œk?âU-äÃ¶‰P*¤ û
zUß8o
£8c9OŒT¯øM.8¦g Þ9ó(ìéöz

entschlüsselt:

Hier könnte ihr Text stehen (dies benötEgt mindHs”ens ekne erweiterten Zei½hensatz)

es treten zwar mehrere Fehler im Text auf, aber das liegt wohl am Rest des Algos,
aber wie man sieht, ist bei keinem Umbruch alles richtig.

SeppJ

Du kannst ein Zeichen auch ein kleines bisschen einfacher in einen int umwandeln:

char Zeichen;
int Num=Zeichen;

Und man kann übrigens auch ganz normal mit char rechnen, falls du das noch nicht wusstest.

5cript

1. es muss ein unsigned char sein
2. WIESO MACH ICH ES SO UMSTÄNDLICH ?
ich vergaß zu sagen, dass Zeichen ein String ist !

unsigned char ASCIITABLE = Zeichen[0];
int Num = int(ASCIITABLE);

EDIT: Ich bekomme ein std::string geliefert.

Nexus

Was ist es jetzt, unsigned char oder char ? Die Klasse std::string verwendet nämlich char .

std::string text = "hallo";
int ascii_code = text[0];

Aber du kannst auch gerade so gut mit char rechnen...

5cript

hmm ich hab gerade gemerkt, dass der Fehler immernoch auftritt.

@Nexus: Wenn ich das mache, wirds Fehlerhaft, bei Umlauten.

Ich glaub ihr braucht mehr code ?
Ich bin am verzweifeln, es kann nur an dieser Umwandlung liegen, denn wenn ich meinen eigenen Zeichensatz benutze ist alles im Lot.

Wie könnte ich Umbrüche gesondert behandeln, oder was haben die für eine Zahl in der Tabelle ?

SeppJ

Tim06TR schrieb:

Ich glaub ihr braucht mehr code ?

Ja.

Ich bin am verzweifeln, es kann nur an dieser Umwandlung liegen, denn wenn ich meinen eigenen Zeichensatz benutze ist alles im Lot.

Ehrlich gesagt, weiß ich gar nicht, was du genau willst. Das was ich und Nexus dir erklärt haben, hätte nach meinem Verständnis deines Problems eigentlich helfen müssen.

Wie könnte ich Umbrüche gesondert behandeln, oder was haben die für eine Zahl in der Tabelle ?

Die haben die Nummer '\n'. CHARS SIND ZAHLEN!

5cript

SeppJ schrieb:

Die haben die Nummer '\n'. CHARS SIND ZAHLEN!

Es muss nicht zwangsweise \n sein, gibts da nicht noch ein anderes ? \r oder so, ich weiß jetzt nicht genau wie das war.
Ich ändere kurz noch 2 Sachen und meld mich dann zurück.

bist du wirklich so wirr wie du schreibst?

SeppJ

Tim06TR schrieb:

SeppJ schrieb:

Die haben die Nummer '\n'. CHARS SIND ZAHLEN!

Es muss nicht zwangsweise \n sein, gibts da nicht noch ein anderes ? \r oder so, ich weiß jetzt nicht genau wie das war.
Ich ändere kurz noch 2 Sachen und meld mich dann zurück.

\n ist das Zeichen für "Line feed" = Cursor in die nächste Zeile setzen

\r ist das Zeichen für "Carriage return" = Cursor an den Anfang der aktuellen Zeile setzen.

In Unixoiden Systemen erfüllt \n eine leicht abgewandelte Funktion, nämlich Cursor an den Anfang der nächsten Zeile setzen. \r wird praktisch nie verwendet.

In DOS-artigen Systemen wird ein Zeilenumbruch durch die Kombination von \n und \r symbolisiert. Einzeln kommen die Zeichen so gut wie nie vor.

5cript

thetubes schrieb:

bist du wirklich so wirr wie du schreibst?

Ich kann um 2549354987 Ecken Denken. so sieht mein Code auch manchmal aus

so zu Problem: (Ausschnitte)
Entschlüsselung Teil 1

while (i < ToDecode.size()) // ToDecode = Verschlüsselter Text
	{
		i++;
		std::string Zeichen = ToDecode.substr(i-1,1); // Zeichen als string ich sehe, hier könnte man es verbessern
// Zeichen ein char und ToDecode[i-1]
		int Num;
		if (Dset < 200) // ist hier nicht der Fall, funktioniert, deshalb teste ich es nicht mehr
		{
			int Dset_ = 0;
			Dset_ = DataSetChecker(Dataset_);
			Num = ZeichenToInt(Zeichen,Dset_);
		}
		else // so hier wirds kritisch
		{
			if (Zeichen[0] == char(10) || Zeichen[0] == char(13) || Zeichen == "\n") // meine NEUE ausnahme regelung, sie hilft nicht :)
				Num == int("\n");
			else // das habe ich gepostet
			{
				unsigned char ASCIITABEL;
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
			}
		}

Entschlüsselung Teil 2

if (_System_ == "System: NEW") // Das zu testende System
		{
			int Keynum = i - 1;
			if (Keynum == 0) // definiert schlüsselname
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-19);
				CurrentKey += ".CodeX3";
			}
			else // definiert schlüsselname
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-18);
				CurrentKey += IntToStr(Keynum);
				CurrentKey += ".CodeX3";
			}
			std::ifstream reader;
			reader.open(CurrentKey.c_str());
			if (!reader) // Huch Schlüssel nicht gefunden ? Der Fehler tritt nicht auf, nur wenn der Schlüssel kaputt ist
			{
				ErrorMessage = "Error Code 100";
				Fehlerbericht = "Schlüssel nicht gefunden, möglicher Verlaufsfolgefehler"; // hmm das werde ich demnächst umformulieren
				Fehlerbericht += char(10);
				Fehlerbericht += CurrentKey;
				Erstellen_EBer(Fehlerbericht,ErrorMessage); // das hilft wirklich extrem
				return ErrorMessage;
			}
			int Zeile = 0;
			while(Zeile < Num) // eigentliches Verschlüsselungssystem
			{
				Zeile++;
				std::getline(reader,num);
			}
			reader.close();
		}

Verschlüsselung Teil 1

if (Parameter2 < 255)
		{
			Num = ZeichenToInt(Zeichen,Parameter2);
		}
		else
		{
			if (Zeichen != " ")
			{
				unsigned char ASCIITABEL; // gibts auch in der Entschlüsselung, ich kann nicht sagen ob hier der Fehler entsteht oder in der Entschlüsselung
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
			}
			else
			{
				Num = 32;
			}
		}

Verschlüsselung Teil 2

while (std::getline(CurrentKey,Line)) // vershlüsselt
			{
				line++;
				std::string a;
				a = IntToStr(line);
				if (Line == NumStr)
				{
					break;
				}
			}

Verschlüsselung Teil 3

else
			{
				char c;
				c = char (NewNum); // wandelt zurück, genauso in Entschlüsselung, tritt eventuell doch eher hier der Fehler auf ?
				Result = c;
			}
		}
		all += Result; // fügt alles zusammen

EDIT: Ich hoffe ich überrenne hier niemand, aber kürzer gehts kaum

unskilled

ohne mehr anzugucken: Num == int("\n"); das willst du bestimmt nicht

SeppJ

unskilled schrieb:

ohne mehr anzugucken: Num == int("\n"); das willst du bestimmt nicht

Das hier willst du auch nicht: Zeichen == "\n"

Mach dich mal kundig, was der Unterschied zwischen den einzelnen und den doppelten Anführungsstrichen ist.

Nexus

unskilled schrieb:

ohne mehr anzugucken: Num == int("\n"); das willst du bestimmt nicht

Vielleicht auch ein Grund, wieso man static_cast einsetzen sollte, wenn man nicht genau weiss, was man macht...

unskilled

SeppJ schrieb:

unskilled schrieb:

ohne mehr anzugucken: Num == int("\n"); das willst du bestimmt nicht

Das hier willst du auch nicht: Zeichen == "\n"

Mach dich mal kundig, was der Unterschied zwischen den einzelnen und den doppelten Anführungsstrichen ist.

doch, das will er, weil zeichen ein string ist... xD

teil das ganze doch mal bitte in fkt auf...
ich würde 2 fkt nehmen:
char encode(char value);
char decode(char value);
die kannst du dann ganz einfach innerhalb einer schleife aufrufen
(den rest würde ich in nen detail-namespace verfrachten, weil das den nutzer nicht zu interessieren hat...
vor allem würde ich an deiner stelle die komplette fkt (mit fkt-rumpf) posten, weil man dann vll auch erraten kann, was der quellcode machen soll...)

wenn du die beiden fkt nehmen würdest, könntest du dann so was hier machen^^

std::string encrypt(const std::string& value)
{
	std::string ret_val(value.size());
	for(std::string::size_type i(0), e(value.size()); i != e; ++i)
		ret_val[i] = encode(value[i];

	return ret_val;
}

die anwendung sollte klar sein... (das decrypt ist analog dazu zu schreiben - könnte man auch mit funktoren zu einer fkt vereinfachen und vor allem könnte man es dann auch mit stl-algorithm-funktionen machen, wenn man das bedürfnis hätte...)

jz zu deinem quelltext - ich hab mal versucht, zu verstehen, was du machen möchtest - allerdings hab ichs nicht verstanden, weil einfach zu viele fehler drin sind und du teilweise nichtssagende variablennamen hast:

while (i < ToDecode.size()) // ToDecode = Verschlüsselter Text
	{
		i++;
//for magst du wohl nicht?

		std::string Zeichen = ToDecode.substr(i-1,1); // Zeichen als string ich sehe, hier könnte man es verbessern
//char Zeichen reicht doch - und substr brauchst du hier doch gar nicht...

// Zeichen ein char und ToDecode[i-1]
		int Num;
//was ist dset überhaupt?
		if (Dset < 200) // ist hier nicht der Fall, funktioniert, deshalb teste ich es nicht mehr
		{
			int Dset_ = 0;
			Dset_ = DataSetChecker(Dataset_);
			Num = ZeichenToInt(Zeichen,Dset_);
		}
//den teil versteh ich nicht - für zeichen to int brauchst du keine fkt mehr, wenn du char zeichen hast...
		else // so hier wirds kritisch
		{
			if (Zeichen[0] == char(10) || Zeichen[0] == char(13) || Zeichen == "\n") // meine NEUE ausnahme regelung, sie hilft nicht :)
				Num == int("\n");
//ausnahmeregelungen solltest du nicht brauchen... und vor allem nicht verwenden! ich will doch nicht, dass mein \r\n zu nem \n\n wird :(
			else // das habe ich gepostet
			{
				unsigned char ASCIITABEL;
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
			}
//was hat das nach ascii zu tun? nix! Num = Zeichen würde doch vollkommen ausreichen
//was mich wiederrum zu der frage bringt: wieso arbeitest du nicht gleich mit zeichen?
		}

Entschlüsselung Teil 2

if (_System_ == "System: NEW") // Das zu testende System
//hä? was hat das damit zu tun?
		{
			int Keynum = i - 1;
			if (Keynum == 0) // definiert schlüsselname
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-19);
				CurrentKey += ".CodeX3";
			}
			else // definiert schlüsselname
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-18);
				CurrentKey += IntToStr(Keynum);
				CurrentKey += ".CodeX3";
			}
			std::ifstream reader;
			reader.open(CurrentKey.c_str());
//kannst du auch schon im ctor machen - currentkey ist nen komischer name für nen dateiname
			if (!reader) // Huch Schlüssel nicht gefunden ? Der Fehler tritt nicht auf, nur wenn der Schlüssel kaputt ist
//ich würde if(reader.bad()) schreiben
			{
				ErrorMessage = "Error Code 100";
				Fehlerbericht = "Schlüssel nicht gefunden, möglicher Verlaufsfolgefehler"; // hmm das werde ich demnächst umformulieren
				Fehlerbericht += char(10);
				Fehlerbericht += CurrentKey;
				Erstellen_EBer(Fehlerbericht,ErrorMessage); // das hilft wirklich extrem
				return ErrorMessage;
//für so was gibts exceptions - nen string sollte man aber nicht so hässlich zusammenbauen... vor allem += char(10) ist dumm...
			}
			int Zeile = 0;
			while(Zeile < Num) // eigentliches Verschlüsselungssystem
			{
				Zeile++;
				std::getline(reader,num);
			}
			reader.close();
		}

Verschlüsselung Teil 1

if (Parameter2 < 255)
		{
			Num = ZeichenToInt(Zeichen,Parameter2);
//das du das hier nicht brauchst, hatten wir schon mal...
		}
		else
		{
			if (Zeichen != " ")
//wieso fallunterscheidung?
			{
				unsigned char ASCIITABEL; // gibts auch in der Entschlüsselung, ich kann nicht sagen ob hier der Fehler entsteht oder in der Entschlüsselung
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
//das hier auch - der quellcode kommt mir bekannt vor... :P wenn er nicht so extrem sinnlos wär, könnte man ihn ja in ne fkt verschieben...
			}
			else
			{
				Num = 32;
			}
		}

Verschlüsselung Teil 2

while (std::getline(CurrentKey,Line)) // vershlüsselt
			{
				line++;
				std::string a;
				a = IntToStr(line);
//würde es nicht viel intuitiver, schneller und komfortabler sein, NumStr in nen Int umzuwandeln? und dann 2 ints zu vergleichen?
				if (Line == NumStr)
				{
					break;
				}
			}

Verschlüsselung Teil 3

else
			{
				char c;
				c = char (NewNum); // wandelt zurück, genauso in Entschlüsselung, tritt eventuell doch eher hier der Fehler auf ?
//welchen typen hat newnum? was steht drin?
				Result = c;
//der code hier ist mal wieder komisch...
			}
		}
		all += Result; // fügt alles zusammen
//wenn ich raten sollte, würde ich meinen, dass hier all.push_back(Result) besser wäre^^

ich hoffe, es hilft dir wenigsten ein wenig...

bb

edit: ziemlich oben was umgeschrieben, weil da der zusammenhang beim nachträglichen einfügen verloren gegangen war^^

SeppJ

unskilled schrieb:

SeppJ schrieb:

unskilled schrieb:

ohne mehr anzugucken: Num == int("\n"); das willst du bestimmt nicht

Das hier willst du auch nicht: Zeichen == "\n"

Mach dich mal kundig, was der Unterschied zwischen den einzelnen und den doppelten Anführungsstrichen ist.

doch, das will er, weil zeichen ein string ist... xD

Nein, das will er sogar doppelt nicht, weil er an der Stelle nämlich Zeichen[0] == "\n" schreiben wollte, aber das [0] vergessen hat.

Wenn er deine Tipps noch beachtet, dürfte der Code auch langsam in eine Form kommen, in der man Fehler suchen und finden kann.

unskilled

SeppJ schrieb:

Nein, das will er sogar doppelt nicht, weil er an der Stelle nämlich Zeichen[0] == "\n" schreiben wollte, aber das [0] vergessen hat.

Nö - guck mal:
std::string Zeichen = ToDecode.substr(i-1,1);
Zeichen ist also ein String der Länge 1 (sozusagen ein char :P):

std::string Zeichen = ToDecode.substr(i-1, 1);

std::string lhs = Zeichen;
std::string rhs; rhs = Zeichen[0];

assert(lhs == rhs);

damit will er Zeichen == "\n"
allerdings ist das schon wieder so was, was jeden programmierer verwirrt...
und performance-technisch das allerschlechteste ist, was geht

SeppJ schrieb:

Wenn er deine Tipps noch beachtet, dürfte der Code auch langsam in eine Form kommen, in der man Fehler suchen und finden kann.

Japp^^

bb

5cript

Ahh wundervoll, ich glaube ich werde jetzt Schritt für Schritt die Änderung vornehmen, und wenns fertig ist sende ich noch mal die ganzen Funktionen.
(In der Hoffnung das das noch mal so viele "Fehler" drin sind )
Und vielleicht finden wir DEN Fehler, den es zu suchen galt.

5cript

Ach noch was:

if (Dset < 200)
{
    int Dset_ = 0;
    Dset_ = DataSetChecker(Dataset_);
    Num = ZeichenToInt(Zeichen,Dset_);
}

Dset müsste eigentlich Cset heißen und steht für Character Set zu deutsch Zeichensatz.
Er wird hier als Auswahlmöglichkeit gegeben, um die Schlüsselgröße zu senken, bei weniger komplexen Textstrukturen.
Wiederrum ist Dataset eigentlich ein falscher Bezeichner... ging mir einfach durch den Kopf.
Und ZeichenToInt, wandelt dann eben mit meinem eigenen Zeichsatz um.
Der ist aber leider noch etwas falsch sortiert, Benutzerunfreundlich.
Man wird wegen der Zahlen fast gezwungen immer einen hohen Zeichensatz zu wählen, aber das werden ich noch ändern.

Und for([...];[...];[...]) benutz ich nur noch selten...
Weiß nicht irgendwie verwirrt mich for, wenns spät wird.

EDIT 1:

all += Result; // fügt alles zusammen
//wenn ich raten sollte, würde ich meinen, dass hier all.push_back(Result) besser wäre^^

nein ist hier unpassend da Result = std::string
Result muss std::string sein, da werdet ihr mir sicher ins Wort fallen, wenn ich alles gepostet habe

5cript

Und Kaputt !!!
Ich hau die Backups rein und poste das unkorigierte.
MOMENT, WAS IST JETZT LOS ???
DER FEHLER TRITT NICHT MEHR AUF ?
(Zeilenumbruch verschwindet im Forum ?????????)

ØeU6VÍø]Ô³ 9/¿ugµQå)¦<Ä£Nd'ÙJáø5çv‡ µÄÎ°Áq>[Ž€8J: ^’: ‚êWx¸êK~u{sÓO×@PÀ9æb

Hier könnte ihr Text stehen (dies benötigt mindestens eine erweiterten Zeichensatz)

Da teste ich nochmal ...
Trotdem hier sind die beiden Header: (Es ist ein wenig .NET mit drin, zu ingnorieren)
(Ich weiß Global = mist, STRINT stellt IntToStr und StrToInt zur verfügung, Datensatz.h = mein Datensatz)
(Ist recht lang)
**
Encode.h
**

#pragma once

#include "DatenSatz.h"
#include "STRINT.h"

#include <vector>
#include <algorithm>
#include <string>
#include <fstream>

std::string GlobalKeyNum_;
int Progress_;
int onlyonemsg_;
int Rechenbar_;
std::string GlobalName_;
int Numb_;
int Parameter_[3];

std::string Encode(std::string INPUT, int Parameter1, int Parameter2, bool KeyCreatorSystem, bool Improval, std::string Passwort, std::string Gname, bool SYNTAX, int VECTSHUFFLE);
void ChangeKey(int Parameter_1,int Parameter_2,bool SystemParam, std::string KName);
void Keycreate(std::string KeyName);

std::string Encode(std::string INPUT, int Parameter1, int Parameter2, bool KeyCreatorSystem, bool Improval, std::string Passwort, std::string Gname, bool SYNTAX, int VECTSHUFFLE)
{
	int Zahl = 0;
	if (Passwort != "nullptr")
	{
		srand(5);
	}
	int RO = 0;
	std::vector<int> VirtualKey_( Parameter2 );
	for( size_t i=0; i< VirtualKey_.size(); ++i )
    VirtualKey_[i] = i+1;
	Parameter_[2] = Parameter2;
	Parameter_[1] = Parameter1;
	std::string all;
	GlobalName_ = Gname;
	int Pusher = 0;
	std::string Text;
	std::sort(VirtualKey_.begin(),VirtualKey_.end());
	std::string OUT;
	String^ All = gcnew String(INPUT.c_str());
	std::string ALL;
	ALL = IntToStr(INPUT.size());
	int Count_Zeichen = 0;
	int RechenOperator = 0;
	std::string CurKey;
	std::string SYNT;
	while (Count_Zeichen < INPUT.size())
	{
		Count_Zeichen++; 
		if (Parameter1 == 4)
		{
			std::random_shuffle( VirtualKey_.begin(), VirtualKey_.end() );
		}
		if (Parameter1 == 3 || Parameter1 == 2 || Parameter1 == 1)
		{
			Rechenbar_--;
			if (Rechenbar_+1 > 0)
			{
				std::random_shuffle( VirtualKey_.begin(), VirtualKey_.end() );
			}
		}
		std::string CZSTR;
		CZSTR = IntToStr(Count_Zeichen);
		float CZF = Count_Zeichen;
		if (Improval == false)
		{
			std::ofstream Progress_2;
			Progress_2.open("Progress.txt");
			Progress_2 << ALL;
			Progress_2 << "\n";
			Progress_2 << CZSTR;	
			Progress_2.close();
		}
		else if (CZF/500 == int(CZF/500))
		{
			std::ofstream Progress_2;
			Progress_2.open("Progress.txt");
			Progress_2 << ALL;
			Progress_2 << "\n";
			Progress_2 << CZSTR;	
			Progress_2.close();
		}
		RechenOperator++;
		if (Parameter1 != 4 && KeyCreatorSystem == false)
		{
			if (RechenOperator == Parameter1)
			{
				CurKey = GlobalName_;
				RechenOperator = 0;
			}
			else
			{
				if (RechenOperator == 1)
				{
					CurKey = GlobalName_;
				}
				else if (RechenOperator != 1)
				{
					CurKey = GlobalName_;
					CurKey = CurKey.substr(0,CurKey.size()-7);
					CurKey += " ";
					std::stringstream convert;
					std::string KeyNumStr;
					convert << (RechenOperator-1);
					convert >> KeyNumStr;
					CurKey += KeyNumStr;
					CurKey += ".CodeX3";
				}
			}
		}
		else if (KeyCreatorSystem == true && Count_Zeichen != 1)
		{
			ChangeKey(Parameter1,Parameter2,true,GlobalName_);
			CurKey = GlobalName_;
			CurKey = CurKey.substr(0,CurKey.size()-7);
			CurKey += " ";
			CurKey += GlobalKeyNum_;
			CurKey += ".CodeX3";
		}
		else if (KeyCreatorSystem == true && Count_Zeichen == 1)
		{
			CurKey = GlobalName_;
			Keycreate(GlobalName_);
		}
		std::string Zeichen;
		Zeichen = INPUT;
		Zeichen = Zeichen.substr(Count_Zeichen-1,1);
		int Num = 0;
		if (Parameter2 < 255)
		{
			Num = ZeichenToInt(Zeichen,Parameter2);
		}
		else
		{
			if (Zeichen != " ")
			{
				unsigned char ASCIITABEL;
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
			}
			else
			{
				Num = 32;
			}
		}
		std::string NumStr;
		NumStr = IntToStr(Num);
		int line = 0;
		if (KeyCreatorSystem == true)
		{			
			std::ifstream CurrentKey;
			CurrentKey.open(CurKey.c_str());
			if (!CurrentKey)
			{
				INPUT = "FILE NOT FOUND";
				CurrentKey.close();
				return "Error Code 103";
			}
			std::string Line;
			line = 0;
			while (std::getline(CurrentKey,Line))
			{
				line++;
				std::string a;
				a = IntToStr(line);
				if (Line == NumStr)
				{
					break;
				}
			}
		}
		else
		{
			std::random_shuffle( VirtualKey_.begin(), VirtualKey_.end() );
			int InVector = 0;
			std::string InVectorStr;
			line = 0;
			while (InVector != Num)
			{
				line++;
				InVector = VirtualKey_[line-1];
				std::stringstream Wandler;
				Wandler << InVector;
				InVectorStr = Wandler.str();
				Wandler.clear();
			}
		}
		std::string Result;
		if (SYNTAX == true)
		{
			SYNT += NumStr;
			SYNT += "||";
			SYNT += IntToStr(line);
			SYNT += "\n";
		}
		else
		{
			int NewNum = line;
			if (Parameter2 < 255)
			{
				Result = IntToZeichen(NewNum,true,Parameter2);
				if (Result == "Zeichenerkennung Fehlerhaft oder Text leer, CRITICAL ERROR\n")
				{
					ErrorMessage = "Error Code 101";
					return ErrorMessage; 
				}
				if (Result == "\nNULLPOINTER\n")
				{
					ErrorMessage = "Error Code 102";
					return ErrorMessage;
				}
			}
			else
			{
				unsigned char c;
				c = char (NewNum);
				Result = c;
			}
		}
		all += Result;
	}
	if(!SYNTAX)
	return all;
	if(SYNTAX)
	return SYNT;
}
void ChangeKey(int Parameter_1,int Parameter_2,bool SystemParam, std::string KName)
{
	std::string KeyNumStr;
	std::string Key = KName;
	bool Existing = true;
	int KeyNumber = 0;
	while (Existing == true)
	{
		std::ifstream check;
		KeyNumber++;
		Key = KName;
		std::stringstream convert;
		convert << KeyNumber;
		convert >> KeyNumStr;
		Key = Key.substr(0,Key.size()-7);
		Key += " ";
		Key += KeyNumStr;
		Key += ".CodeX3";
		check.open(Key.c_str());
		if (!check)
		{
			Keycreate(Key);
			Existing = false;
		}
	}
	GlobalKeyNum_ = KeyNumStr;	
}
void Keycreate(std::string KeyName)
{
	// Zufällige Zahlen erzeugen
//	MessageBox::Show(gcnew String(KeyName.c_str()));
	std::vector<int> numbers(Parameter_[2]);
    for(size_t i=0;i<numbers.size();++i)
	{
		numbers[i] = i+1;
	}
	std::random_shuffle( numbers.begin(), numbers.end() );

    // Version A, schreibt direkt in die Datei

	std::ofstream SaveKey( KeyName.c_str(), std::ios::out );
	for (size_t i=0;i<numbers.size();++i )
    {
		SaveKey << numbers[i] << '\n'; 
	}
	SaveKey.close();

	/*
	const char* szA = "Hello";
	const wchar_t *szW = L"World";
	String ^strA = gcnew String(szA);
	String ^strW = gcnew String(szW);
	*/
}

Decode.h

#ifndef DECODE_HEADER_H 
#define DECODE_HEADER_H 

//Need: DatenSatz.h
//Need: STRINT.h
//Need: Tausch.h

#include <windows.h>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <deque>
#include <algorithm>

#include "STRINT.h"
#include "DatenSatz.h"
#include "Tausch.h"
#include "Fehlerberichtersteller.h"

using namespace System;
using namespace System::Windows::Forms;

std::string Decode(std::string InformationLocation, std::string ToDecode);
bool TabelExistence(std::string Location);
int DataSetChecker(std::string DATASET_);
// std::string Enttauscht
std::string ErrorMessage;

std::deque<int> VirtualDeq;

std::string Decode(std::string InformationLocation, std::string ToDecode)
{
	bool EXI = TabelExistence(InformationLocation);
	bool KeyisValid = false;
	std::string tag;
	std::string Fehlerbericht;
	if (EXI == false)
	{
		Fehlerbericht = "Schlüssel Existiert nicht. Interner Systemfehler";
		Erstellen_EBer(Fehlerbericht,"Error Code 104");
		return "Error Code 104";
	}
	std::ifstream Validation;
	Validation.open(InformationLocation.c_str());
	std::getline(Validation,tag);
	if (tag == "1.0 cx3keytyp")
	{
		KeyisValid = true;
	}
	else if (tag == "1.1 cx3keytyp")
	{
		KeyisValid = true;
	}
	else
	{
		KeyisValid = false;
		Fehlerbericht = tag;
		Fehlerbericht += char(10);
		Fehlerbericht += "zu hohe Versionsnummer, aktualisieren sie Code X3";
		Erstellen_EBer(Fehlerbericht,"Error Code 105");
		return "Error Code 105";
	}
	std::string Dimensionen_;
	std::string Dataset_;
	std::string _System_;
	std::string Tabel_;
	std::string RandNum;
	std::getline(Validation,Dimensionen_);
	std::getline(Validation,Dataset_);
	std::getline(Validation,_System_);
	if (_System_ == "System: MASTER")
	{
		std::getline(Validation,RandNum);
	}
	std::getline(Validation,Tabel_);
	Validation.close();
	int Dim = StrToInt(Dimensionen_.substr(13,1));
	int Dset = DataSetChecker(Dataset_);
	std::string Enttauscht;
	if (Tabel_ == "TABEL: true")
	{
		std::string TabelLoc;
		TabelLoc = InformationLocation;
		TabelLoc = TabelLoc.substr(0,TabelLoc.size()-18);
		TabelLoc += "Tabel.CodeX3_T";
	//	MessageBox::Show(gcnew String(TabelLoc.c_str()));
		Enttauscht = Enttauschen(ToDecode,TabelLoc);
		ToDecode = Enttauscht;
	}
	if (Enttauscht == "ERROR")
	{
		Fehlerbericht = "Tauschen Misslungen, beschädigte Tauschtabelle";
		Fehlerbericht += char(10);
		Fehlerbericht += ToDecode;
		Erstellen_EBer(Fehlerbericht,"Error Code 106");
		return "Error Code 106";
	}	
	std::vector<int> VirtualKey;
	if (_System_ == "System: MASTER")
	{
		srand(5);
		VirtualKey.empty();
		VirtualKey.clear();
		int Mn = 0;
		while (Mn < Dset)
		{
			Mn++;
			VirtualKey.push_back(Mn);
			VirtualDeq.push_back(Mn);
		}
		int Sizero = VirtualDeq.size();
		Sizero = VirtualKey.size();
	}
	std::sort(VirtualKey.begin(),VirtualKey.end());
	std::string OUTPUT;
	int i = 0;
	while (i < ToDecode.size())
	{
		i++;
		std::string Zeichen = ToDecode.substr(i-1,1);
		int Num;
		if (Dset < 200)
		{
			int Dset_ = 0;
			Dset_ = DataSetChecker(Dataset_);
			Num = ZeichenToInt(Zeichen,Dset_);
		}
		else
		{
			if (Zeichen[0] == char(10) || Zeichen[0] == char(13) || Zeichen == "\n")
				Num == int("\n");
			else
			{
				unsigned char ASCIITABEL;
				ASCIITABEL = Zeichen[0];
				Num = static_cast<int>(ASCIITABEL);
			}
		}
		std::string NUMMERSTR = IntToStr(Num);
		std::string CurrentKey;
		std::string num = "";
		if (_System_ == "System: NEW")
		{
			int Keynum = i - 1;
			if (Keynum == 0)
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-19);
				CurrentKey += ".CodeX3";
			}
			else
			{
				CurrentKey = InformationLocation.substr(0,InformationLocation.size()-18);
				CurrentKey += IntToStr(Keynum);
				CurrentKey += ".CodeX3";
			}
			std::ifstream reader;
			reader.open(CurrentKey.c_str());
			if (!reader)
			{
				ErrorMessage = "Error Code 100";
				Fehlerbericht = "Schlüssel nicht gefunden, möglicher Verlaufsfolgefehler";
				Fehlerbericht += char(10);
				Fehlerbericht += CurrentKey;
				Erstellen_EBer(Fehlerbericht,ErrorMessage);
				return ErrorMessage;
			}
			int Zeile = 0;
			while(Zeile < Num)
			{
				Zeile++;
				std::getline(reader,num);
			}
			reader.close();
		}
		if (_System_ == "System: MASTER")
		{
			std::random_shuffle(VirtualKey.begin(),VirtualKey.end());
			int Zeile = 0;
			while(Zeile < Num)
			{
				Zeile++;
			}
			if(!VirtualKey[Zeile])
			{
				Erstellen_EBer(IntToStr(Zeile),"Error Code 107");
				return "Error Code 107";
			}
			num = IntToStr(VirtualKey[Zeile]);
		}
		Erstellen_EBer(IntToStr(i),"Error Code 107");
		int NUMBER = StrToInt(num);
		std::string back;
		if (Dset < 200)
		{
			if (num == "" || num == "0")
				MessageBox::Show(gcnew String(num.c_str()));
			back = IntToZeichen(NUMBER,false,Dset);
			if (back == "Zeichenerkennung Fehlerhaft oder Text leer, CRITICAL ERROR\n")
			{
				Fehlerbericht = "Zeichenerkennung Fehlgeschlagen\n";
				Fehlerbericht += num;
				Fehlerbericht += char(10);
				Fehlerbericht += _System_;
				Fehlerbericht += char(10);
				Fehlerbericht += Dimensionen_;
				Fehlerbericht += char(10);
				Fehlerbericht += Dataset_;
				Fehlerbericht += char(10);
				Fehlerbericht += back;
				Fehlerbericht += char(10);
				Fehlerbericht += CurrentKey;
				Erstellen_EBer(Fehlerbericht,"Error Code 101");
				return "Error Code 101"; 
			}
			if (back == "\nNULLPOINTER\n")
			{
				Fehlerbericht = "NULLPOINTER CRITICAL ERROR\n";
				Fehlerbericht += num;
				Fehlerbericht += char(10);
				Fehlerbericht += NUMMERSTR;
				Fehlerbericht += char(10);
				Fehlerbericht += _System_;
				Fehlerbericht += char(10);
				Fehlerbericht += Dimensionen_;
				Fehlerbericht += char(10);
				Fehlerbericht += Dataset_;
				Fehlerbericht += char(10);
				Fehlerbericht += back;
				Fehlerbericht += char(10);
				Fehlerbericht += CurrentKey;
				Erstellen_EBer(Fehlerbericht,"Error Code 102");
				return "Error Code 102";
			}
		}
		else
		{
			unsigned char c;
			c = char (NUMBER);
			back = c;
		}
		OUTPUT += back;
		int Tester_OUT = NUMBER; // Value To Check here
		std::string Tester_Out_Str = IntToStr(Tester_OUT); //Str_Val to check here
	//	MessageBox::Show(gcnew String(Tester_Out_Str.c_str()));
	}
	return OUTPUT;
}
bool TabelExistence(std::string Location)
{
	std::ifstream check;
	check.open(Location.c_str());
	if (check)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int DataSetChecker(std::string DATASET_)
{
	if (DATASET_ == "Dataset: 255")
	{
		return 255;
	}
	else if (DATASET_ == "Dataset: 103")
	{
		return 103;
	}
	else if (DATASET_ == "Dataset: 75")
	{
		return 75;
	}
	else if (DATASET_ == "Dataset: 53")
	{
		return 53;
	}
	else
	{
		return 0;
	}
}

#endif

unskilled

ne, sry - zumindest heut guck ich mir das nicht mehr an...

"nein ist hier unpassend[Rede vom push_back] da Result = std::string"
ja, und?
std::string::push_back

Das ist so grausam, da wirst du wohl auch niemanden finden, der sich das gern angucken wird...
ich hab bei der zeile hier aufgehört:
std::string Encode(std::string INPUT, int Parameter1, int Parameter2, bool KeyCreatorSystem, bool Improval, std::string Passwort, std::string Gname, bool SYNTAX, int VECTSHUFFLE)

Natürlich möchte ich so eine Funktion benutzen... nicht!

Keine Angst - der Rest ist nicht besser...

Bevor du nicht mind. das korrigierst, was ich oben schon geschrieben habe, guck ich mir das vrmtl nicht an - bin zwar ein bisschen neugierig, aber so viel zu viel zeit hab ich auch nicht - und meine geduld ist sehr begrenzt
wieso kopierst du den string eigtl ncoh mal und nimmst dann auch noch den .net string?
wieso schreibst du dir dein IntToStr nicht selbst?
usw. usf.

bb

PS:
"Zeilenumbruch verschwindet im Forum ?????????"
Nein ????????????????

Michael E.

Tim06TR: In einem Jahr wirst du keine Ahnung mehr haben, was du da geschrieben hast.

Kleiner Tipp: Funktionen über 200 Zeilen sind out

Problem beim Umwandeln char &lt;-&gt; int

Problem beim Umwandeln char <-> int