Programmeren in C++/Inleiding

Introductie

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

De ontwerper van C++ is Bjarne Stroustrup, die toentertijd voor AT&T werkte. Zijn website is https://www.stroustrup.com/.

Naast structureel programmeren, zoals dat in C gebeurt, kan in C++ ook object-georiënteerd gewerkt worden. Omdat C++ beide programmeermethoden 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 (backward compatibility). Dit is niet voor alle aspecten van C gerealiseerd, maar wel voor het overgrote deel.

Geschiedenis

Bjarne Stroustrup, een computerwetenschapper van Bell Labs, was de ontwerper van C++ (hij noemde het "C met Klassen") en ontwierp deze taal in 1986 als verbetering van de programmeertaal C. De verbeteringen begonnen met concepten voor object-georiënteerd programmeren, zoals klassen, gevolgd door veel andere dingen, zoals virtuele functies, overloading van operatoren, multiple inheritance, templates en exception handling. Deze en vele andere dingen werden in een boek beschreven.

De programmeertaal C++ is een standaard erkende taal door de ANSI (Het Amerikaanse Natinonale Standaard Instituut), de BSI (Het Britse Standaard Instituut), DIN (Het Duitse Nationale Standaard Organisatie), en vele andere nationale standaardiseringsorganen, en was erkend door de ISO (Internationale standaard Organisatie) in 1998 als ISO/IEC 14882:1998.

Veranderingen

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>

// Print Hello World! op het scherm.

// In C++ krijgen functies een type mee, dit is meestal void of int.
int main(void)
{   
    // 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.
    std::cout << "Hello World!" << std::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{
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(void){
	// 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 neemt) 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(void){
	// 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.

Waarom C++ leren?

Waarom niet? Het is de duidelijkste keuze om iets te leren, Hoewel leren van iets altijd wel goed is.