// Lösungen zu "Richard Kaiser: C++ mit dem Borland C++Builder 2007", ISBN: 978-3-540-69575-2
// Copyright Richard Kaiser, 2007. http://www.rkaiser.de. All rights reserved.
// Diese Quelltexte dürfen in eigenen Programmen verwendet werden, wenn sie einen Hinweis auf die Quelle (die ersten beiden Zeilen) enthalten. In keinem Fall wird eine Haftung für direkte, indirekte, zufällige oder Folgeschäden übernommen, die sich aus der Nutzung ergeben.
// It is permitted to use this source text in programs of your own, provided that it contains a reference to the source (the first two lines above). All liabilities for use of the code are disclaimed.

//---------------------------------------------------------------------------
#include <vcl\vcl.h>
#pragma hdrstop

#include "IntU.h"
//---------------------------------------------------------------------------
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}

// --------------- Aufgabe 3.3.2, 1. -----------------------

void __fastcall TForm1::Button_3_3_2_1Click(TObject *Sender)
{
// 1. a)

  // 37 im Binärsystem:
  // 37dez = 1*2^5 + 0*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 0010 0101bin

//    b)

  // -37 im Zweierkomplement: Einerkomplement(37) +1
  // 1101 1010 + 1 = 1101 1011bin = -37dez

//    c)
  // 37dez = 2*16^1 + 5*16^0 = 25hex,
  // Alternativ - Die Blöcke aus der Binärdarstellung sind die hex-Ziffern:
  //            0010bin = 2hex, 0101bin = 5hex

  //            37dez  = 0010 0101bin = 25 hex
  //            -37dez = 1101 1011bin = db hex

Memo1->Lines->Add("Aufgabe 1:");
int i1=37;
Memo1->Lines->Add(IntToStr(i1)+ "dez: "+IntToHex(i1,2)+ "hex");
int j1=-37;
Memo1->Lines->Add(IntToStr(j1)+ "dez: "+IntToHex(j1,2)+ "hex");

//    d) 37 + (-25)

//       37: 00100101bin
//      -25: 11100111bin
//           -----------
//          100001100bin, mit 8 bits: 00001100bin = 12dez


//    e) 25 + (-37)

//       25: 00011001bin
//      -37: 11011011bin
//           -----------
//           11110100bin --> Zweierkomplement: 00001100bin
}


// --------------- Aufgabe 3.3.2, 2. -----------------------

void __fastcall TForm1::Button_3_3_2_2Click(TObject *Sender)
{
// 2. a)

  // Zweierkomplement von ab=1010 1011: 0101 0101 bin = 55 hex = 85 dez,
  // also -85

Memo1->Lines->Add("Aufgabe 2:");
signed char i2=0xab;
Memo1->Lines->Add(IntToStr(i2)+ "dez: "+IntToHex(i2,2)+ "hex");

//    b)

  // ab = 10*16 + 11 = 171

unsigned char j2=0xab;
Memo1->Lines->Add(IntToStr(j2)+ "dez: "+IntToHex(j2,2)+ "hex");
}

// --------------- Aufgabe 3.3.2, 3. -----------------------

void __fastcall TForm1::Button_3_3_2_3Click(TObject *Sender)
{
Memo1->Lines->Add("Aufgabe 3:");
Memo1->Lines->Add(IntToStr(030)); // Vorwahl Berlin // 24,
       // da wegen der führenden 0 ein Oktalliteral
Memo1->Lines->Add(IntToStr(017+15));  // 30
Memo1->Lines->Add(IntToStr(0x12+10)); // 28
}


// --------------- Aufgabe 3.3.4, 1. -----------------------

void __fastcall TForm1::Button_3_3_4_1Click(TObject *Sender)
{
unsigned char b = 255;
unsigned char c = 0;
//short i = 20000;
short i = 1234567898;
b = b + 1;      // 0
c = c - 1;      // 255
int d = i/100;
int e = i%100;
int f = i+i;

Memo1->Lines->Add(IntToStr(b));
Memo1->Lines->Add(IntToStr(c));
Memo1->Lines->Add(IntToStr(d));
Memo1->Lines->Add(IntToStr(e));
Memo1->Lines->Add(IntToStr(f));
}


// --------------- Aufgabe 3.3.4, 2. -----------------------

void __fastcall TForm1::Button_3_3_4_2Click(TObject *Sender)
{
AnsiString s=
"Falls die beiden Zahlen i und j verschieden sind, ist immer einer der "
"beiden Faktoren in (i/j)*(j/i) Null (Ganzzahldivision). Wenn i und j "
"dagegen gleich sind, ist das Produkt immer Eins.";
Memo1->Lines->Add(s);
}

// --------------- Aufgabe 3.3.4, 3. -----------------------

void __fastcall TForm1::Button_3_3_4_3Click(TObject *Sender)
{
// a)
// Wenn beide Operanden den Datentyp int haben, werden sie nicht
// im Rahmen einer ganzzahligen Typangleichung in den Datentyp int
// konvertiert.
// b)
// Wenn der Datentyp des Ausdrucks ein "kleinerer" Datentyp als int
// ist (z.B. char), wird er durch die Addition von 0 (Datentyp int)
// in int konvertiert.
}

// --------------- Aufgabe 3.3.4, 4. -----------------------

void __fastcall TForm1::Button_3_3_4_4Click(TObject *Sender)
{
// a)
// int a=x^x;

// a erhält immer den Wert 0, da die bitweise Verknüpfung von zwei
// Operanden mit xor immer den Wert 0 hat.

// b)
// int b=x&1;

// b ist genau dann 1, wenn x ungerade ist.
}

// --------------- Aufgabe 3.3.4, 5. -----------------------

// Im Bitmuster von x und y darf nicht an derselben Stelle eine 1 stehen.

// --------------- Aufgabe 3.3.4, 6. -----------------------

void __fastcall TForm1::Button_3_3_4_6Click(TObject *Sender)
{
/*
a)
Die beiden Operanden c und -1 haben dasselbe Bitmuster.
Wenn sie nicht in einen gemeinsamen Datentyp konvertiert würden,
wäre das Ergebnis des Vergleichs true.

b)
Wenn die beiden Operanden x-y==-1 und 0 nicht in einen gemeinsamen
Datentyp konvertiert würden, hätte die linke Seite das Bitmuster
FF, und das Ergebnis des Vergleichs wäre false.

c)
Die mathematisch gleichwertigen Ausdrücke in b) und c) hätten
verschiedene Ergebnisse.

In a) und b) wäre das Ergebnis hochgradig kontraintuitiv, und die von
b) und c) sollten gleich sein.
*/
}


// --------------- Aufgabe 3.3.6, 1. -----------------------

void __fastcall TForm1::Button_3_3_6_1Click(TObject *Sender)
{
// a)
char c;
bool Grossbuchstabe = (c>='A') && (c<='Z');

// b)
bool Buchstabe = ((c>='A') && (c<='Z')) || ((c>='a') && (c<='z'));

// c)
bool alphanumerisch = ((c>='A') && (c<='Z')) || ((c>='a') && (c<='z'))||
                      ((c>='0') && (c<='9'));
}

// --------------- Aufgabe 3.3.6, 2. -----------------------

void __fastcall TForm1::Button_3_3_6_2Click(TObject *Sender)
{
int Jahr;
bool Schaltjahr =((Jahr%4 == 0) && (Jahr%100 != 0)) || (Jahr%400 == 0);
}

// --------------- Aufgabe 3.3.6, 3. -----------------------

void __fastcall TForm1::Button_3_3_6_3Click(TObject *Sender)
{
int j1,j2,m1,m2,t1,t2;
bool vorher = (j1<j2) || ((j1==j2) && ((m1<m2) || ((m1==m2) && (t1< t2))));
}

// --------------- Aufgabe 3.3.6, 4. -----------------------

void __fastcall TForm1::Button_3_3_6_4Click(TObject *Sender)
{
/*
bool:
  x y     x&&y       x&y
  f f      f         0000&0000 == 0000 (f)
  f t      f         0000&0001 == 0000 (f)
  t f      f         0001&0000 == 0000 (f)
  t t      t         0001&0001 == 0001 (t)

int:

  x  y     x&&y            x&y
  0  0    f && f ==f     0&0 == 0 (f)
  0 !0    f && t ==f     0&0 == 0 (f)
  !0 0    t && f ==f     0&0 == 0 (f)
  !0 !0   t && t ==t

Für bool Operanden x und y ist das Ergebnis von x&&y immer identisch
mit dem von x&y.

Für int Operanden ist das Ergebnis in den ersten drei Zeilen gleich.
In der letzten Zeile erhält man bei !0&!0 nur dann den Wert true,
wenn sich die bits der Operanden nicht auslöschen. Z.B. erhält man
mit 1&2 den Wert false, während 1&&2 true ist.
*/
}

// --------------- Aufgabe 3.3.6, 5. -----------------------

void __fastcall TForm1::Button_3_3_6_5Click(TObject *Sender)
{
/*
In !0 wird der int-Ausdruck 0 in den booleschen Wert false konvertiert.
Deshalb stellt !0 den Wert true dar.
Als Operand des binären Operators == wird der boolesche Wert true in
einer ganzzahligen Typangleichung  in den Wert 1 konvertiert. Deshalb
entspricht die Bedingung

  if (x==!0) ... // gemeint war if (x!=0) ...

der Bedingung

  if (x==1) ...
*/
}

// --------------- Aufgabe 3.3.6, 6. -----------------------

void __fastcall TForm1::Button_3_3_6_6Click(TObject *Sender)
{
Option1a1->Enabled = !Option1a1->Enabled;
GroupBox4->Visible = !GroupBox4->Visible;
}

