Op deze pagina probeer ik een soort naslagwerk voor 'C' en 'C++' programmeurs te maken, in het Nederlands. Deze pagina is niet beschikbaar in de Engelse versie, omdat er voor de Engelse taal al hele goede internet sites zijn.

• 1. Een introductie in 'C++' voor 'C' programmeurs.
• 2. Boeken voor 'C' en 'C++' programmeurs.
• 3. Een OOP aanpak in standaard 'C'.
• 4. Een vergelijking tussen Visual C++ en C++ Builder.
• 5. De basis van object georiënteerd programmeren.
• 6. Een artikel dat in PT Embedded Juni 1999 geplaatst is.
• 7. Vragen en antwoorden.

Inhoud opgave deel 1

• Hele strikte type controle
• Verbeterd commentaar
• Andere cast methode
• Verplichte functie declaraties
• Functie overloading
• Default parameters
• Meer vrijheid in het declareren van variabelen
• Verbeterd FOR statement
• Eenvoudigere struct, enum en union notatie
• Echte constanten
• Nieuwe input en output methode
• Nieuwe geheugen beheer methode
• Call by reference
• Conclusie

Hele strikte type controle

Verbeterd commentaar

void testfunc(int i)    // Dit is een commentaar tot einde regel.
{                       /* Dit is oude commentaar stijl 
                           en kan over meerdere regels lopen. */
}

Andere cast methode

result = long(var1) * var2;

TestFunc(long(IntVar),Str); 

Verplichte functie declaraties

Functie overloading

void DrukafInt(int getal)
{
  // Code
}
void DrukafLong(long getal)
{
  // Code
}
void DrukafStr(char *str)
{
  // Code 
}

void TestFunc()
{
  DrukafInt(10);
  DrukafLong(423424L);
  DrukafStr("test");
}

void Drukaf(int getal)
{
  // Code
}
void Drukaf(long getal)
{
  // Code
}
void Drukaf(char *str)
{
  // Code
}

void TestFunc()
{
  Drukaf(10);
  Drukaf(423424L);
  Drukaf("test");
}

Default parameters

void TestFunc(char *Str, int i = 5)
{
  cout << Str << " " << i;   // Druk resultaat af!
}

TestFunc("Dit is met twee parameters",10);     // Dit drukt 10 af
TestFunc("Dit is met een parameter");          // Dit drukt 5 af

Meer vrijheid in het declareren van variabelen

int TestFunc()
{
int  var1;       // Deze variabele is globaal voor de hele functie

  // code
  if (var1> 100) { 
    int var2;       // De scope van deze variabele is dit if block
    // code
  }                 // Einde variabele var2 
  int var3;         // Hier begint variabele var3
  // code
}                   // Hier eindigen var1 en var3;

Verbeterd FOR statement

void TestFunc()
{
  for (int ind=0; ind < 10; ind++)
  {
    // code
  }
} 

Eenvoudigere struct, enum en union notatie

struct Stype {int a, int b };

Stype StructVar;

enum Boolean { FALSE, TRUE };

Boolean Gereed = FALSE;

Echte constanten

const int Cvar = 100;

void Test(const int index)
{
  index = 5;      // Hier geeft de compiler een foutmelding
}

void Test()
{
  Cvar = 10;      // Ook hier geeft de compiler een foutmelding 
} 
 
int Varray[Cvar]; // Dit zou in 'C' een foutmelding geven.
 

Nieuwe input en output methode

cout << "Hello world\n";      // Output Hello world met een newline
cout << "Hello world" << endl;    // Idem

int   VarInt = 4;
int   Var1,Var2;
float VarFloat = 3.14;
char *Str = "Hello";

cout << Str << VarInt << VarFloat << endl;   

// Resulteert in Hello43.14

cout << setw(6) << setfil('*') << 134;       

// Resulteert in  ***134 

cin >> VarInt;                

// Leest 1 integer uit de input stream

cin >> Var1 >> Var2;    

// Leest 2 integers uit de input stream

  while (var1 = getchar())
    putchar(var1);

  while(cin >> var1)
    cout << var1; 

Nieuwe geheugen beheer methode

void TestFunc()
{
int *IntPointer;

  IntPointer = new int;
  *IntPointer = 12;
  cout << *IntPointer;
  delete IntPointer;
} 


void TestFunc()
{
int *IntPointer;

  IntPointer = new int(100);
  IntPointer(10) = 12;
  cout << IntPointer(10);
  delete [] IntPointer;     // Let op bij arrays altijd [] gebruiken
} 

Call by reference

void Swap(int *Var1, int *Var2)
{
int Tmp = *Var1;

  *Var1 = *Var2; 
  *var2 = Tmp;
}

void TestFunc()
{
int V1, V2;

  Swap(& V1, & V2);      // Voorbeeld aanroep functie swap;
}

void Swap(int& Var1, int& Var2)
{
int Tmp = Var1;

  Var1 = Var2;
  var2 = Tmp;
}

void TestFunc()
{
int V1, V2;

  Swap(V1,V2);     // Voorbeeld aanroep functie Swap in C++
}

Conclusie

Hoe werkt het!

/* -------------------------------------------------------------- */
/* Include file for test class                                    */
/* (c) Hein Pragt   1998                                          */
/* -------------------------------------------------------------- */

struct _test1_class              /* Class definition */
{
  void (*func1)(int);           /* Modifier */
  int  (*func2)(void);          /* Selector */
};

extern const struct _test1_class test1; 

/* ---------------------------------------------------------------- */
/* Implementation file of test1 class.                              */
/* (c) Hein Pragt   1998                                            */
/*                                                                  */
/* Demonstration of data and member function hiding in standard 'C' */
/* ---------------------------------------------------------------- */

#include "test1.h"               /* Definition of test1 class */

/* ------------------------------------ */
/* These member functions are static    */
/* and can only be called trough the    */
/* class member interface.              */
/* ------------------------------------ */

static void func1a(int);
static int  func2a(void);

/* ------------------------------------ */
/* Local data cannot be accesed outside */
/* this module and be accessed trough   */
/* class members functions.             */
/* ------------------------------------ */
 
static int  local_data; 

/* Trick to init the class */

struct const _test1_class test1 = { func1a, func2a }; 


/* ------------------------------------ */
/* Class function 1                     */
/* This is a modifier.                  */
/* ------------------------------------ */

static void func1a(int b)
{
  printf("Test1 class func1 set local variable to %d and adds 100\n",b);
  local_data = b + 100;
} 


/* ------------------------------------ */
/* Class function 2                     */
/* This is a selector.                  */
/* ------------------------------------ */

static int  func2a()
{
  printf("Test1 class func2 return the value %d\n",local_data);
  return(local_data);
} 

/* ---------------------------------------------------------------- */
/* Main module uses test class.                                     */
/* (c) Hein Pragt   1998                                            */
/*                                                                  */
/* Demonstration of data and member function hiding in standard 'C' */
/* ---------------------------------------------------------------- */

#include "test1.h"       /* Get definition of test1 class */
#include "test2.h"       /* Get definition of test2 class */

main()
{
int res;

  printf("\n\nDit is een test van OOP methode in standard 'C'\n\n");

  test1.func1(234);              /* Call a modifier function */
  res = test1.func2();           /* Call a selector function */

  printf("The return value is: %d \n\n",res);

  test2.func1(333);              /* Call a modifier function */
  res = test2.func2();           /* Call a selector function */

  printf("The return value is: %d \n\n",res);
}

Slot conclusie.

Een object heeft een aantal kenmerken:

De interface functies zijn ook weer onder te verdelen in vier soorten:

Een tweede eigenschap van OO programmeren is overerving.

Er wordt een voorbeeld met autorijden gebruikt dat niet correct is. Het autorijden is de laatste tien jaar sterk verbeterd doordat de autoindustrie telkens weer met verbeteringen in het ontwerp kwam en nieuwe technologie is gaan toepassen. Ook wordt in het voorbeeld popnagels gebruikt als verbindingstechniek, om lijmen te vervangen. Hier zou men dus een gloednieuw en betere verbindingsmethode zoals lijmen (zelfs vliegtuigenonderdelen worden tegenwoordig gelijmd in plaats van popnagelverbindingen) door een verouderde techniek als popnagels vervangen. Dit is dus een slecht voorbeeld. Het objectgeoriënteerde ontwerpen is een nieuwe techniek die een aanvulling moet zijn op bestaande technieken. Geen enkele techniek is dusdanig goed dat het alle voorgaande technieken volledig kan vervangen. Dit mag echter geen reden zijn om elke nieuwe techniek bij voorbaat af te wijzen als zijnde onbruikbaar.

Een goed vergelijk is de elektronica-industrie. De ontwerper heeft de keuze uit een groot aantal standaardcomponenten en maakt daarmee een schakeling. Een component heeft een door de fabrikant bepaald aantal poorten en functionaliteiten, en de ontwerper moet daar in zijn ontwerp rekening mee houden. Dit betekent dat er wel eens een paar ongebruikte poorten in zijn ontwerp zitten en dat hij, als hij een poortje tekort komt, soms een tussenoplossing moet vinden want we willen (of moeten) zo weinig mogelijk componenten gebruiken. Het grote voordeel voor de ontwerper is dat de eigenschappen van de standaardcomponenten goed zijn beschreven, de componenten hun stabiliteit reeds hebben bewezen, en dat er second sources zijn. Dit leidt tot een beter en efficient ontwerpproces. In de elektronica zullen weinig mensen hun eigen componenten samenstellen, tenzij het om grote aantallen gaat.

In de software-industrie wordt echter nog heel vaak voor elk nieuw probleem een nieuwe oplossing bedacht. In de ideale situatie zou het ontwerpen van software vergelijkbaar moeten zijn aan het ontwerpen van hardware. Het gebruik van standaardcomponenten (lees: objecten zou tot betere en sneller te ontwikkelen producten kunnen leiden. Dit is niet iets wat binnen een korte tijd kan worden gerealiseerd, maar door nieuwe ontwikkelingen in standaard herbruikbare componenten op te zetten zal deze (objectgeoriënteerde) ontwerpmethode langzaam zijn intrede doen. Oude en nieuwe technieken kunnen langzaam in elkaar overgaan.

Het grote probleem is dat veel mensen in bestaande organisaties al jaren met een bepaalde techniek hebben gewerkt en het gevoel hebben dat ze de nieuwe ontwikkelingen niet meer kunnen bijhouden. Als resultaat hiervan wordt de nieuwe technologie vaak afgedaan als "nieuwe fratsen en geneuzel met classes" en dergelijke. Dit is vaak gebaseerd op de angst het niet allemaal meer te kunnen bijbenen, of na jaren nog een andere wijze van denken te moeten leren. Echter de ontwikkelingen in de techniek staan niet stil, en men zal steeds om nieuwe gereedschappen in de (software) gereedschapskist vragen. Dit is een natuurlijk proces dat niet te stuiten is. Mijn mening is dan ook dat elke nieuwe techniek de moeite van het bestuderen waard is, en ook al is zij niet direct toepasbaar, op een dag kan ze de oplossing van een bepaald probleem zijn.