Programmeren in C++/Inleiding

Introductie

C++ is een uitbreiding (superset) van de programmeertaal C. C++ werd geïntroduceerd omdat C al een aantal jaren meeging en achterop raakte bij de mogelijkheden van modernere programmeertalen. Een van die mogelijkheden is object-georiënteerd programmeren. Dit is een van de belangrijkste vernieuwingen in C++.

De ontwerper van C++ is Bjarne Stroustrup. Hij werkte op dat moment voor AT&T. Zijn website is http://www.research.att.com/~bs/.

Naast structureel programmeren (zoals dat in C gebeurt) kan in C++ ook object-georiënteerd gewerkt worden. Omdat C++ beide programmeer-methoden ondersteunt, wordt C++ een hybride taal genoemd. Tijdens de ontwikkeling van C++ is een van de hoofdpunten altijd geweest dat C programma's compileerbaar zijn met een C++ compiler (backwards compatible). Dit is niet voor alle aspecten van C gerealiseerd, maar wel voor het overgrote deel.

Veranderingen

We gaan er op dit moment vanuit dat je al een klein beetje ervaring met C hebt. Dit hoeft niet veel te zijn, maar het programma "Hello World" moet je bekend zijn.

Headers

Een eerste verschil met C is dat de zogenaamde header-bestanden geen extensie meer hebben:

C

C-code:

#include <stdio.h>

C++

C++-code:

#include <iostream>

Een volgend verschil is dat er zogenaamde naamruimten (namespaces) worden gebruikt; dit om conflicten te voorkomen. De standaard header-bestanden gebruiken alle de namespace "std" (standard). Om deze namespace voor het gehele document te laten gelden, kun je "using namespace std;" gebruiken:

C++-code:

#include <iostream>
using namespace std;

De oude C-headers kunnen in C++ echter wel nog gebruikt worden.
Veel standaard C-headers zijn geconverteerd naar C++.
Ze krijgen dan geen extensie meer, hebben een c voor hun naam gekregen en gebruiken naamruimten.
Bijvoorbeeld "stdio.h" wordt "cstdio".

Functies versus objecten

Een van de grootste verschillen - zoniet het grootste - tussen C en C++ is dat er objecten i.p.v. functies kunnen worden gebruikt. Het klinkt moeilijker dan het is, kijk maar...

Het C-programma "Hello World":

C-code:

#include <stdio.h>

/* Print Hello World op het scherm */
main()
{
    printf("Hello World!\n");
}

Het C++-programma "Hello World":

C++-code:

#include <iostream>
using namespace std;

// Print Hello World op het scherm.

// In C++ krijgen functies een type mee, dit is meestal void of int.
int main()
{   
    // endl staat voor end line en doet dus hetzelfde als \n.
    // betekenis code: verplaats naar cout eerst "Hello World" en daarna endl.
    // cout plaatst de uitvoer vervolgens op het scherm.
    cout << "Hello World" << endl;

    // dit betekent: programma afgesloten zonder problemen 
    return 0;     
}

Een tweede versie van het "Hello World" programma maakt gebruik van een "Begroeter"-object, een instantie van de klasse "Begroeter":

C++-code:

// Gebruik de iostream header en de string header
#include <iostream>
#include <string>
using std::cout;	// Wanneer we 'cout' of 'endl' gebruiken refereren we
using std::endl;        // naar deze uit de naamruimte 'std'
using std::string;

// Definitie van de klasse "Begroeter".
class Begroeter{
protected: // beschermde onderdelen, enkel in sommige gevallen toegankelijk in de klasse zelf of van overal toegankelijk.
           string begroeting;

private:
	// Privaat toegankelijke onderdelen, enkel toegankelijk
	// in de klasse zelf.
	string begroeting;
public:
	// Publieke toegankelijk onderdelen, van overal toegankelijk.

	// Default constructor maakt een nieuwe instantie van
	// deze klasse aan.
	Begroeter(){
		begroeting = "Hello World";
	}

	// De zegHallo memberfunction, deze voert de begroeting uit.
	void zegHallo(){
		cout << begroeting << endl;
	}
};

int main(){
	// Maakt een nieuwe klasse aan en roept de default 
	// constructor op.
	Begroeter groeter;
	// Roep de lidfunctie 'zegHallo()' op.
	groeter.zegHallo();
	// Alles was ok, geef 0 terug.
	return 0;
}

Het Begroeter-object wordt gedefinieerd door het class- of het struct-keyword (class is nieuw tov C, en struct kan hier nu ook memberfunctions bevatten en is dus uitgebreid tegenover C). Zoals opvalt, is de klassedefinitie in twee gesplitst door de woorden "private" en "public". Na "private" komen alle lidfuncties en variabelen die eigen zijn aan de klasse en niet van buitenaf geraadpleegd of gewijzigd kunnen worden.

Voorbeelden:

• Vanuit de main functie kan men de 'begroeting' string niet wijzigen of opvragen (adhv groeter.begroeting).
• Indien de zegHallo() lidfunctie, die nu in het "public" deel staat en dus publiek toegankelijk is (adhv groeter.zegHallo() ), verplaatst zou worden naar het "private" gedeelte, zou de oproep falen.
  

In het "private" gedeelte zit enkel de begroetingsstring (C++ ondersteunt string objecten welke makkelijker te hanteren zijn dan de char * in C, char * is wel nog steeds bruikbaar). Deze begroetingsstring wordt ingesteld door de defaultconstructor in het publieke gedeelte van de klasse. Een constructor is een lidfunctie die geen returntype heeft en als naam, de naam van het object heeft. Deze wordt aangeroepen indien een instantie van het object aangemaakt wordt om administratieve zaken goed te zetten (in dit geval de private begroetingsstring). In een programma schrijven "klasseNaam identifier" roept de default constructor (een constructor die geen parameters neem) impliciet aan tenzij overladen constructors beschikbaar zijn en aangeroepen worden. Een uitbreiding op de klasse zou de volgende kunnen zijn:

C++-code:

class Begroeter{
....
public:
    ...	
    Begroeter(string s){
	begroeting = s;
    }
    ...
};

Hier definieren we een tweede constructor welke de begroeting wijzigt, wanneer we nu het hoofdprogramma zouden wijzigen tot:

C++-code:

int main(){
	// Maakt een nieuwe klasse aan en roept de default 
	// constructor op.
	Begroeter groeter("Kiekeboe");
	// Roep de lidfunctie 'zegHallo()' op.
	groeter.zegHallo();
	// Alles was ok, geef 0 terug.
	return 0;
}

Dan roepen we de tweede constructor op die een string als argument neemt. De laatste publieke functie in de klasse is de zegHallo() lidfunctie welke de begroeting uitschrijft

naar standaard uitvoer.