Rechnen in C++?

Und zwar soll ich für int n=4 folgendes lösen: n>>n/2<<n. Als Lösung erhält man 16. Ich verstehe aber nicht wieso bzw. was die << bzw >> bedeuten soll. Ich hab online was mit bit gelesen aber verstehe es trotzdem nicht. Könnte mir jemand das einfach erklären?

5 Antworten

mihisu

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Mathematik

30.06.2023, 20:07

>> und << sind Verschiebungsoperatoren, die eine bitweise Verschiebung bewirken. Aber da diese eine recht niedrige Priorität in der Operatorrangfolge haben, wird zunächst einmal die Division n/2 durchgeführt.

Für n = 4 erhält man n/2 = 4/2 = 2.

Nun wird als nächstes (da weiter links stehend) die Rechtsverschiebung >> durchgeführt. Bei n >> 2 wird das durch n gegebene Bitmuster um 2 stellen nach rechts verschoben. Die binäre Darstellung der Ganzzahl n = 4 ist... [Hier mit 2 Byte bzw. 16 bit dargestellt, obwohl int in C++ je nach Compiler und System heute üblicherweise eher 4 Byte lang sind.]

00000000 00000100

Bei der Verschiebung um 2 Stellen nach rechts wander die 1 um 2 Stellen nach rechts und ist nun an der Einer-Position.

00000000 00000001

Die entsprechende Ganzzahl ist 1. Dementsprechend ist also n >> 2 hier 1. Nun wird durch die Linksverschiebung um 4 Stellen nach links (wegen << n mit n = 4) die 1 im Bitmuster um 4 Stellen nach links verschoben. [Der Rest bleibt einfach alles 0 und ist uninteressant.]

00000000 00010000

Die 1 befindet sich nun an der 2⁴-Position. Man erhält die Zahl 1 ⋅ 2⁴, also 16, als Ergebnis.

Ergebnis: 16

Weitere Informationen zu den Verschiebungsoperatoren << und >> findest du beispielsweise hier: https://learn.microsoft.com/de-de/cpp/cpp/left-shift-and-right-shift-operators-input-and-output?view=msvc-170

Hamsty28393

Beitragsersteller

30.06.2023, 20:09

Wie kommt man auf die Binärdarstellung?

mihisu

30.06.2023, 20:32

@Hamsty28393

Hmm. Schwierig wenn du das frägst, weil ich nicht ganz weiß auf welchem Niveau ich dich da abholen muss. Ich versuch mal auf einem recht niedrigen Niveau anzufangen.

============

Du kennst doch das Dezimalsystem, das im Alltag heutzutage von den meisten Personen benutzt wird, oder?

Da hat die Zahl 476 beispielsweise folgende Darstellung...

476₁₀ = 4 ⋅ 10² + 7 ⋅ 10¹ + 6 ⋅ 10⁰ = 4 ⋅ 100 + 7 ⋅ 10 + 6 ⋅ 1 = 476

[Die Zahl hat 4 Hunderter und 7 Zehner und 6 Einer.]

Soweit so gut, oder? Sowas ist quasi Grundschulstoff.

============

Nun ist es aber so, dass es in der Elektrotechnik einfacher ist 2 verschiedene Zustände (Strom fließt bzw. Spannung liegt an einerseits, kein Strom fließt bzw. keine Spannung andererseits) zu unterscheiden, als dass man 10 verschiedene Zustände als Grundlage nimmt. Dementsprechend arbeiten Computer im Grunde mit einem Binärsystem (mit 0 und 1) statt mit einem Dezimalsystem (mit 0, 1, 2, 3, 4, 5, 6, 7, 8, 9).

Analog zum Dezimalsystem kann man nun Zahlen darstellen. Die Binärzahl 100110 würde beispielsweise der Zahl 38 entsprechen. Denn...

100110₂ = 1 ⋅ 2⁵ + 0 ⋅ 2⁴ + 0 ⋅ 2³ + 1 ⋅ 2² + 1 ⋅ 2¹ + 0 ⋅ 2⁰
= 1 ⋅ 32 + 0 ⋅ 16 + 0 ⋅ 8 + 1 ⋅ 4 + 1 ⋅ 2 + 0 ⋅ 1
= 32 + 4 + 2 = 38

[Die Zahl hat 1 32er und 0 16er und 0 8er und 1 4er und 1 2er und 0 1er.]

------------

Nun kann man sich umgekehrt fragen. Welche Binärdarstellung hat beispielsweise die Dezimalzahl 4? Naja, da 4 eine 2er-Potenz ist, nämlich 4 = 2² ist das ganze recht einfach. Die Zahl hat eine 1 an der 4er-Stelle (2²er-Stelle) und sonst nur 0er.

4 = 2² = 1 ⋅ 2² + 0 ⋅ 2¹ + 0 ⋅ 2⁰ = 100₂

Bzw. kann man die Binärzahl 100₂ nun noch mit führenden 0ern ergänzen, die nichts am eigentlichen Wert ändern, aber die Zahl so darstellen, dass sie eine gewisse Anzahl an Stellen aufweist (beispielsweise 16 Stellen bei einer 16-bit-Darstellung)...

4 = 100₂ = 0000000000000100₂

============

Ich hoffe das war einigermaßen verständlich. Ansonsten frag nochmal nach. Aber eigentlich ist das auch Stoff, der in der Unterstufe im Mathematikunterricht behandeln worden sein sollte.

Eine allgemeinere Umrechnungsmethode vom Dezimalsystem ins Binärsystem ist beispielsweise auch hier dargestellt:

https://de.wikipedia.org/wiki/Dualsystem#Vom_Dezimalsystem_ins_Dualsystem

[Wiederholte Division durch 2 mit Rest und dann betrachten der Reste.]

flyaquarius

30.06.2023, 19:54

>> und << verschieben Bits einer Binärzahl. Die Zahl deren Bits verschoben wird kommt vor das Zeichen. Die Anzahl der Stellen, um die verschoben wird, kommt nach das Zeichen. Im dem Code werden zwei Operationen aneinandergereiht.

n = 4 und n/2 = 2. Setzt man das ein, steht da also

4 >> 2 << 4

4 als Binärzahl ist 100. Verschoben um zwei Stellen nach rechts kommt 1 raus. Zwischenergebnis:

1 << 4

1 ist dezimal und binär das gleiche. Verschoben um 4 Stellen nach links kommt 10000 raus. Das ist als Dezimalzahl 16.

tunik123

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

Mathematik

30.06.2023, 19:39

<< und >> sind Bitverschiebeoperatoren. Da sie eine absurd niedrige Priorität haben, wird zuerst n/2 = 2 ausgerechnet.

Dann folgt (von links nach rechts)

n >> n/2 = 4 >> 2 = 1

und 1 << n = 1 << 4 = 16.

Hamsty28393

Beitragsersteller

30.06.2023, 19:43

Kannst du mir erklären warum gilt 4>>2=1 und 1<<n=1

tunik123

30.06.2023, 19:47

@Hamsty28393

4 ist im Dualsystem 100, das um 2 Bit nach rechts verschoben ist 1.

1 << n = 16

Die 1 um n (also 4) Bit linksverschoben ist 10000, das ist 16.

KarlRanseierIII

Von gutefrage auf Grund seines Wissens auf einem Fachgebiet ausgezeichneter Nutzer

programmieren, Programmiersprache, Programmieren & Softwareentwicklung

30.06.2023, 21:43

<< und >> ist das Shiften, also Verschieben von Bits, wobei ein Shift um 1 Stelle einer Multiplikation mit 2 resp. einer Division durch 2 entspricht - insofern ist es komisch, daß man das n/2 nicht auch als Shift umgesetzt hat.

Wichtig ist noch zu wissen, daß Shifts gleiche Präzedenz haben unf von links nach rechts ausgewertet werden, während die Division eine höhere Präzedenz hat, also zuerst ausgeführt wird.

n=4
n>>n/2<<n (erst Division)
n>>2<<n
4>>2<<4 ( (4/2)/2=1 )
1<<4  (entspricht 1*2^4)
16

Bushmills145

30.06.2023, 20:19

Einmal rechts schieben hat den gleichen Effekt wie Teilen durch 2, einmal links schieben den gleichen wie Multiplikation mit 2.

die 4 schiebst du erst 4/2 mal nach rechts, also 2 mal, was zwei mal Teilen durch 2 entspricht: 4 / 2 / 2, resultierend in 1.

Danach schiebst du die erhaltene 1 vier mal nach links, entsprechend 1 * 2 * 2 * 2 * 2, ergebend 16.

Ähnliche Beiträge

Computer rechnen komisch?

Ich habe ein Problem beim Programmieren.
Derzeit programmiere ich einen Arduino und will eine Rechnung durchführen. Aber es gibt ein Problem, da nicht die richtige Lösung herraus kommt.

Hier mein code: (Wenn ich ihn so schreibe, dann geht alles perfekt)

unsigned long Volumen=Entfernung;

Volumen=Volumen*1000;

Volumen=Volumen/794;

Volumen=1000-Volumen;

return Volumen;

Einheit der Entfernung: int (ich glaube da ist das Problem, weiß es aber nicht)

Ich dachte mir ich kann das Ganze kürzen und so schreiben:

unsigned long Volumen = 1000 - (Entfernung * 1000) / 794;

return Volumen;

Aber NEIN. es kommt ein fehler herraus und für das Volumen bekomme ich dann das falsche Ergebnis herraus.

Kann mir jemand erklären wieso das so ist?

Danke Lg. Richi

...zum Beitrag

Java BlueJ Projekt für Schule(Tic Tac Toe) zeigt Fehler an?

Liebe Gute Fragen Community,

ich soll für die Schule ein Tic Tac Toe Spiel programmieren, jedoch zeigt mir das Programm dauernd den Fehler an:“Die nicht statische Methode Kreis_setzen (int) kann nicht aus einem statischen Kontext referenziert werden“(ins deutsch übersetzt).Ich versteh jedoch nicht wo hier das Problem liegt. Kann mir da jemand helfen und es mir erklären und wenn möglich sogar eine Lösung für den Fehler nennen?

viele Grüße und Danke im Voraus,

xela

...zum Beitrag

Programmieren informatik?

Hallo, ich habe die Aufgabe ein implementaionsdiagramm herzustellen. Die Klasse ist Konto und die unter Klassen davon sind Girokonto und Sparkonto. Das Sparkonto besitzt eine Begrenzung an Geld (einen Höchstbetrag) den ich abheben kann. Das Girokonto kann ich nach einem beliebigen Betrag überziehen. Wie kann ich diese Methoden nun ausdrücken?

meine Idee:

Girokonto

—

geld abheben(pAnzahl: int): void

geld einzahlen(pAnazahl: int): void

Sparkonto

—

geld abheben(pBegrenzteanzahl: int) void

geld einzahlen(pAnzahl: int): void

ich bin mir nicht ganz sicher ob ich nun „pBegrenzteanzahl“ schreiben kann da ich es zuvor noch nie so gemacht habe jedoch keine bessere Lösung nun finden konnte.
Eine Verbesserung, Meinung, Vorschläge alles ist willkommen! Ich möchte es verstehen und anwenden :)

...zum Beitrag

C++ Code für LGS?

Ich möchte mit einen C++-Programm alle LGS lösen können (endlich, unendlich und keine Lösungen). Ich habe auch einen Code. Endlich viele und keine Lösungen kann er recht gut (bisher), aber unendlich viele Lösungen kann er nicht anzeigen lassen (soll dann auch t einführen, nicht einfach einen Wert einsetzen).

Wo liegt der Fehler?

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

// Funktion zur Berechnung des Determinanten einer Matrix
double determinant(vector<vector<double>>& matrix, int n) {
  double det = 0;

  if (n == 1) {
    return matrix[0][0];
  }

  if (n == 2) {
    return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
  }

  for (int i = 0; i < n; i++) {
    vector<vector<double>> subMatrix(n - 1, vector<double>(n - 1));

    for (int j = 1; j < n; j++) {
      for (int k = 0; k < n; k++) {
        if (k < i) {
          subMatrix[j - 1][k] = matrix[j][k];
        }
        else if (k > i) {
          subMatrix[j - 1][k - 1] = matrix[j][k];
        }
      }
    }

    det += pow(-1, i) * matrix[0][i] * determinant(subMatrix, n - 1);
  }

  return det;
}
 
// Funktion zur Durchführung der Gauss-Jordan-Elimination
void gaussJordan(vector<vector<double>>& matrix, vector<double>& constants) {
  int n = matrix.size();

  for (int i = 0; i < n; i++) {
    int maxIndex = i;

    for (int j = i + 1; j < n; j++) {
      if (abs(matrix[j][i]) > abs(matrix[maxIndex][i])) {
        maxIndex = j;
      }
    }

    if (maxIndex != i) {
      swap(matrix[maxIndex], matrix[i]);
      swap(constants[i], constants[maxIndex]); // Korrektur hier
    }

    double factor = matrix[i][i];

    for (int j = i; j < n; j++) {
      matrix[i][j] /= factor;
    }

    constants[i] /= factor;

    for (int j = 0; j < n; j++) {
      if (j != i) {
        double factor = matrix[j][i];

        for (int k = i; k < n; k++) {
          matrix[j][k] -= factor * matrix[i][k];
        }

        constants[j] -= factor * constants[i];
      }
    }
  }
}

// Funktion zur Überprüfung der Invertierbarkeit und zur Lösung des LGS
vector<double> solveLinearSystem(vector<vector<double>>& matrix, vector<double>& constants) {
  int n = matrix.size();
  double det = determinant(matrix, n);

  // Überprüfung auf unendlich viele Lösungen
  bool allZero = true;

  for (double constant : constants) {
    if (constant != 0) {
      allZero = false;
      break;
    }
  }

  if (det == 0) {
    if (allZero) {
      cout << "Das LGS hat unendlich viele Lösungen." << endl;
      return {}; // Leerer Vektor, da unendlich viele Lösungen existieren
    }
    else {
      cout << "Das LGS hat keine Lösung." << endl;
      return {}; // Leerer Vektor, da keine Lösung existiert
    }
  }

  // Anwendung der Gauss-Jordan-Elimination
  gaussJordan(matrix, constants);

  vector<double> solution(n);

  for (int i = 0; i < n; i++) {
    solution[i] = constants[i];
  }

  return solution;
}

int main() {
  vector<vector<double>> matrix = {
    { 1, -3,  5 },
    { 2, -5,  12 },
    { 3, -11,  11 }
  };
  vector<double> constants = { 2, 1, 12 };

  vector<double> solution = solveLinearSystem(matrix, constants);

  if (!solution.empty()) {
    cout << "Die Lösung des LGS ist: ";

    for (int i = 0; i < solution.size(); i++) {
      cout << "x" << i + 1 << " = " << solution[i] << ", ";
    }

    cout << endl;
  }
  else {
    cout << "Das LGS hat keine Lösung." << endl;
  }

  return 0;
}

...zum Beitrag

Arduino code Widerstand messung?

Könnte mir einer diesen code erklären also halt den teil wo dran steht :

for(int i=0;i<6;i++){

(Ich verstehe nicht so viel von ardoino aber ich würde gantz gerne diese rechnung verstehen)

float Quellspannung=5.0;

int AnalogPin=6;

int R1=1500.0; //Hier Kommt hin wie gross der wiederstand ist

long Messwert;

float SpannungR2;

float Widerstand;

Messwert=0;

for(int i=0;i<6;i++){ //U=R*I wiederstand berechnen (Spannung =U) (Stromstärke =I) (Wiederstand =R)

Messwert+=analogRead(AnalogPin);

...zum Beitrag

Sudoku automatisch lösen - Algorithmus Logik-Problem?

Ich bin momentan dabei für die Schule einen Algorithmus für einen automatischen "Sudoku Löser" zu schreiben und will folgende Regeln aus dem Internet für mich nutzen:

http://members.chello.at/ksteiner/klaus/sudokuloeser.htm

Ich verstehe allerdings nicht was Regel A bedeuten soll? Es wäre mir extrem geholfen wenn jemand, der die Logik versteht mir erklären würde was das bedeuten soll

Vielen Dank schonmal!!

...zum Beitrag

C++ Paritätsbit Aufgaben hilfe?

Hi,

ich brächte mal hilfe und zwar habe ich seit 5 wochen in der schule Programmieren. Dazu hat mir mein Lehrer die Aufgabe erstellt eine Dezimal Zahl als erstes in Binär zu übersetzen und dann die Parrität zu vergleichen. Mein Lehrer erklärt leider nicht viel deswegen verstehe ich die erste For Schleife nicht ganz. Wenn mir die Jemand erklären kann wäre das gut. Dazu funktioniert das so noch nicht da wenn ich 445 als zahl eingebe die zahl als 32 bit wie folgt ausgegeben wird:

0000 0000 0000 0000 0000 0001 1011 1101 = Zahl in 32bit binär

Even Even Even Even = Parität

Aber es müsste raus kommen in der Parität spalte

Even Even Odd Even

Dies wäre soweit mein Lösungsansatz.

#include <iostream>
#include <cstdlib>
                                                                                                                                                                                                                   
int i;
int a;
int bits[sizeof(int)*8];
unsigned int unum;
int num;
                                                                                                                                                                                                                   
int main (int nargs, char **args) {
        num=atoi(args[1]);                                                                                                                                                                                         
        unum = (unsigned int)num;
                                                                                                                                                                                                                   
        for(int i=0; i<sizeof(int)*8; i++) {
                bits[i]=unum % 2;                                                                                                                                                                                  
                unum /=2;                                                                                                                                                                                          
        }                                                                                                                                                                                                          
        if(bits[1,2,3,4] == bits[5,6,7,8]) {
                std::cout << "Even\n";
                                                                                                                                                                                                                   
        } else {
                std::cout << "Odd\n";
        }                                                                                                                                                                                                          
        if(bits[9,10,11,12] == bits[13,14,15,16]) {
                std::cout << "Even\n";
        } else {
                std::cout << "Odd\n";
        }                                                                                                                                                                                                          
        if(bits[17,18,19,20] == bits [21,22,23,24]) {
                std::cout << "Even\n";
        } else {
                std::cout << "Odd\n";
        }                                                                                                                                                                                                          
        if(bits[25,26,27,28] == bits[29,30,31,32]) {
                std::cout << "Even\n";
        } else {
                std::cout << "Odd\n";
        }                                                                                                                                                                                                          
        return 0;
}

...zum Beitrag

Wie kann ich eine bestimmte Ziffer aus einer Zahl auslesen in Java?

Frage 1:

Ich habe die Integer-Variable value = 2017

Außerdem deklariere ich:

int Jahrzehntzahl;

int Jahrzahl;

Nun möchte ich ich aus der Variable "value" (2017)

die ersten beiden Stellen (also 20) in die Variable "Jahrzehntzahl" (Int)

und

die letzten beiden (also 17) in die Variable "Jahrzahl" (Int) speichern.

Ergebnis wäre dann:

Jahrzehntzahl=20

Jahrzahl=17

Meine Lösungsansätze:

Mit Bit-Position arbeiten
Durch Division (Dieser Ansatz wäre aber deutlich länger)

Ich bevorzuge eine einfache Lösung. Wenn möglich Einzeiler.

Frage 2:

Außerdem wüsste ich gerne, wie das ganze funktioniert, wenn man mit Kommazahlen (double) arbeitet. Hier reicht mir eine Erklärung für das auslesen einer Ziffer vor und einer hinter dem Komma.

Ich freue mich auf jede Antwort

Liebe Grüße

...zum Beitrag

Binomialverteilung Aufgabe: Kann jemand helfen?

Hallo Leute,

kann mir jemand bitte bei erklären, wie die 11f) zu lösen ist?

In den Lösungen steht das Ergebnis 1/16, aber ich verstehe nicht, wie ich darauf komme.

Danke im Voraus

...zum Beitrag

Hexadezimale Zahl als Bit umrechnen?

Hi Leute, ich habe die Aufgabenstellung bekommen und weiß einfach nicht weiter. Wie rechne ich das um?

Die Hexadezimale Zahl 0xA1 hat dezimal den Wert als

a) 8-Bit unsigned:

b) 8-Bit signed (2-er Komplement):

c) 16-Bit signed (2-er Komplement):

d) 32-Bit signed (2-er Komplement):

...zum Beitrag

Java Referenzdatentypen?

Mir ist ein bestimmter Aspekt, und zwar der Sinn einer Referenz noch nciht ganz klar geworden:

Primitiver Datentyp:

int zahl = 8;

Hier wird ja mit der Deklarierung der Variable zahl eine Adresse für einen gerade freien Speicherplatz erzeugt und in diesem Speicherort der Wert der Variable, 8, abgelegt.
So wie in meiner Zeichnung:

Referenzdatentyp:

Mensch mensch1 = new Mensch(16); //16 = pAlter

Hier wird auch mit der Variable einem gerade freien Speicherplatz eine Adresse zugeordnet. Dann wird in dem freien Speicherplatz, glaube ich, nichts (kein Variablen Wert (new Mensch(16) ) ) abgelegt, sondern nur eine komplett andere Adresse. Folgt man dieser Adresse und guckt in dem durch sie verwiesenen Speicherplatz nach, findet man da unseren Variablen - Wert = new Mensch(16).
Wie in meiner Zeichnung hier:

Was ich jetzt nicht so richtig verstehe ist, warum wird unser Variablenwert (unser neues menschen - objekt) unter einer anderen Adresse abgelegt, als der, der der Variable "mensch1"eigentlich zugeordnet wurde? Sprich: Wozu eine Referenz auf eine andere Adresse (ich glaube immer Referenz auf eine andere Adresse, vielleicht ist es aber auch in WIrklichkeit eine Referenz auf das neue Menschen Objekt?)? Warum nicht so wie beim primitiven Datentypen machen, also so wie bei meiner Zeichnung hier unten?:

omg, diese logik - aber es macht mir Spaß, zu programmieren und ich möchte alles unbedingt verstehen !😊

...zum Beitrag

was ist die größte bzw. kleinste zahl im 4, 8, 16 Bit-Zahlen System?

Wir haben grade das Binärsystem angefangen aber wir haben keinerlei Erklärung wegen dieser Coronazeit bekommen und ich verstehe das einfach nicht.

Die Aufgabe lautet: Gib an, welches die größte und welches die kleinste 4-, 8- bzw. 16-Bit-Zahl im Zweierkomplement ist. Schreibe dazu auch immer ihre binäre Darstellung.

...zum Beitrag

Wie rechnet man Mbit/s * ms?

1Mbits/s * 80ms

= 80.000 Bit

= 10.000 Byte

= 10 kB

Ich verstehe den ersten Rechenschritt nicht genau. Wie komme ich bei der Multiplikation von Mbits/s und ms auf bit bzw. welche Schritte muss ich dabei machen?

Ich weiß:

1 MBit sind 1.000.000 Bit, mal 80 sind

80.000.000 Bit

Jetzt fallen in der Lösung aber 3 nullen weg. Liegt sicher daran, dass ja noch ms und pro Sekunde irgendwie verrechnet werden müssen. Aber ich verstehe nicht wie?!

...zum Beitrag

C# Array Wert geben?

Hey, ich wollte bisschen mit Arrays in C# rumprobieren und hab das Programm da unten geschrieben aber wenn ichs starte geht es für den ersten Moment bis ich dem Array einen Wert gebe und dann steht es gäbe ein "Out Of Range Error", wüsst jemand wie man das lösen könnte? Danke!

Code:

Console.Write("Rechenoperatoion [+,-,*,/]: ");

char rechop = Convert.ToChar(Console.ReadLine());

Console.Write("Anzahl: ");

int y = Convert.ToInt32(Console.ReadLine());

int[] array = new int[y];

Console.Write("Wert: ");

array[y] = Convert.ToInt32(Console.ReadLine());

int lösung = 0;

if (rechop == '+')

{

for (int i = 1; i <= y; i++)

{

lösung += array[y];

}

Console.Write(lösung)

}

...zum Beitrag

Was möchtest Du wissen?

Deinen Beitrag erstellen