Zugehörigkeitsoperator in C++ ?

[PAX]

Ich grüße euch!

Ich hab mich vor kurzem an C++-Builder herangewagt und nun kamen einige Fragen auf zu dieser Programmiersprache...

Ich bekomme einfach nicht heraus, wie ich prüfen kann, ob ein Bezeichnerwert Element einer Menge ist! In Delphi funktionierte das mit dem Operator "in". Beispielsweise:

if v in ['a', 'c', 'd'] then dies else das; Wie mache ich soetwas in C++?

Viva los tioz!

LG


PAX

[Frickeldrecktuxer_TM]

Zitat von PAX:

Wie mache ich soetwas in C++?

Syntaktisch? gar nicht. C(++) kennt keine Sets.
In ISO-C++ gibt es aber das Template std::set<>, das genau das machen dürfte, was du suchst. Du kannst mit std::set<>::find() nach dem Eintrag suchen, kommt er nicht im Set vor, ist der Rückgabewert von find() identisch mit std::set<>::end() für die gleiche Instanz.

[PAX]

hmm... das is schade... :/

es gibt viele dinge, die mir an c++ gefallen (im vergleich zu delphi), aber dass dann solche sachen wieder so kompliziet sein müssen...

danke für die lösung, Frickeldrecktuxer_TM

viva los tioz!


PAX

[Frickeldrecktuxer_TM]

Zitat von PAX:

es gibt viele dinge, die mir an c++ gefallen (im vergleich zu delphi), aber dass dann solche sachen wieder so kompliziet sein müssen...

Kompliziert?
In C sind es einfach Bitoperationen, da kannst du sicher sein, daß es kompakt bleibt und du bist nicht auf die Implementierung des Compilers angewiesen (Borland kann sich sowas leisten, die haben keine Konkurrenz):

Code:

typedef SomeSet unsigned int;
const SS_FIRST  = 1 << 0; // vorsicht, C99, nicht C89 oder K&R!
const SS_SECOND = 1 << 1;
const SS_THIRD  = 1 << 2;
const SS_FOURTH = 1 << 3;

SomeSet myset;
myset = SS_FIRST | SS_THIRD; // SS_FIRST und SS_THIRD im Set
myset |= SS_FOURTH; // SS_FOURTH mit ins Set genommen
myset &= ~SS_FIRST; // SS_FIRST aus dem Set entfernt;
if (myset & SS_THIRD) { }; // wird ausgeführt, wenn SS_THIRD im Set ist

Wenn dir die Bitoperationen in C zu ungewohnt sind, kannst du dir ja Funktionen (in C++ besser Templates) wie SET_INSERT() oder SET_REMOVE() schreiben. Eklig wird es dann nur, wenn dein Set mehr elemente enthalten soll, als deine Plattform Bits in Integern kennt. Mit einem long long int solltest du auf IA32 auf eine Set-Größe von maximal 64 kommen, wenn's mehr sein soll, braucht man mehr Programmlogik, aber machbar ist auch dies (und man schreibt sich seine lib ja nur einmal und bindet sie dann beliebig oft ein).
Unter C++ hast du neben eben genannter klassischen C-Lösung auch noch das Template std::set<>. Ich sehe da nicht, was daran umständlich ist. Ich persönlich finde für systemnahe Programmierung die C-Lösung "schöner" als die Pascal-Lösung, aber umständlich finde ich weder C, noch Pascal, noch C++.

[PAX]

ähm, da seh ich gerade überhaupt nicht durch
du musst wissen, dass ich privat nun n paar jahre mit delphi gearbeitet hatte und auch dort ne ganze menge mir noch nicht angeeignet hatte - vieles lerne ich jetzt erst bei c++ (mit klassen und so hatte ich noch nie gearbeitet). vor delphi hab ich selbstverständlich pascal gelernt und davor wiederum quick basic. das, kann man sagen, war mein bisheriger werdegang - und so lange leb ich ja auch noch nich.

ja, nun wollte ich mich mal so langsam mit c++-builder befassen. die IDE von visual c## war mir zu ungewohnt, deshalb bleib ich erstmal bei borland.

ich hatte mein programmierproblem jetzt auch anders realisieren müssen. dabei versuchte ich in einer switch-case-anweisung in einem case mehrere ausdrücke in einem case zu schreiben, was nicht funktionierte, sowohl durch komma getrennt, als auch mit logisch ODER.

Delphi-Quellcode:

.
.
.
case 2,8,14,20: ...

bzw.

Delphi-Quellcode:

.
.
.
case 2||8||14||20: ...

naja, so wäre es übersichtlicher gewesen, aber geht leider nicht. deshalb mach ich es im moment so:

if(z==2||z==8||z==14||z==20) ... haste da ne günstiger idee?

mich würde desweiteren auch noch etwas persönliches von dir interessieren:
wie hast du dir dieses ganze wissen angeeignet? in welchen jahren (und wo) hast du am meisten gelernt?

viva los tioz!
lg


PAX

[Flocke]

Zitat von PAX:

deshalb mach ich es im moment so:

if(z==2||z==8||z==14||z==20) ... haste da ne günstiger idee?

So:

Delphi-Quellcode:

.
.
.
case 2:
case 8:
case 14:
case 20:
  ...
  break;

C/C++ fällt durch ein case-Statement durch, sofern du es nicht explizit mit break beendest.

[Frickeldrecktuxer_TM]

Zitat von PAX:

ähm, da seh ich gerade überhaupt nicht durch
...

Das ist eigentlich nichts fortgeschrittenes und hat auch nichts mit Klassen oder ähnlichem zu tun. Im Prinzip ist es einfache Mathematik.
Zahlen werden im Computer als Reihe von Bits (0 oder 1) gespeichert. Deswegen kann man prima einen long int als Bitfeld missbrauchen, weil er 32 (64) Bits enthält, über die man natürlich frei verfügen kann.
Wenn ich jetzt

Code:

const SS_SECOND = 1 << 1;

definiere, habe ich eine 1, die ich einmal nicht links verschiebe. Binär wäre eine Eins 00000001, eine Eins, die einmal nach links verschoben ist wäre 00000010.
Für die Operationen nimmt man dann einfach die Operatoren aus der Logik, die bei C & (AND), | (OR), ^ (XOR) und ~ (NOT) lauten. In C habe ich zusätzlich die Möglichkeit, gleich eine Zuweisung durchzuführen, indem ich ein "=" hinter den Operator setze, aber das schaust du dir am besten in einem C-Grundlagenbuch an.
In C prüft eine if()-Abfrage nicht, ob etwas TRUE ist, sondern ob etwas !FALSE (nicht FALSE) ist, wobei FALSE den Wert 0 hat. if(42) wird also genauso ausgeführt, wie if(1), if(-1) oder if(TRUE). Das kann man sich dann bei Bitfeldern zunutze machen.
Nehmen wir das Bitfeld 00001001. Nach obigem Schema mit den Konstanten wäre SS_FIRST und SS_FOURTH im "Set". Jetzt ANDe ich SS_FOURTH mit diesem Set. 00001000 AND 00001001 ergibt 00001000, dezimal 8. if(8) wird ausgeführt. Ein solches AND kann ich also benutzen, um zu überprüfen, ob ein Element in meinem "Set" ist, denn umgekehrt wäre 00001001 AND 00000100 "nur" 00000000, dezimal 0, und if(0) ist genauso wie if(FALSE).
Umgekehrt kann ich das OR dazu benutzen, neue Werte in mein "Set" aufzunehmen, unabhängig davon, ob sie bereits im "Set" enthalten sind, oder nicht.
Für solche logischen Operationen gibt es Tabellen, wenn dir das für den Anfang etwas verwirrend erscheint, im Grunde ist es aber alles ganz einfach.


Zu deinem anderen Problem hat dir Flocke schon geholfen. Ein beliebter Anfängerfehler (gerade von Quereinsteigern aus anderen Sprache) ist es, das break bei switch()-Blöcken zu vergessen und sich dann über unerwartetes Verhalten zu wundern. Du musst also auch hinter jedem case-Zweig, den du für abgeschlossen hältst, ein break einfügen, damit nicht alle weiteren case-Zweige abgearbeitet werden.

Zitat von PAX:

mich würde desweiteren auch noch etwas persönliches von dir interessieren:
wie hast du dir dieses ganze wissen angeeignet? in welchen jahren (und wo) hast du am meisten gelernt?

In meinen besten
Das ganze Wissen habe ich mir mehr oder weniger "nebenbei" (neben der Schule) angeeignet, und zwar autodidaktisch. Angefangen habe ich wie viele mit BASIC unter DOS, später unter Windows mit Delphi und nun bin ich bei C++ angelangt, weil mir C++ einfacher und flexibler erscheint als Delphi (okay, und weil es unter Linux kein Delphi-Äquivalent gibt ). Neue Sprachen erschließe ich mir, indem ich die Sprachreferenzen lese. Dabei erschließt sich auch meistens der Sinn von Dingen, die in anderen Sprachen nicht möglich sind. Templates, Multiple Inheritance oder Namespaces sind etwas, was es in Delphi nicht gibt, für die sich (zumindest für mich) der Sinn aber mehr oder weniger von selber erschließt, wenn man sich die Definitionen dafür anschaut. Der Rest ist learning by doing und Lesen von Code-Beispielen, Bibliotheksdokumentationen und Rumprobieren mit bestimmten Aufrufen oder Bibliotheken.
Ich denke, am meisten habe ich in den zwei Jahren gelernt, in denen ich mit Delphi gearbeitet habe, nämlich modernes (objektorientiertes) Programmieren und wie moderne Betriebssysteme implementiert sind. Dann habe ich mich immer mehr für C++ interessiert, weil ich die Syntax sehr viel einfacher finde und mit dem Komplettumstieg auf Linux kam dann auch der Komplettumstieg auf C++. Ich hätte genauso gut von Anfang an C++ machen können und hätte dann wahrscheinlich das gleiche gelernt, ich denke es hängt also damit zusammen, daß ich mich in dieser Zeit am meisten dafür interessiert habe.

[PAX]

ach so läuft das

naja, das ding is, dass ich halt mehrere "sets" hätte und bei jedem set etwas anderes ausgeführt wird. die switch-struktur wäre nachher einfach zu lang. und bitverknüpfungen halte ich hier für überzogen. wenn ich allerdings n paar if-anweisungen verwende und schön eng schreibe , dann reduziert sich die problematik auf wenige zeilen.

und nun zum parallelgespräch:

hast eine ähnliche vorgehensweise wie ich, nur dass ich mich mit linux einfach nicht anfreunden kann. darf ich fragen, wie alt du bist?

viva los tioz!

[Frickeldrecktuxer_TM]

Zitat von PAX:

und bitverknüpfungen halte ich hier für überzogen

Was meinst du, wie Sets intern implementiert sind, wenn sie richtig implementiert sind?
Wenn du z==20 verwendest, wie in deinem obigen Code, warum nimmst du dann nicht z == (16 | 4) und setzt fr 16 und 4 die Konstanten ein, die du definiert hast (oder die ich definiert habe, ich weiß ja nicht, ob du es genauso gemacht hast )? Das erhöht die Lesbarkeit deutlich: "Ähh, watt war nochma' 20?!?" und ist performancetechnisch kein Unterschied, denn der Compiler wird die beiden Konstanten beim kompilieren zusammenfassen, weil deren Werte bereits zur Compile-Time bestimmbar sind.
Wie gesagt, wenn dir die Operatoren zu umständlich sind, schreib dir Funktionen dafür, oder eine eigene Set-Klasse.

Zitat von PAX:

nur dass ich mich mit linux einfach nicht anfreunden kann.

Irgendwann war ich Windows einfach leid und unixoide Systeme erlauben mir mehr Freiheiten und Möglichkeiten. Der Umstieg erschien irgendwie logisch, und als Nicht-Spieler hat mich auch nichts irgendwie an Windows gebunden.

Zitat von PAX:

darf ich fragen, wie alt du bist?

19.