- Flags: einen unsigned char z.B. kann man als Sammlung von 8 Bits (Plattformabhängig, aber meistens sinds sehen, die man als Flags (Ein/Aus-Schalter) benutzt. Der Zugriff auf die einzelnen Bits ist mit Bitoperatoren leicht machbar.

- Datenmengen kleiner als 1 Byte: Wenn du Daten die z.B. jeweils 3 Bit beanspruchen irgendwo eng gepackt unterbringen willst, kannst du sie z.B. in unsigne char-Arrays unterbringen und mit bitshifts direkt aneinanderpacken, statt immer 5 Bits freizulassen. Herb Sutter hat das Ganze mal anhand von Schach-Notationen demonstriert.
http://www.gotw.ca/gotw/072.htm

Ebenso bei Funktionen mit vielen möglichen Parametern, z.B. bei der Windows-Programmierung:

HWND hwnd = CreateWindow (..., WS_SYSMENU | WS_THICKFRAME, ...);

wc.style = CS_HREDRAW | CS_VREDRAW;

if ((cs.style & FWS_ADDTOTITLE) && afxData.bWin4) cs.style |= FWS_PREFIXTITLE;

hmm hört sich so an als würde es in der normalen programmierung kaum benötigt werden und es verdient nicht gelernt zu werden

Es reicht, wenn Du weißt, wie es funktioniert. Man kann es exakt nachschlagen, wenn man es braucht.

"&"   AND
"|"   nicht-exclusives OR
"^"   exclusives OR
"~"   NOT (bitweises Komplement)
"<<"  Linksverschiebung
">>"  Rechtsverschiebung

Zum Beispiel kann man die Bitshiftoperatoren zur Ein- und Ausgabe auf der Konsole verwenden

Diese Mehrfachverwendungen von Zeichen wie >> oder & nehme ich C++ richtig übel.

LoL *sich das mal bildlich vorstellt, wie ein Erhard eine Sprache anknurrt*
Aber mal ehrlich, wieso ist das ein Problem? Es ist ja nicht wirklich eine Mehrfachverwendung, sondern eine Operator Überladung. Was willst du mit einem Bitshift Operator bei einer Klasse? Da kannst du ja nichts damit anstellen, also besser für anderes verwenden und es siehst sogar noch schick aus

Grüssli

Diese Mehrfachverwendungen von Zeichen wie >> oder & nehme ich C++ richtig übel.

Die überladenen Bitshiftoperatoren finde ich okay, aber die Operatoren & (Adresse, Referenz, Bit-Und) und * (Zeigerdeklaration, -dereferenzierung, Multiplikation) ist v.a. am Anfang sehr schwierig zu unterscheiden. Aber wenn man sich daran gewöhnt hat, ist es kein Problem mehr.

Und sonst, was würdest du machen? Einfach neue Operatoren einführen? Ich denke, C++ besitzt schon genug... (Obwohl natürlich ein >>> lustig aussehen würde ;))

Und sonst, was würdest du machen? Einfach neue Operatoren einführen? Ich denke, C++ besitzt schon genug... (Obwohl natürlich ein >>> lustig aussehen würde ;))

Alternativen gibt es schon:

// Nur als Beispiel!
#include <iostream>

class CMyOutputStream
{
  // Attributes //
private:
  std::ostream m_Output;

  // Constructors & Destructor //
public:
  CMyOutputStream(std::ostream& rOutput)
    : m_Output(rOutput.rdbuf())
  { }

  ~CMyOutputStream() { };

  // Methods //
public:
  template<typename T>
  CMyOutputStream& write(T const& rT) { m_Output << rT; return *this; }

  template<typename T>
  CMyOutputStream& write_new_line(T const& rT) { m_Output << rT << std::endl; return *this; };

  CMyOutputStream& write_new_line() { m_Output << std::endl; return *this; };
};

int main()
{
  CMyOutputStream Out(std::cout);

  Out.write(3).write(" hello").write_new_line();
  Out.write_new_line("huhu");

  return 0;
}

Grüssli

Aber ob das eine schöne (lesbare) Alternative ist, lassen wir mal aussen vor.

Würde ich auch meinen. Ausserdem besteht bei den Streams wohl kaum die Möglichkeit, die Operatoren für BitShifts zu halten. Abgesehen davon kommt man in C++ wahrscheinlich eher selten in die Lage, wo man mit Bitschiebereien hantieren muss, und falls doch, ist der Fall eigentlich immer klar.

Aber ob das eine schöne (lesbare) Alternative ist, lassen wir mal aussen vor.

Ich habe ja extra hingeschrieben "// Nur als Beispiel!". Alternativen gibt es genug, das wollte ich eigentlich damit aufzeigen. Mir persönlich gefällt ja die Sache auch mit dem Operator <<, bzw. >>. Wollte es nur aufzeigen, dass es auch anders geht

Grüssli

drakon schrieb:

Aber ob das eine schöne (lesbare) Alternative ist, lassen wir mal aussen vor.

Ich habe ja extra hingeschrieben "// Nur als Beispiel!". Alternativen gibt es genug, das wollte ich eigentlich damit aufzeigen. Mir persönlich gefällt ja die Sache auch mit dem Operator <<, bzw. >>. Wollte es nur aufzeigen, dass es auch anders geht

Grüssli

War nicht böse gemeint. - Ich finde enifach, dass es schreklich aussieht, aber nichts gegen das Beispiel. Es hat ja ziemlich getroffen.

Erhard Henkes schrieb:

Diese Mehrfachverwendungen von Zeichen wie >> oder & nehme ich C++ richtig übel.

Die überladenen Bitshiftoperatoren finde ich okay, aber die Operatoren & (Adresse, Referenz, Bit-Und) und * (Zeigerdeklaration, -dereferenzierung, Multiplikation) ist v.a. am Anfang sehr schwierig zu unterscheiden. Aber wenn man sich daran gewöhnt hat, ist es kein Problem mehr.

Und sonst, was würdest du machen? Einfach neue Operatoren einführen? Ich denke, C++ besitzt schon genug... (Obwohl natürlich ein >>> lustig aussehen würde ;))

Naja, was am Anfang verwirrend ist, ist vielleicht unpraktisch beim lernen, aber >> und << fuer ein/ausgabe ist technisch furchtbar.

denn stell dir einfach mal eine klasse fuer grosse zahlen vor. und nun definierst du alle bit operationen auf ihr. &, | und natuerlich <<.

jetzt hast du folgenden code

myInt c;
cout<<c<<3;
cout<<(c<<3);

sieht boese aus

Oder würdest du auch <<< und >>> unterstützen? Ich sollte eine Kampagne starten :p

Oder würdest du auch <<< und >>> unterstützen? Ich sollte eine Kampagne starten :p

entweder das oder etwas .NET aehnliches:

stream.print("Hallo, {0}!", string("nexus"));

dazu braeuchte man einen ausgabe operator. zB sowas wie toString oder derartiges.

ka, was am besten ist. op<< ist schon praktisch, aber halt die doppeldeutigkeit ist haesslich.

stream.print("Hallo, ").print(string("nexus).print("!");
waere das furchtbarste...