Ausgangspunkt für das Verstehen einer objektorientierten Programmiersprache ist immer das objektorientierte Basiskonzept (Paradigma). Das Basiskonzept stellt sozusagen das SOLL und die konkrete Sprache das IST dar. Gehen Sie davon aus, dass eigentlich in keiner derzeit verfügbaren objektorientierten Sprache auch alle in der Theorie formulierten Konzepte bereits komplett umgesetzt sind. Man sollte sich auf jeden Fall davor hüten von den Möglichkeiten und den Einschränkungen einer konkreten Sprache auf das Konzept zu schließen. Wesentliche Aspekte objektorientierter Sprachen sollen im Folgenden anhand der Sprache C++ aufgezeigt werden. Für das Verständnis von C++ ist weiterhin wichtig zu wissen, das C++ die Sprache C beinhaltet. C++ ist die objektorientierte Erweiterung der Sprache C.

// Schlüsselworte ..........................................
break		double		int		struct
case		else		long		switch
char		extern		return		unsigned
const		float		short		signed	
continue	for		void		sizeof
default		if		sizeof		volatile
do		while		main
// Operatoren ..............................................
+		-		*		/
=		++		--		
<<		>>		!		&
|		^		~		%
==		>		<		<=
>=		&&		||		!=

C folgt dem Basiskonzept der Strukturierung was nichts weiter bedeutet, als dass auf die Sprunganweisung (vgl. Assembler, GOTO, JUMP, usw.) verzichtet wird um einen Algorithmus zu erstellen. Es werden nur drei algorithmische Grundstrukturen benötigt um jede Programmlogik zu realisieren. Das sind:

• die Sequenz, Anweisungen werden nacheinander ausgeführt
• die Iteration (Wiederholung, Schleife), Anweisungen werden wiederholt ausgeführt
• die Alternative, bestimmte Anweisungen werden entsprechend einer Bedingung anstatt anderer Anweisungen ausgeführt

In den strukturierten Sprachen gibt es zwar noch weitere Spielarten dieser drei Grundstrukturen aber dem Wesen nach gibt es tatsächlich nur diese drei. Im Folgenden soll dargestellt werden wie diese Algorithmusbausteine in C und dann natürlich auch in C++ notiert werden. Beachten Sie die geschweiften Klammern! Diese begrenzen einen Anweisungsblock und sollten immer besonders am Anfang diszipliniert gesetzt werden.

// Blöcke in C und C++
{	// BEGIN
	// Blockinhalt
}	// END

Das Weglassen von Klammern in bestimmten Fällen sind eben genau das, Sonderfälle und diese sollte man sich als Einsteiger erst mal sparen. Übrigens gibt es die Blockbildung in allen strukturierten Sprachen. Manchmal sind das statt Klammern Schlüsselworte wie BEGIN oder END. Das gleiche gilt für das Semikolon. Ein Semikolon ist in C das Endekennzeichen einer Anweisung und für den Compiler extrem wichtig. Notieren Sie eine Anweisung immer in einer eigenen Zeile und schließen diese immer mit einem Semikolon ab. Das Einrücken der Anweisungen mit einem TAB innerhalb eines Blocks gewährleistet den Überblick zu bewahren.

int A,B,C;
 
// eine Sequenz ..............................................
{
	A = 1;		// führe zuerst A
	B = 2;		// dann B
	C = A+B;	// danach C aus A und B berechnen
}
 
// eine Wiederholung .........................................
while ( A < 100 )	// wiederhole ( solange )
{			
	A = A + 1;	// diese Anweisungen
}			
 
// eine Alternative ..........................................
if ( A == 0)		// wenn ( das wahr ist )
{
	C = B;		// dann führe diese Anweisungen aus
}
else			// sonst
{
	C = A;		// führe diese Anweisungen aus
}
 
// -----------------------------------------------------------
// ausgewählte Spielarten
// -----------------------------------------------------------
 
// Zählschleife ..............................................
for ( uint8_t i = 0; i<100; i++)
{
	// was auch immer genau 100 mal getan werden muss
}
// fußgesteuerte Schleife ....................................
do {
	// etwas was mindestens einmal oder öfter nötig ist
} while ( notReady );
 
// bedingte Anweisung .......................................
if ( ok )
{
	// etwas alternativloses
}
// Fallunterscheidung .............
switch (fall)
{
	case 1:  { 
			// Fall 1
		 } break;
	case 2:  { 
			// Fall 2
		 } break;
	default: { 
			// Standardfall
		 } break;
}

bool 		catch  		false 		enum
class 		new 		delete 		public 		template 
virtual 	operator 	private 	protected 	this
namespace 	using 		true		throw 		try

Wie wir sehen, ist der eigentliche Sprachumfang von C übersichtlich und die Erweiterung um zur Sprache C++ zu kommen vergleichsweise gering. Was dem Lernenden als umfangreich erscheint, sind die hinzukommenden Bibliotheken, welche vorgefertigte Funktionen anbieten. Des Weiteren ist ersichtlich, dass eine objektorientierte Programmiersprache ihre strukturierten Vorgänger nicht ablöst, sondern auf deren Konzepten und Schlüsselworten aufbaut und diese auch übernimmt. Die Botschaft lautet also, dass alles was man mit AVR C machen kann funktioniert nach wie vor auch in myAVR C++ . Eine objektorientierte Programmiersprache muss also zusätzlich nur die Ausdrucksmittel zur Realisierung der objektorientierten Basiskonzepte anbieten. Zu einem objektorientierten Programm kommt man nicht einfach durch Verwendung eines bestimmten Compilers, sondern einzig durch die Art und Weise, wie man das Programm aufbaut. Im Folgenden vorab wichtige C++ Konstrukte, welche ausgewählte besondere Merkmale einer objektorientierten Sprache aufzeigen. Im Verlauf des Tutorials werden wesentliche Aspekte des Gezeigten Schritt für Schritt besprochen.

Es ist ein Anwendungsprogramm mit dem Namen Applikation (englisch: Application) zu entwickeln. Die Anwendung soll zunächst geplant und dann programmiert werden und letztlich benötigen wir eine Instanz von dem Programm.

// Klasse Name { Bauplan } Instanz;
class Application
{
 
} app; 

Die Applikation ist eine Mikrocontrolleranwendung. Diese soll alle Möglichkeiten der vorhandenen Klasse Controller besitzen. Somit erbt die Applikation am besten alle Merkmale vom Controller.

// Klasse Name : Sichtbarkeit Basisklasse { Bauplanerweiterung } Instanz;
class Application : public Controller
{
 
} app; 

Der Controller wird eingeschaltet und arbeitet dann fortlaufend taktgesteuert. Oh ja, wir erinnern uns dunkel. Subjekt und Prädikat. WER (der Controller) macht WAS (wird eingeschaltet, arbeitet)… Dafür sollte es jetzt Operationen in der Klasse geben.

// Klasse Name : Sichtbarkeit Basisklasse { Bauplanerweiterung } Instanz;
class Application : public Controller
{
   // Sichtbarkeit : RückgabeTyp name (Parameter) { Code; }
   public: void onStart()
   {
      // alles was beim Hochfahren getan werden muss
      // dann gehe zur Mainloop
   }
   // Sichtbarkeit : RückgabeTyp name (Parameter) { Code; }
   public: void onWork()
   {
      // alles was fortlaufend getan werden muss
      // die Mainloop liegt in der Controllerklasse
      // von dort aus wird onWork fortlaufend aufgerufen (getriggert)
      // hier also KEINE Unendlichschleife !!!
   }
} app; 

Es soll eine LED angeschlossen werden. An diese LED wollen wir niemand anderes heranlassen. Wir schützen diese vor unberechtigtem Zugriff.

// Klasse Name : Sichtbarkeit Basisklasse { Bauplanerweiterung } Instanz;
class Application : public Controller
{
   // Sichtbarkeit : Typ name;
   protected: LED led;
 
   public: void onStart()
   {
      // ...
   }
   public: void onWork()
   {
      // ...
   }
} app; 

Die LED ist eine fertige Klasse aus dem Framework. Wir müssen der LED mitteilen, an welchem Port-Pin sie angeschlossen ist und wir wollen sie einschalten.

// Klasse Name : Sichtbarkeit Basisklasse { Bauplanerweiterung } Instanz;
class Application : public Controller
{
   // Sichtbarkeit : Typ name;
   protected: LED led;
 
   public: onStart()
   { 
      // instanzName . nachricht ( Parameter );
      led.config(portB,bit0);
   }
   public: onWork()
   {
      // instanzName . nachricht ( );
      led.on();
   }
} app; 

Bei diesem kurzen Ausflug in die objektorientierte Art und Weise Programme zu schreiben ist wohl deutlich geworden, dass es sehr darauf ankommt, sich ein bestimmtes Muster anzugewöhnen, Systeme zu betrachten und darüber nachzudenken. Objektorientierung beginnt im Kopf! Übrigens ist es hilfreich, das zu programmierende System in kurzen einfachen Sätzen zu beschreiben oder diese laut vor sich hin zu sagen.

myAVR C++