Kategorie: C und C++

C++: stream

– alle Daten werden zu chars
– In: bedeutet von aussen zur CPU.
– out: bedeutet von OS nach aussen
————————————————————————————-

istream
char Daten werden übergeben

ostream
sendet chars an eine Ort (file, konsole, speicher, ..)

ifstream  [Daten in File ablegen]
– Datei als String mitgeben
ifstream stream_a {„input.txt“}
– Inhalt wortweise in String ablegen string temp
– Strings in Vektor speichern   vector <string> input

while (stream_a >> temp) {      
        // fill vector
        input.push_back(temp);
    }


ofstream [ lesen von einem file (wird als stream gemacht)]

cout << "Name of output file"
string name_outputfile;
cin >> name_outputfile;

ostream stream_1 {name_outputfile};
if (! stream_1) error("Konnte nicht eingelesen werden.");

 

strukturiert einlesen

struct Inputdata {
    int hour;
    double temperature; 
};
cout << "Please enter input file name: ";
    string name_inputfile;
    cin >> name_inputfile;
    ifstream ist {name_inputfile};
    if (!ist) throw ios_base::failure("can't open input file "+name_inputfile);
vector<Inputdata> temps; // structured vector
    int hour;
    double temperature;

    // read structured in
    while (ist >> hour >> temperature) {
        if (hour < 0 || 23 <hour) throw range_error("hour out of range");
        // fill vector
        temps.push_back(Inputdata{hour,temperature});
    }

 

strucktruriert ausgeben

// set brackets for clearer structure
    for (int i=0; i<input.size(); ++i)
        ost << '(' << input[i].hour << ','
            << input[i].temperature << ")\n";

 

 

…

 

 

Pointer C++: Wert auslesen

struct ImageInt16 {
.        short data[100]
};


Objekt bilden
2 Bilder werden abgelegt. Inhaltstruktur ist identisch. Der Typ der Speichervariable nicht.

ImageInt16     bild_1;          // enthält Wert
ImageInt16*    bild_2;          // enthält Speicherort, an dem Wert liegt


Variable auslesen

int result_1, result_2;

result_1 = bild_1.data[0];    
result_2 = bild_2->data[1];       // Objektreferenz
  //oder
result_2 = (*bild_2).data[1];    // Dereferenziert
.                                // Wert des Objekts

Der ersten zwei Wert aus dem Array wurden übergeben.
..

 

 

 

 

 

Enumarates

In C++ gehören die „enums“ zu den Klassen. Sie sind ein Sonderfall einer Klasse, da sie keine Funktionen, sondern nur Konstanten haben.

– enums beginnen bei 0, ausser:
– wird der ersten Konstante einen Wert zugewiesen, beginnt der
.  enum bei dieser Zahl und zählt immer +1.

enum class Month{
.     jan
.     feb,
.     ...
.     dez
};
enum class gruppe_1{
.     urs,
.     noe,
.     ...
.     eva
};

Zuweisungen

gruppe_1  karl = 5;                  // neuer Wert dazu
gruppe_1 nils = gruppe_1.eva         // nils an Stelle von eva

 

Operationen mit Enumerates

Month new_month = sept;
++new_month;                       //new_month is now okt
++new_month;                       //new_month is now nov

Bjarne 9.6

…

Objekt bearbeiten

Klasse

class MidiData {
.     public: 
.            // varibale
.            int pin;
.            double version;
.            int wait;        // in ms
.
.            // functions
.            MidiData(int pin, double version, int wait);   
.            string readStream( steam io);
.            string extractdata( string s);
}

Objekt definieren

MidiData system_2{ 8, 14.04, 5 }

system_2 ist ein Objekt der Klasse MidireadData. Im Objekt ist definiert, wo und mit welcher Version Midi gelesen wird.

Objeket bearbeiten

system_2.pin = 10;    // change data pin
system_2.wait = 10;   // change wait time

Zur Verarbeitung der Klasse wurden extra Memberfunktionen definiert.

string in_pin8 = system_2.readStream( input_8);
string data_pin8 = system_2.extractdata( in_pin8);

Über die Objektvariable system_2 können die Memberfunktionen aufgerufen werden.

 

Defintion Member functions

class MidiData {
.     public: 
.            // varibale
.            int pin;
.            double version;
.            int wait;        // in ms
.
.            // functions
.            MidiData(int pin, double version, int wait);   
.            string readStream( steam io);
.            string extractdata( string s);
}

Im public-Teil einer Funktion, wird die member-Funktion nur deklariert. Die Definition folgt ausserhalb.
Das gilt auch, wenn pro Klasse eine Datei erstellt wird.

Definition Member Function

<class>::<member-function>( <type> <argument> ) {
.      // Code
}
void Date::add_day( int n){
.      // Code
}
void Date:: month(){
.     // Code
}

..

Constructor C++

Eine Member-Funktion mit demselben Name wie die Klasse selbst, ist ein Constructor.

1. Konstruktor ohne Funktionen———————————————–

class MidiData {
. public: 
.     int pin;
.     double version;
.     int wait;        // in ms
.     MidiData(int pin, double version, int wait);  //Construct
.
}

Ein Objekt der Klasse kann nicht ohne Wertzuweisung definiert werden, eine Initialisierung ist zwingend notwendig beim Bilden eines Objektes. Die Initialiserung kann über eine List ober über den Constructor erfolgen:

MidireadData system_1 = { 13,  14.04, 10}  // list

MidireadData system_2 { 8, 14.04, 5 }  // constructor usually
MidireadData system_2( 8, 14.04, 5 )   // constructor old style

MidireadData system_3 = MidireadData{ 10, 14.04, 10 } //special

In der Initialisierung müssen alle Member-Variablen definiert werden.
Vgl. Bjarne Kapitel 9.4.2

2. Konstruktor für Klasse mit Funktionen ——————————-–

class Date{
.      public:
.         // constructor
.         Date( int year, int month, int day);  
.         // member-functions
.         void add_day( int n);
.         int month();       // check error of number        
.
.      private:
.         int year, month, day;

};

Konstruktor mit Funktion:

Date::Date(int y_1,int m_1,int d_1)      
     : month( month1) {}

…

Class: public and private

Was eine Klasse ist
– Eine Klasse ist ein selbst definierter Datentyp
– Man erfindet eine Klasse nur, weil man sie für etwas braucht.
– Um das umzusetzen, braucht man Variablen und Funkitonen
– Damit man nicht alles von Hand schreiben muss, importiert
.  man oft Funktionen von Bibliotheken (oder anderen Klassen)

Struktur

class <Name> {
.     public: 
.            <type> <var>;
.            <type> <member_function>(<arguments);
.
.     private:
.            <type> <utility_functions>(<argument>);    
} ;

public:
–  Alles, warum die Classe definiert wurde. Der Public-Teil dient
.  dem direkten bearbeiten (nutzen) der Klasse.
–  Den Public-Teil nennt man auch das Interface.
–  Die Funktionen im public heissen member functions. Nur diese
.  Funktinen sind von aussen zugänglich (sichtbar)

private:
–  Hilfsfunktionen und Hilfsvaraiabeln.

Bilden eines Objektes
Eine Klasse kreierte man, weil man sie braucht. Damit man sie brauchen kann, müssen der Klasse Werte zugewiesen werden, dies geschieht im Constructor. In Python wird der Konstruktor durch die Funktion init in der Klasse definiert.

class <Name>(<argument>):

.    def __init__(self):  
.        // set variables
        
.   def <function_a> (self):
.       // Code

In C++ wird der Konstruktor nach der Klasse gebildet.

…

C++: Vektor per (const) reference

Es gibt zwei Prinzipien, wie man Vektoren (grosse Wertetabellen) übergeben kann:
1. Man will die Werte „nur“ verarbeiten. Die Tabelle bleibt gleich.
2. Man will Werte in der Tabelle ändern.

Werte nicht ändern
Wird ein Vektor per const Referenz übergeben const vector <type>& <name> , so verändert man aufgrund des Schlüsselwortes const die Einträge nicht (Bjarne 8.5.4). Anstatt per Referenz kann man die Werte auch traditionell per Pointer (per Adresse) übergeben, ebenfalls mit const.

Werte verändern (Bjarne 8.5.5)
Ist das Ziel, die Einträge zu ändern, so tut man dies z. B. so:

void init(vector <int> v){
.  //
}

————————————————————————————————————————-

Adresse erhalten

int i = 5;

// Variable für Adresse
int* adresse;

adresse = &i;      // die Adresse von i wird übergeben

Aus einer Adress-Variable einen Wert auselesen

int value_1;
value_1 = * adresse;

 

..