ich möchte eine silbenliste erstellen und dabei auch einige bedingungen beachten lassen. bisher sieht das bei mir so aus:

//a b und c sind chars, die in schleifen von ascii 97(a) bis 122 (z) "durchzählen"
if(a == 97 || a == 101 || a == 105 || a == 111 ||
        a == 117 || a == 121 || b == 97 || b == 101 ||
	b == 105 || b == 111 || b == 117 || b == 121||
	c == 97 || c ==101 || c == 105 || c == 111 ||
	c == 117 || c == 121 || !(a == 106 && b ==106)
	|| !(b == 106 && c == 106) || !(a == 113 && b == 113)
	|| !(b == 113 && c == 113) || !(a==b && b==c && b==a)) {
//...schreiben
}

ich habe aber bemerkt, dass oder hier fehl am platze ist. denn wenn nur eine der bedingungen richtig ist ( also zum beispiel, dass ein q drin ist), dann ist ja gleich der ganze ausdruck wahr und wird geschrieben in meine datei.
welchen logischen operator könnte ich denn hier besser verwenden, oder wie sollte ich das anders lösen, dass es funktioniert?

(die bedingungen mit den einzelnen sachen sind mir auch nicht ganz geheuer, sie sollen EIGENTLICH dafür sorgen, dass keine q und j dopplungen auftreten)

viele grüße

nun, es soll verhindert werden, dass nur konsonanten in dem trio enthalten sind ( bbb, lkj, whatever ). und eben, dass 2er folgen von q und j auftreten können also sowas wie "aqq" soll auch rausgeworfen werden.

so long

...

//a b und c sind chars, die in schleifen von ascii 97(a) bis 122 (z) "durchzählen"
if(a == 97 || a == 101 || a == 105 || a == 111 ||
        a == 117 || a == 121 || b == 97 || b == 101 ||
	b == 105 || b == 111 || b == 117 || b == 121||
	c == 97 || c ==101 || c == 105 || c == 111 ||
	c == 117 || c == 121 || !(a == 106 && b ==106)
	|| !(b == 106 && c == 106) || !(a == 113 && b == 113)
	|| !(b == 113 && c == 113) || !(a==b && b==c && b==a)) {
//...schreiben
}

...

Das ist "multi award winning bad code" !!

• voller "magic numbers": Wirst Du in einem Jahr noch wissen, wofür 106 steht ?
• absolut nichtssagende Variablennamen: Frag mal einen Kollegen, ob ihm sofort klar ist, wann man b ändern darf
• voller Dopplungen: Ist es wirklich sinnvoll, mal diese Variable gegen 105 abzufragen und mal jene ?
• ohne erkennbare Struktur: Sicher, dass die Prüfungen aus fachlichen Gründen in genau der Reihenfolge ablaufen müssen ?
• am falschen Ende Platz gespart: Warum überhaupt so viele Prüfungen in ein Statement packen ?
• Bahnschienen-Flexibilität: Was, wenn plötzlich statt 106 gegen 107 abgeprüft werden soll ?
• ...

Ich will Dich damit nicht "fertigmachen", sondern dazu motivieren, Deinen Satz an Programmiertechniken mal gründlich auzustocken. Z.B. um

• bool-Variablen
• Konstanten und enums (die einem helfen Werte mit sprechenden Namen zu versehen)
• switch/case-Statements oder besser noch
• Container (mit denen man Mengen von Werten in einem verwalten kann und dann jede Variable mit einem einzigen "find()" dagegen abprüfen kann)
• ...

Gruß,

Simon2.

P.S.: Zum Letzten ein kleines Beispiel:

int myChoice;
set<int> specialValues;
int const special_goBack = 97;
int const special_double = 101;
int const special_wrongType = 105;
specialValues.insert(special_goBack);
specialValues.insert(special_double);
specialValues.insert(special_wrongType);

if(specialValues.find(myChoice) != specialValues.end()) {
   cout << "jetzt weiß ich, dass myChoice einen special Value hat\n";
}

1.wie soll ich denn das mit den nummern lösen? die nummern stehn ja für best. zeichen im ascii satz, soll ich da mit sowas wie define ( was ja auch kein gutes coden wäre oO ) rangehn?

const int ascii_q = 106;
if(ersterchar == zweiterchar == ascii_q) { 
//...
}

ist sowas möglich? oO

2.wie kann ich das denn in mehrere prüfungsdurchgänge packen? es geht doch immer nur um das verhindern vom schreiben, wenn bestimmte bedingungen erfüllt sind. soll ich da ifs verschachteln?

3.nun, hier in diesem tool wird der fall nie auftreten, dass statt gegen 106 gegen 107 geprüft werden soll

4. nc zur struktur. aber das ist ja auch das problem, weshalb ich hier gefragt habe. wie kann ich da struktur reinbringen??

5. wie kann ich die dopplungen mit containern umgehen? ein beispiel bitte
( war mir schon beim schreiben aufgefalln, dass das umständlich ist)
//edit erledigt

das wars dann erstma^^

const int ascii_q = 'q';

dann könnt ich ja auch gleich auf 'q' überprüfen
mach ich wohl besser

Um 2 gleiche Buchstaben nebeneinander ausfindig zu machen überprüfst du einfach a und b und dann b und c auf Gleichheit, wenn da true rauskommt verzweigst du weiter und guckst, ob es sich bei den verglichenen Zahlen um den Code für Q oder J oder was auch immer handelt.

Und um zu prüfen, ob es sich nur um Konsonanten handelt schaust du einfach jeden einzeln an ob es ein Konsonant ist (mach dir ne Funktion IsConsonant() die das prüft (wegen Übersichtlichkeit)) und verknüpst dann mit && ... also WENN (A ist Konsonant UND B ist Konsonant UND C ist Konsonant) dann ungültig ... usw. usf.

Noch Fragen?

ich hätte es auch nicht als fertigmachen aufgefasst, sondern als konstruktive kritik....

Super ! Das ist sehr löblich !

just-another-programmer schrieb:

...1.wie soll ich denn das mit den nummern lösen? die nummern stehn ja für best. zeichen im ascii satz, ...

muss es wirklich ASCII sein (also auch auf non-ASCII-Plattformen) ? Oder ist es nicht vielmehr "der auf der Plattform übliche Zeichensatz" ?
Dann könntest Du nämlich den "von Gott dafür vorgesehenen Datentyp" nehmen: char ... zusammen mit den sprechenden Literalen:

if(ersterchar == zweiterchar == 'q') { //...}

... und sobald man mehrere davon hat: std::string und Stringliterale:

string zeichenKette = "Simon2";
if(zeichenKette[0] == zeichenKette[1] == 'q') { //...}

just-another-programmer schrieb:

2.wie kann ich das denn in mehrere prüfungsdurchgänge packen? es geht doch immer nur um das verhindern vom schreiben, wenn bestimmte bedingungen erfüllt sind. soll ich da ifs verschachteln?

Naja, Du kannst ja "schrittweise" prüfen:

bool ist_q_enthalten = false;
ist_q_enthalten |= (a == 'q') || (b == 'q');
ist_q_enthalten |= (c == 'q');
// ... 1000 andere Prüfungen

bool ist_Bedingung_erfuellt = ist_q_enthalten || ist_doppelt;
// ... 10.000 weitere Bedingungen

if(ist_Bedingung_erfuellt) {
   // ... mach, was zu tun ist

just-another-programmer schrieb:

3.nun, hier in diesem tool wird der fall nie auftreten, dass statt gegen 106 gegen 107 geprüft werden soll

=>

... Ein Computer wird nie mehr als 64kB Hauptspeicher brauchen ...

:p
Ich bin zwar kein Freund von "Überflexibilisierung" aber dieses Maß an "Konkretion" ist mir doch zuuuu kurzsichtig.
Es wird Dir schon beim Debuggen (und das kommt IMMER, weil niemand ein (nennenswertes) Programm auf Anhieb 100%ig fehlerfrei schreiben kann) mächtig auf den Sack gehen, dass Du jedesmal überlegen musst, was denn 105 nun eigentlich ist ....

Gruß,

Simon2.

P.S.: Mein Akku ist gleich leer ... schaue sonst morgen oder so nochmal rein.

Noch Fragen?

Was kostet einmal nageln?

vielen dank euch allen und ( irgendwann xD) ne gute nacht

//edit doch noch ne frage an simon2:

wie funktioniert das denn mit den |= ( oderistgleich? )? könntest du das vllt nochmal kommentiert posten?

...
wie funktioniert das denn mit den |= ( oderistgleich? )? könntest du das vllt nochmal kommentiert posten?

"a |= b;" ist dassselbe wie "a = a | b;"
Ist für viele Operatoren so definiert :
+=, -=, ~=, &=, .....

Gruß,

Simon2.

jetz isses geklärt und muss nur noch umgesetzt werden. mal sehn ob ich nochma hilfe brauch

...Und um zu prüfen, ob es sich nur um Konsonanten handelt ...

... nimmt man ebenfalls einfach Gottgegebenes:

string vokale = "aeiouAEIOU";

string s;
if(s.find_first_of(vokale) == string::npos) {
   cout << "kein Vokal drin\n";
}

Gruß,

Simon2.

...extra 'nen String würd ich dazu aber nicht anlegen. Geschmackssache ..

Ich auch nicht (jedenfalls nicht, wenn ich den nicht noch für was Anderes verwenden müsste) ... war mehr zur Demonstration gedacht, wie man strings anlegen kann.
(hätte natürlich auch const sein müssen )

Gruß,

Simon2.

if(zeichenKette[0] == zeichenKette[1] == 'q') ...

Sowas funktioniert nicht, da muss man einzeln abfragen, also if (zeichenKette[0]=='q' && zeichenKette[1]=='q') . Ich weiß grad nicht, ob der Operator '==' rechts- oder linksrum ausgewertet wird, aber je nachdem würde aus

if ( bla[0] == bla[1] == 'q' )

halt

if ( (bla[0] == bla[1]) == 'q' )

oder

if ( bla[0] == (bla[1] == 'q') )

werden. Das ist insofern schlecht, als dass der Operator == für Integer einen bool-Wert zurückgibt. Dann würde ein Zeichen mit 'true'/'false' verglichen werden, was bestimmt nicht das gewünschte Ergebnis bringt

(mit funktionen, die bools zurückgeben in den ifs steht nur noch drin, was verglichen wird ich habe nur noch bools^^)

hallo.

ich möchte eine silbenliste erstellen und dabei auch einige bedingungen beachten lassen. bisher sieht das bei mir so aus:

//a b und c sind chars, die in schleifen von ascii 97(a) bis 122 (z) "durchzählen"
if(a == 97 || a == 101 || a == 105 || a == 111 ||
        a == 117 || a == 121 || b == 97 || b == 101 ||
	b == 105 || b == 111 || b == 117 || b == 121||
	c == 97 || c ==101 || c == 105 || c == 111 ||
	c == 117 || c == 121 || !(a == 106 && b ==106)
	|| !(b == 106 && c == 106) || !(a == 113 && b == 113)
	|| !(b == 113 && c == 113) || !(a==b && b==c && b==a)) {
//...schreiben
}

ich habe aber bemerkt, dass oder hier fehl am platze ist. denn wenn nur eine der bedingungen richtig ist ( also zum beispiel, dass ein q drin ist), dann ist ja gleich der ganze ausdruck wahr und wird geschrieben in meine datei.
welchen logischen operator könnte ich denn hier besser verwenden, oder wie sollte ich das anders lösen, dass es funktioniert?

(die bedingungen mit den einzelnen sachen sind mir auch nicht ganz geheuer, sie sollen EIGENTLICH dafür sorgen, dass keine q und j dopplungen auftreten)

viele grüße