int getinfo(int argc, char *argv[])
{
	if (argc == 1)//wenn programm in konsole ohne argumente gestartet wird
	{
		cerr << "\nFEHLER\nDas Programm " << argv[0] << " muss mit Argumenten aufgerufen werden.\nMit \"" << argv[0] << " -h\" erfahren Sie mehr.\n";
		return 1;
	}

	if (argc > 1)
	{
		std::vector<std::string> arguments(argv, argv + argc);
		if (arguments.at(1) == "-h")
		{
			cout << endl;
			cout << argv[0] << " Pfad Modus Passwort";
			cout << endl;
			cout << endl;
			cout << "\tPfad:\n\t\tfür Dateien:\tbla/blub.xyz\n\t\tfür Ordner:\tbla/blub/";
			cout << endl;
			cout << endl;
			cout << "\tModus:\n\t\tzum Verschlüsseln:\tver\n\t\tzum Entschlüsseln:\tent\n\t\tfür Lodatei \"log\"  anhängen";
			cout << endl;
			cout << endl;
			cout << "\tPasswort\n\t\ta-z\n\t\t0-9\n\t\t12 Zeichen maximal";
			cout << endl;
			cout << endl;
			return 1;
		}
	}

int i=0,j=0,k=0;

//pfad
char *pathread_p;
char pathread[1000];
	if (argc > 0){pathread_p = argv[1];}
	snprintf(pathread, 1000, "%s", pathread_p);

//ordner -->1/0 aus pfad ableiten
bool ordner=false;
	if (pathread[strlen(pathread) - 1] == '/'){ordner = true;}//feststellen, ob ein ordner oder eine datei vorliegt

//modus
char *char_modus_p;
char char_modus[50];
	if (argc > 0){char_modus_p = argv[2];}
	snprintf(char_modus, 50, "%s", char_modus_p);

bool verschluesseln, entschluesseln, log;
	while (true)
	{
		if ((char_modus[0] == 'v')&&(char_modus[1] == 'e')&&(char_modus[2] == 'r')){verschluesseln = true;}
		else {verschluesseln = false;}
		if ((char_modus[0] == 'e')&&(char_modus[1] == 'n')&&(char_modus[2] == 't')){entschluesseln = true;}
		else {entschluesseln = false;}
		if ((char_modus[3] == 'l')&&(char_modus[4] == 'o')&&(char_modus[5] == 'g')){log = true;}
		else {log = false;}
		if (((verschluesseln == true)||(entschluesseln == true))&&((log == true)||(char_modus[3] == '\0'))){break;}
		if (argc > 0)
		{
			cerr << "\nFEHLER\n" << char_modus_p << " ist kein gültiger Modus.\nGeben Sie \"ver\" zum verschluesseln bzw. \"ent\" zum entschluesseln ein ggf. gefolgt durch \"log\", um eine Logdatei zu erzeugen.\n";
			return 1;
		}
	}

//passwort
char code[CODELENGTH];
char *code_safe_p;
bool check[CODELENGTH];
for (int i=0; i<CODELENGTH; i++){check[i] = false;}
char zahlenundbuchstaben[36] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
	while (true)
	{
		if (argc > 0){code_safe_p = argv[3];}
		snprintf(code, CODELENGTH, "%s", code_safe_p);
		while (true)
		{
			if (strlen(code) == CODELENGTH){break;}
			code[strlen(code)] = '8';
		}
		//new
		for (int i=0; i<CODELENGTH; i++)
		{
			for (int j=0; j<36; j++)
			{
				if (code[i] == zahlenundbuchstaben[j]){check[i] = true;}
			}
		}
cout << check[11] << endl;
cout << code[11] << endl;
//check[11] = false;
//if (check[11] = false){cout << "blablub"; code[11] = '8';}
//code[11] = '8';
		for (int i=0; i<CODELENGTH; i++)
		{
			if (check[i] = false){cout << "C++ works again" << endl; code[i] = '8';}
		};
cout << code[11] << endl;
cout << code << endl;
		break;
		//new end
		/*k=0;
		for (i=0; i<CODELENGTH; i++)//ueberpruefen der zeichen von code
		{
			for (j=0; j<36; j++)
			{
				if (code[i] == zahlenundbuchstaben[j]){k++;}
				if (k == CODELENGTH){break;}
			}
			if (k == CODELENGTH){break;}
		}
		if (k == CODELENGTH){break;}*/
		if (argc > 0)
		{
			cerr << "\nFEHLER\nDer Code kann maximal " << CODELENGTH << " Zahlen oder / und kleine Buchstaben enthalten.\n";
			return 1;
		}
	}

	//codeit(pathread, verschluesseln, entschluesseln, code, ordner, log, argc, argv);
	return 0;
}

meine fehler treten in //passowrt auf
von der kommandozeile wird ein passwort abgefragt, maximal CODELENGTH (12) zeichen in code kopiert und mit 8en auf 12 zeichen aufgefüllt. sollte ein zeichen von code nicht den zeichen in buchstabenundzahlen entsprechen, so wird stattdessen eine 8 verwendet. leider klappt das nicht so ganz...

cout << check[11] << endl;
cout << code[11] << endl;
//check[11] = false;
//if (check[11] = false){cout << "blablub"; code[11] = '8';}
//code[11] = '8';
		for (int i=0; i<CODELENGTH; i++)
		{
			if (check[i] = false){cout << "C++ works again" << endl; code[i] = '8';}
		};
cout << code[11] << endl;
cout << code << endl;

wenn man das programm folgendermaßen aufruft:

./codeit bla.txt ver piaegenolf

ist check[11] bei mir immer false!
obwohl code[11] eigentlich eine 8 sein sollte, bekomme ich in der konsole statt der 8 immer ein ? mit nem quadrat auf der ecke stehend ausgegeben

ist das mein fehler oder bin ich gaga, oder ahhh!!!!
ist das mein fehler oder baut mein compiler da mist?
wenn ich code[11] manuell setze geht es mit der auskommentierten abfrage if()... geht es jedoch nicht.

weiß jemand mehr, als ich?

if (check[i] = false)

Das ist wohl nicht Absicht, oder? Vergleichen tut man mit "=="...
Aber prinzipiell ist das deine Aufgabe, zu debuggen. Mit nem Debugger kannst du wunderbar dein Programm Stück für Stück durchlaufen lassen und die Werte der Variablen anschauen.

seht euch mal folgenden code an:

Ne das ist zu viel. Minimiere deinen Code. Entferne alles außer der stelle, wo dein Problem ist. Vielleicht findest du dann selber die lösung.

Bei sowas kannst du die Übersicht behalten?

@athar
ja, MEISTENS liegt es am code, dennoch kann es auch am compiler liegen, denn der ist auch nur ein von menschen geschriebenes programm und genau deswegen übernehmen die programmierer des g++ auch keine verantwortung für mögliche fehler im compiler

ich hab den fehler andauernd wieder überlesen...
jedenfalls danke für die schnelle hilfe!!!

const char* const cm=char_modus;
verschluesseln=cm[0]=='v' && cm[1]=='e' && cm[2]=='r';
entschluesseln=cm[0]=='e' && cm[1]=='n' && cm[2]=='t';
log=cm[3]=='l' && cm[4]=='o' && cm[5]=='g';
if ((verschluesseln || entschluesseln) && (log || cm[3]=='\0'))break;

Kurzfassen lohnt sich, auch beim Programmieren.
Die Leser werden's dir danken. Du selbst dir auch, wenn du deinen Code später nochmal lesen musst.

Aufgeräumt sieht das so aus:

Das ist für mich genau das gleiche.
Wir sind ja hier in einem C++ Forum und in C++ gibt es viele tolle Sachen, die sowas wirklich aufräumen.

ja, MEISTENS liegt es am code, dennoch kann es auch am compiler liegen, denn der ist auch nur ein von menschen geschriebenes programm und genau deswegen übernehmen die programmierer des g++ auch keine verantwortung für mögliche fehler im compiler

Ich denke du kannst noch einige Zeit davon ausgehen, dass auftretende Problem nie am Compiler sondern an deinem Code liegen. Riesige Projekte, die deutlich "extremere" features als simples if/else nutzen, haben keinerlei Probleme.

Das ist für mich genau das gleiche.

Naja, beim Original bekomme ich persönlich Kopfschmerzen, bei der aufgeräumten Variante sehe ich auf den ersten Blick, dass hier nach Zeichenfolgen gesucht wird.

Wir sind ja hier in einem C++ Forum und in C++ gibt es viele tolle Sachen, die sowas wirklich aufräumen.

Sowas kann durchaus Sinn machen, wenn man Daten nach Zeichenfolgen absuchen muss. Mit string (falls du das meintest) wäre das um ein Vielfaches langsamer.
Ist hier vermutlich aber nicht der Fall.

@nexus

ja, MEISTENS liegt es am code, dennoch kann es auch am compiler liegen, denn der ist auch nur ein von menschen geschriebenes programm und genau deswegen übernehmen die programmierer des g++ auch keine verantwortung für mögliche fehler im compiler

Keine Frage, der GCC hat Bugs. Aber der GCC gehört auch mit zu den bestgetesteten programmen die man so auf dem opensource markt kriegen kann. Immerhin wird der von mehreren Betriebssystemen als Grundlage verwendet.
Die Bugs die der GCC hat sind eignetlich nur Kategorien: 1. floatingpoint Berechnungen beim Optimieren(das fällt auf bei Rechenfehlern nach der 15. Nachkommastelle) 2. nicht unterstützte Sprachfeatures. Und bei 2. sind das so spezielle Sachen, dass die meisten Programmierer damit nie in Berührung kommen.

Also, bevor du das nächste mal glaubst, dass dein Compiler verbuggt ist: check deinen Code 15 mal Zeile für Zeile mit dem Debugger. Der Compiler wurde von Profis geschrieben die ihn brauchten um ihre eigenen Programme zu compilieren. Die werden sicherlich merken, wenn da was einfaches kaputt ist...

wäre das um ein Vielfaches langsamer.

Wieso ist denn

char c[x];
...
c[0] == 'a' && c[1] == 'b' && c[2] == 'c'

um ein Vielfaches schneller als

string c;
...
c == "abc"

Weil du im ursprünglichen Fall noch ein substr brauchst.

Man sollte natürlich nicht unnötig kopieren.

Falls es es sich tatsächlich um ein geschwindigkeitskritisches Programm handelt (was hier sicherlich nicht der Fall ist), dürfte std::string etwas im Nachteil sein. Zum Beispiel wegen der dynamischen Allokation oder teilweise unnötigen Kopien.

Aber zum Glück programmieren wir in C++, wo Sauberkeit und Effizienz nicht zwingend Gegensätze sind.

verschluesseln=cm[0]=='v' && cm[1]=='e' && cm[2]=='r'

wird zu

verschluesseln = std::equal(cm, cm+3, "ver");

Ahnte ich schon, dass die Standard-Library da was schönes bereithält.
Falls das vergleichbaren Assemblercode produziert, ist es so natürlich besser.

programmierst Du in Assembler oder C++? Lesbarkeit von Code ist sehr wichtig. Ich verzichte sogar an der einen oder anderen Stelle auf den einen oder anderen Takt im Prozessor, um den Code lesbar zu machen. In der Regel wird er dadurch deutlich besser und fehlerfreier. Du hast selbst erlebt, wie Dein Spaggetticode zu unlesbaren Code führt, so dass Du selbst triviale Fehler überliest. Das hast Du mit diesem Beitrag doch demonstriert.

Und C++ ist deswegen so gut, da der lesbare Code in der Regel keinen Overhead produziert. (Textzeile aus einer bedeutenden C++-Hymne: "I want abstraction and optimization both"

Das Beispiels ist sehr gut dafür. Das std::equal produziert tatsächlich keinen Overhead. Allerdings sagst Du nicht nur dem Leser des Codes sondern auch der Standardbibliothek und dem Compliler präziser, was Du tun willst. Dadurch kann der Compiler möglicherweise spezializierte Assemblerbefehle verwenden, die er bei Deinem Spaghetticode nicht kann.

programmierst Du in Assembler oder C++? Lesbarkeit von Code ist sehr wichtig. Ich verzichte sogar an der einen oder anderen Stelle auf den einen oder anderen Takt im Prozessor, um den Code lesbar zu machen. In der Regel wird er dadurch deutlich besser und fehlerfreier. Du hast selbst erlebt, wie Dein Spaggetticode zu unlesbaren Code führt, so dass Du selbst triviale Fehler überliest. Das hast Du mit diesem Beitrag doch demonstriert.

Ich bin nicht der OP
Dass Lesbarkeit wichtig ist, sagte ich schon selbst. Bis auf performancekritische Codebereiche auch wichtiger als Effizienz.

tntnet schrieb:

Und C++ ist deswegen so gut, da der lesbare Code in der Regel keinen Overhead produziert. (Textzeile aus einer bedeutenden C++-Hymne: "I want abstraction and optimization both"

In der Theorie schon, aber das erfordert, dass die Compiler auch alle Optimierungsmöglichkeiten ausnutzen. Zumindest g++ produziert hier auch bei -O3 nicht immer optimalen Code, gerade wenn's ums Loop-Unrolling geht. In "normalem" Code ist das völlig egal, aber wenn es um Schnelligkeit geht, sollte man selbst überprüfen, ob der Compiler das ideal löst.

int test()
{
  const char cm[4]="ver"; //das reicht schon, um g++ aus dem Konzept zu bringen
  return std::equal(cm, cm+3, "ver"); //kompiliert in eine schön umfangreiche Schleife
  //return cm[0]=='v' && cm[1]=='e' && cm[2]=='r'; //kompiliert zu mov eax,1
}

Naja, egal. Im Grunde wollte ich nur sagen, dass man möglichst lesbaren Code schreiben sollte.