Übung 2 : Programmieren in Eclipse

Input

3 Methoden, um Variablen zuzuweisen :

1. im Programm
2. mit Programmargumenten
3. mit cin

Temperaturumwandlung

atof - Funktion

#include<iostream>#include<stdlib.h>...float a = atof( argv[1] )

Fehler

Integer-Division !!

t_f = 9 / 5 * t_c + 32; // FALSCH !!t_f = (9 / 5) * t_c + 32; // FALSCH !!

t_f = (9 * t_c) / 5 + 32; // RICHTIG !
t_f = (9.0f / 5) * t_c + 32; // RICHTIG !t_f = (9f / 5) * t_c + 32; // FALSCH !

t_f = float(9) / 5 * t_c + 32; // RICHTIG !

Eclipse Fehlermeldungen

using namespace std;

Theorie

Datentypen

int (integer)

• Speicherung ganzer Zahlen (mit Vorzeichen)
• Speicher ist endlich gross --> endlich grosse Zahlen
• 2, 467467, -7263, 0

 char x = 'y';

• Zeichen werden in eine Zahl umgewandelt
• ASCII-Tabelle
• +   ►   43
• A..Z   ►   65..90
• a..z ►  97..122

float / double

• Speichern von Kommazahlen

float a = 3.14;float x = 0.1E-4;

9.0f / 5 //9 wird als float abgespeichert

bool (boolean)

bool test1 = 10; // test 1 = truebool test2 = 0; // test 2 = false

Hauptspeicher

• Daten im Speicher als Bitfolge abgelegt
• 1 Bit : 2 mögliche Zustände (0/1)
• 1 Byte : Kombination von 8 Bits 
• 2^8 (256) mögliche Zustände 
• 1 Word : Kombination von Bytes
• 32-bit : 1 Word = 4 Bytes
• 64-bit : 1 Word = 8 Bytes

32 bit

• 1 Word = 4 Bytes = 32 bit
• 2^32 verschiedene Bytes 
• ~= 4.000.000.000 Bytes = 4GB
• = Grösse des zugreifbaren Arbeitsspeichers

64 bit

• 1 Word = 8 Bytes = 64 bit
• 2^64 verschiedene Bytes 
• ~= 16 Exabyte = 16.000.000.000 GB
• = Grösse des (theoretisch) zugreifbaren Arbeitsspeichers

Binary

Datentypen

• sinnvolle Interpretation des Speicherinhalts
  
• Basistypen (int, double, float, bool,...)
• abgeleitete Typen (arrays, structs) (später)

Wiederholung : Variablen

int a; // Definitiona = 5; // Zuweisung
int b = 3; // Definition und Zuweisung
int c,d,e; // in Seriec = d = e = 7;

nicht erlaubte Namen

int a!; int ä;
int 1a;
int for;int main;
int __a:int _B;

Modifiers / Specifiers

<modifier> <type> <name>;

long int a; // integer Variable a mit 2 x 2 Byte = 4 Byte Speicherplatz
short int b; // integer Variable b mit 1 Byte Speicherplatz
unsigned int c; // c ohne Vorzeichen
const int d = 5; // d hat im ganzen Programm den Wert 5

Zuweisungen / Typenumwandlung

int / float / double --> char

int a = 127;char b = a; // b ist das ASCII Zeichen von 127

! Achtung : ergibt falsche Werte für Werte über 255 !

int / float / double --> bool

int a = 0;bool b = a; // b = FALSE (0)
int a = 2;bool b = a; // b = TRUE (1)

bool --> int / float / double

bool a = true;int b = a; // a = 1
bool a = false;int b = a; // a = 0

Achtung!!

long int a = 100000000000000;int b = a; // falsche Werte!!
long int a = 10000000000000;short int b = a; // falsche Werte

Bits werden abgeschnitten, ergibt falsche Werte für grosse Zahlen

float a = 3.14;
long int b = a; // a wird abgerundet

OK!

type cast

(<type>) Wert/Variable; // C und C++<type> (Wert/Variable); // nur in C++ 
float f = float(3/2 + 4.0f); // f=5.0float f = float(3)/2 + 4.0f; // f=5.5 

Funktionen

Vordefinierte Funktionen

float a = sqrt(81); // "function call", a = 9

float b = atof("32"); // b = 32

Eigene Funktionen

Deklaration

<type> <name> ( <type> ) // Prototyp

Definition

<type> <name>(arguments)

{
	statements;         return <Wert/Variable>; // (optional)}    

Beispiel : Temperaturumwandlung

Vorgehen :

1. Rückgabetyp ?
2. Name ?
3. Argumente / Parameter ?
4. Anweisungen ?

1. float
   
2. t_umwandlung
3. 1 float Argument : t_c

float t_umwandlung(float); // Deklaration, Prototyp
int main(){...}
float t_umwandlung(float t_c) //Definition{...}

Funktionsaufruf in main()

 <name> (argument1, argument2,...)
float c; cin >> c;
float f;f = t_umwandlung(c); // function call

Scope (Gültigkeitsbereich)

Aufgabe 2 : UNIX On-line Hilfe

Aufgabe 3 : Typenumwandlung

• Zeile für Zeile vorgehen
• Variablentabelle erstellen
• Tipp : Zufallswerte für nicht initialisierte Variablen