~005~ Namensgebung + Operatoren

per2per · 03.05.2013, 02:01

Namensgebung

Die Namensgebung von Variablen sollte wohl überlegt sein. So wäre es gut, wenn der Name eine gewisse Aussagekraft hat, damit man selbst und andere den Programm-Code leichter verstehen können. Der C-Standard schreibt einem dazu noch folgende Regeln zur Benennung vor:

Der Name darf nur aus Buchstaben, Ziffern und dem Unterstrich _ bestehen.
Das erste Zeichen muss ein Buchstabe oder der Unterstrich _ sein.
Groß- und Kleinschreibung ist relevant, d.h. "zahl" und "Zahl" ist nicht dasselbe.
Der Name darf kein Schlüsselwort sein.

Schlüsselwörter

asm
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
whil

Wollen wir aussagekräftige Namen verwenden, so sind wir meist gezwungen, mehrere Wörter in den Namen zu packen. Da wir kein Leerzeichen verwenden dürfen, stehen uns folgende Möglichkeiten zur Trennung der Wörter zur Verfügung. Diese Variable soll z.B. den aktuellen Preis für Kartoffeln darstellen:


			
float preisKartoffeln = 0.89;

float PreisKartoffeln = 0.89;

float Preis_Kartoffeln = 0.89;

float preis_kartoffeln = 0.89;

Heutzutage beginnt man die Namen für Variablen überlicherweise mit einem Kleinbuchstaben und realisiert die Trennung mittels Groß- und Kleinschreibung (siehe erste Variante). Die letzte Variante findet man meistens in alten Programmen oder bei der Hardwareprogrammierung.

Zuweisung

Den einfachsten Operator = haben wir bereits aus den bisherigen Beispielen kennengelernt, er setzt eine Variable auf einen bestimmten Wert. Auf der linken Seite von = muss also eine Variable stehen, auf der rechten Seite ein Ausdruck, z.B. ein konstanter Wert, eine Formel, oder eine Variable.


			
 int a, b;

// Zuweisung eines konstanten Wertes, a ist 1
a = 1;

// Zuweisung eines Variablenwertes, b ist 1
b = a;
Inkrement & Dekrement

Wollen wir den Wert einer Variablen um eins erhöhen oder erniedrigen, empfiehlt es sich die Inkrement- und Dekrement-Operatoren zu nutzen. Im folgendem Beispiel erledigen wir das Inkrementieren und Dekrementieren mit und ohne Inkrement- und Dekrement-Operatoren, um den praktischen Vorteil zu erkennen.


			
 int a=0, b=0;

// a mit Inkrement-Operator hochzählen
a++;

// b ohne Inkrement-Operator hochzählen
b = b + 1;

// a dekrementieren, a ist wieder 0
a--;

// b ohne Inkrement-Operator dekrementieren
b = b - 1;
Bei der Zuweisung gibt es mit ++ und -- noch eine Besonderheit:

 int a,  b=0;

// Erst Zuweisung, dann Inkrement, a ist 0, b ist 1
a = b++;

// Erst Inkrement, dann Zuweisung, a ist 2, b ist 2
a = ++b;

Rechenoperatoren

Für das Rechnen stehen uns die folgenden bekannten Operatoren zur Verfügung:

Addition: +
Subtraktion: -
Multiplikation: *
Division: /
Modulo (Rest): %
Wenden wir die Multiplikation und Division auf int Variablen an, welche bekanntlich nur ganze Zahlen speichern können, wird automatisch gerundet. Der Nachkommateil wird hierbei einfach weggeschnitten, d.h. aus 2.1, 2.5 und 2.9 wird einfach 2.


			
 int a=0, b=2, c=5;

a = b + c;  // a ist 7
a = b - c;  // a ist -3
a = c / b;  // a ist 2
a = c * b;  // a ist 10

// Rest aus Division berechnen
a = c % b;  // 5 / 2 ist 2 Rest 1, a ist 1
a = c % 3;  // 5 / 3 ist 1 Rest 2, a ist 2

// Prioritäten mit Klammern setzen
a = 1 + b * c;    // Punkt vor Strich, a ist 11
a = (1 + b) * c;  // 1+2 ist 3, 3*5 ist 15, a ist 15

Möchte man den bisherigen Wert der Zielvariable mit verwenden, so kann man auch eine Kurzschreibweise für alle Rechenoperatoren verwenden. Hierfür wird der Operator vor die Zuweisung gesetzt.


			
 int a=1, b=2;

a += 1;      // wie a=a+1 oder a++, a ist 2
a += b * 4;  // a ist 10
a /= 2;      // a ist 5
a %= 2;      // a ist 1

//Um eine Rechtschreibe und Grammatik Vergewaltigung zu vermeiden Formuliere ich weniger, ich nehme mir die Aussage zu herzen für den Anfang mich strickt an ein Leitbild zu halten und hoffe das der Text in der Formatierung und Gestaltung angenehmer zu Lesen ist. Laufe der Zeit bemühe ich mich noch mehr zu Schreiben damit ein Leitbild nicht mehr benötigt wird.

Zitat von dr.pepper

Als kleiner Zusatz zum Thema Zuweisung:

Unveränderliche Variablen

Wir haben auch die Möglichkeit festzulegen, ob der Wert einer Variablen nach der Deklaration und Initialisierung verändert werden darf oder nicht. Mithilfe des Schlüsselswortes const machen wir also Variabeln invariabel.

 // unveränderliche Variablen
const int raeder = 4;
const float preisKartoffeln = 0.89;

// Hier bringt der Compiler einen Fehler oder eine Warnung
raeder = 5;

mfg

Domenic · 03.05.2013, 20:26

Wirklich gut geschrieben, eine Anmerkung habe ich jedoch noch.

Heutzutage beginnt man die Namen für Variablen überlicherweise mit einem Kleinbuchstaben und realisiert die Trennung mittels Groß- und Kleinschreibung (siehe erste Variante). Die letzte Variante findet man meistens in alten Programmen oder bei der Hardwareprogrammierung.

Das stimmt so nicht ganz, in C++ ist es standard das alles klein geschrieben wird und mehrere Wörter im Bezeichner durch einen Unterstich getrennt werden. In C++ wird so ziemlich alles klein geschrieben, bis auf wenige Ausnahmen. Das ist aber keine Pflicht, ich persönlich bevorzuge auch die übliche Java Schreibweise. In Java hat sich nämlich lowerCamelCase für Variablennamen und UpperCamelCase für Klassennamen durchgesetzt. Ich kenne genug Leute die Java hassen und wirklich so programmieren, wie es im C++ Standard auch aussieht.

Liebe Grüße,
Domenic

Wuffy · 04.05.2013, 07:53

Ist das verwenden von Präfixen wie es in der Ungarischen Notation gemacht wird nicht mehr "in"?

The Blubb · 04.05.2013, 11:34

obwohl ich C++ programmiere verwende ich auch meistens die Java notation: variabeln lowerCamelCase und klassen UpperCamelCase.
man gewöhnt sich mit der zeit auch einige eigenheiten an, z.B. verwende ich bei gui elementen in allen programmiersprachen prefixes wie txtIrgendEinName für ein Textfeld.

Mit der ungarischen notation habe ich mie genauer befasst, aber wenn ich das richtig verstanden habe verwendet man für jeden datentyp ein prefix, wie würde man das dann bei so einem Datentyp machen:
std::vector<std::map<std::vector<int>,std::map<int ,char*>>>?
wäre der prefix dann: vmpvimpisz?

CodeCracker · 04.05.2013, 12:05

Was hat Camel mit Coding zu tun?
Also ich rauch die Dinger nur ^^

/*IRONIE OFF*/

TgZero · 04.05.2013, 15:01

Zitat von The Blubb

Mit der ungarischen notation habe ich mie genauer befasst, aber wenn ich das richtig verstanden habe verwendet man für jeden datentyp ein prefix, wie würde man das dann bei so einem Datentyp machen:
std::vector<std::map<std::vector<int>,std::map<int ,char*>>>?
wäre der prefix dann: vmpvimpisz?

Das ist nur bedingt richtig, ursprünglich besagt die ungarische Notation, dass die Variable nach ihrem "Typ" benannt wird. Dabei entspricht der Typ nicht dem Datentyp, also eine int-Variable würde das Präfix "i" implementieren, sondern eher der Verwendung der Varibale (Zähler, Index, Iterator usw.)
Ziel dieser Notation war es, eine Variable einen Namen zuzuweisen, der schon auf die Verwendung dieser Variable innerhalb des Programms deutet.

Leider benutzt die WinAPI die "falsche" Notation, so wird aus jedem DWORD Variable ein DWORD dwVariable.
Somit hat man die Ungarische Notation nochmal aufgespalten in Apps Hungarian (Ursprüngliche Notation) und Systems Hungarian (WinAPI).

Am besten du guckst dir mal die Wikipedia-Seite dazu an.
Ich persönlich finde die "falsche" Notation besser, bzw. lesbarer, da man dort hinter dem Präfix, also dem Kürzel des Datentypen, ein frei wählbares Wort benutzen kann. Bei der Apps Hungarian wäre dies schon ein Verstoß gegen die Notationskonvention.

mfg
TgZero

Wuffy · 05.05.2013, 07:10

Beim inkrementieren von Zahlen könnte ich noch hinzufügen dass man die plus- und minuszeichen auch vor die Variable setzen kann und welchen Unterschied das macht. Ich weiß allerdings gerade nicht ob das auch in C++ geht?

Hier mal zwei Beispiele.

Im ersten Code wird zuerst 1 dazu gezählt, dann wird der wert zurück geliefert. Im zweiten Beispiel ist es umgekehrt. Es wird zuerst der wert zurück geliefert und dann wird 1 dazu gezählt. Unter Umständen kann sich da ein Bug einschleichen wenn man es falsch anwendet, da dann z.b. die erste zahl übersprungen wird und man den fehler schwer findet wenn man diese Regel nicht kennt.

#include <stdio.h>
#include <stdlib.h>
int get_zahl()
{
    static int i = 0;
    if (i == 11) exit(0);
    return ++i;
}
int main() {
    while(1)
    {
        printf("%i\n", get_zahl());
    }
    return 0;
}

Dieses erste Beispiel wird auch die Zahl 11 noch ausgeben obwohl das Programm beendet werden soll wenn die Zahl 11 ist.

Hier die Ausgabe:

1
2
3
4
5
6
7
8
9
10
11

Die Ausgabe von 0 fehlt hier. Dafür wird die 11 noch ausgegeben. Es wird erst 1 zu i dazu gezählt dann wird der wert mit return zurück gegeben.

#include <stdio.h>
#include <stdlib.h>
int get_zahl()
{
    static int i = 0;
    if (i == 11) exit(0);
    return i++;
}
int main() {
    while(1)
    {
        printf("%i\n", get_zahl());
    }
    return 0;
}

Ausgabe:

0
1
2
3
4
5
6
7
8
9
10

Hier wird der Wert zuerst zurück geliefert und danach wird 1 dazu gezählt. Deshalb springt das IF-Statement dann richtig an.

Es kann manchmal nützlich sein wenn man einen Counter mit anderem Verhalten haben will.

Ich hoffe es ist erwünscht wenn man hier einfach was dazu schreibt.

dr.pepper · 15.10.2013, 13:32

Als kleiner Zusatz zum Thema Zuweisung:

Unveränderliche Variablen

Wir haben auch die Möglichkeit festzulegen, ob der Wert einer Variablen nach der Deklaration und Initialisierung verändert werden darf oder nicht. Mithilfe des Schlüsselswortes const machen wir also Variabeln invariabel.

 // unveränderliche Variablen
const int raeder = 4;
const float preisKartoffeln = 0.89;

// Hier bringt der Compiler einen Fehler oder eine Warnung
raeder = 5;

per2per · 19.10.2013, 14:38

Zitat von dr.pepper

Als kleiner Zusatz zum Thema Zuweisung:

Unveränderliche Variablen

Wir haben auch die Möglichkeit festzulegen, ob der Wert einer Variablen nach der Deklaration und Initialisierung verändert werden darf oder nicht. Mithilfe des Schlüsselswortes const machen wir also Variabeln invariabel.

 // unveränderliche Variablen
const int raeder = 4;
const float preisKartoffeln = 0.89;

// Hier bringt der Compiler einen Fehler oder eine Warnung
raeder = 5;

Ich habe es mal hinzugefügt, immer schön weiter schreiben (: