Thuis
Contacten

    Hoofdpagina


Programmeren in C++ voor beginners

Dovnload 5.04 Mb.

Programmeren in C++ voor beginners



Pagina49/49
Datum25.10.2017
Grootte5.04 Mb.

Dovnload 5.04 Mb.
1   ...   41   42   43   44   45   46   47   48   49

std::string

Onze String klasse is niet platform onafhankelijk. Het heeft weinig zin een platform-onafhankelijke console applicatie te bouwen met onze platform-afhankelijke String klasse.






Geef de voorkeur aan de STL boven andere bibliotheken en eigengemaakte code.

Hieronder een voorbeeld van het gebruik van std::string:


#include

#include


int main()

{

const std::string s = "Hello world";

std::cout << s << std::endl;

std::cin.get();

}
Prefereer het gebruik van std::string boven String. Gelukkig kunnen beide klassen gemakkelijk naar elkaar worden geconverteerd, zoals onderstaande code laat zien.
#include

#include

#include

#include //De CLX header


int main()

{

const String s1 = "Hello World";



const std::string s2(s1.c_str());

const String s3(s2.c_str());
assert(s1==s3);

assert(s1.Length() == s2.size());

assert(s1[1] == s2[0]);
std::cout

<< s1 << std::endl

<< s2 << std::endl

<< s3 << std::endl;

std::cin.get();

}
Merk het volgende op:

* de methode c_str produceert voor beide string klassen een

'char *', die in beide hun constructoren gebruikt kan

worden. Een 'char*' wordt ook wel een 'C-style string'

genoemd.

* Het aantal tekens in een String is met de methode

'Length' te verkrijgen, bij std::string heet deze methode

'size'.


* De String begint te tellen vanaf index 1, de std::string

vanaf index 0.



    1. En nu verder

De console applicatie is het type applicatie waar de meeste boeken mee beginnen. Ook zijn voor console applicaties de meeste programmeeromgevingen te vinden. Vanaf dit punt kan ook zonder Kylix worden gewerkt. Dit was een van mijn doelen van de cursus.


We hebben in de cursus ongeveer 50% van de C++ basis behandeld. Maar in principe kun je nu elke niet-netwerk niet-internet programma schrijven.
Iedereen die meer over C++ wil weten, kan nu verder met de vele literatuur over C++ en de vele C++ programmeeromgevingen.


  1. Appendix A: Een plaatje laten stuiteren

Onderstaande code maakt gebruik van de Tag Property. Een Tag is een getalletje waar nooit iets mee gedaan wordt.


Ik laat de dingen die ik tijdens design-time heb ingesteld geheim. Ook is de code expres niet kogelvrij.
void __fastcall TForm1::Timer1Timer(TObject *Sender)

{

//Beweeg het plaatje



Image1->Left = Image1->Left + LabelXstap->Tag;

Image1->Top = Image1->Top + LabelYstap->Tag;


//Check of het plaatje niet uit het beeld gaat.

if (Image1->Left < 0)

{

//Links uit beeld, stuiter in x richting



LabelXstap->Tag = -LabelXstap->Tag;

}

if (Image1->Left + Image1->Width > Form1->ClientWidth)

{

//Rechts uit beeld, stuiter in x richting



LabelXstap->Tag = -LabelXstap->Tag;

}

if (Image1->Top < 0)

{

//Boven uit beeld, stuiter in y richting



LabelYstap->Tag = -LabelYstap->Tag;

}

if (Image1->Top + Image1->Height > Form1->ClientHeight)

{

//Onder uit beeld, stuiter in y richting



LabelYstap->Tag = -LabelYstap->Tag;

}

}



  1. Appendix B: Maar wat is dat dan?

Inderdaad, er is meer code dan alleen de Events die je zelf maakt. Voor de liefhebbers leg ik deze uit.


Onderstaande code (zonder regelnummers) staat in Unit1.cpp:
//---------------------------------------------------------

1) #include

2) #pragma hdrstop
3) #include "Unit1.h"

//---------------------------------------------------------



4) #pragma package(smart_init)

5) #pragma resource "*.xfm"

6) TForm1 *Form1;

//---------------------------------------------------------



7) __fastcall TForm1::TForm1(TComponent* Owner)

8) : TForm(Owner)

{

}



//---------------------------------------------------------
9) void __fastcall TForm1::Button1Click(TObject *Sender)

{
}


//---------------------------------------------------------
1) Roep de CLX bibliotheek aan. 'CLX.h' is een algemene

header file, vandaar de '<' en '>'.

2) Zorg dat compilen mogelijk sneller gaat.

3) Roep de header file aan van onze Unit. 'Unit1.h' is een

lokale header file, vandaar de dubbele aanhalingstekens.

4) Gebruik de Packages zoals beschreven in de Project

Options.

5) Gebruik de .xfm als resource van dit Form.

6) Declareer een globale pointer naar het type van ons

Form. Ons Form is van het data type TForm1.

7) De constructor van ons TForm1. Heeft als argument een

TComponent pointer naar de Owner van het Form, in dit

geval Application.

8) Construct de parent class constructor (TForm) met de

Owner.

9) De definitie van de methode Button1Click. Dit is een



methode van TForm1 en heeft als argument een TObject

pointer naar Sender. Sender kan TObject zijn dat deze

methode aanroept. De methode is void, ofwel deze heeft

geen return waarde. __fastcall is een Borland extensie

die nodig is voor TForms.
Onderstaande code (zonder regelnummers) staat in Unit1.h:
//---------------------------------------------------------

1) #ifndef Unit1H

2) #define Unit1H

//---------------------------------------------------------



3) #include

4) #include

5) #include

6) #include

//-------------------------------------------------------



7) class TForm1 : public TForm

8) {

9) __published: // IDE-managed Components

10) TButton *Button1;

11) void __fastcall Button1Click(TObject *Sender);

12) private: // User declarations

13) public: // User declarations

14) __fastcall TForm1(TComponent* Owner);

15) };

//---------------------------------------------------------



16) extern PACKAGE TForm1 *Form1;

//---------------------------------------------------------



17) #endif
1) #include guard

2) #include guard

3) Roep header file 'Classes.hpp' aan. Dit is een algemene

header file, vandaar de '<' en '>'.

4) Roep header file 'QControls.hpp' aan. Dit is een

algemene header file, vandaar de '<' en '>'.

5) Roep header file 'QStdCtrls.hpp' aan. Dit is een

algemene header file, vandaar de '<' en '>'.

6) Roep header file 'QForms.hpp' aan. Dit is een algemene

header file, vandaar de '<' en '>'.

7) Start de klasse declaratie van TForm1. Deze erft public

over van TForm.

8) Accolade openen van klasse declaratie.

9) Start van het gedeelte dat door Kylix wordt beheerd.

10) Kylix beheert Button1, een TButton pointer.

11) Kylix beheert de Button1Click Event.

12) Hierachter kunnen de private methode declaraties staan.

13) Hierachter kunnen de public methode declaraties staan.

14) Declaratie van de constructor van TForm1.

15) Accolade sluiten van klasse declaratie.

16) Declareer een globale pointer genaamd Form1 van het

type TForm1.

17) #include guard

  1. Appendix C: Sneltoetsen





Effect

Sneltoets

Compileer programma

Alt-F9

Find

CTRL-F

Indent blok naar links

CTRL-SHIFT-U

Indenk blok naar rechts

CTRL-SHIFT-I

Insert code template

CTRL-J

Object Inspector

F11

Object Treeview

ALT-SHIFT-F11

Open File At Cursor

CTRL-ENTER

Project Manager

CTRL-ALT-F11

Project Options

CTRL-SHIFT-F11

Replace

CTRL-R

Toggle tussen accolades

ALT-[ en ALT-]

Toggle tussen blokhaken

ALT-[ en ALT-]

Toggle tussen haakjes

ALT-[ en ALT-]

Toggle tussen header en implementatie file

CTRL-F6

Toggle tussen Text Editor en Form

F12

Trace Into

F7

Run program

F9

Reset program

CTRL-F2

Start programma

F9

Step over

F8



  1. Appendix D: Overzicht

Een overzicht van de belangrijkste begrippen.



    1. Cast


Een conversie van een data type naar een ander data type. Hieronder vallen de vier C++ casts (static_cast, const_cast, dynamic_cast en reinterpret_cast) en de C stijl cast.
double d = static_cast<double>(i);
    1. Code

De tekst waaruit je programma bestaat.


    1. Compiler


Het programma dat onze code vertaalt naar object-code. De compiler doet zijn werk na de pre-compiler. De linker koppelt alle object-code aan elkaar tot een werkende applicatie.
    1. Data type


Het soort gegevens dat in een variabele kan worden opgeslagen. Elke variabele bestaat uit een data type en een identifier.
int x; //Declaratie van de variabele met data type int

//en met naam x. x kan hele getallen opslaan.


String s; //Declaratie van de variabele met data type

//String. String kan woorden opslaan.


    1. Declaratie


In het algemeen: aangeven dat er 'iets' is, zonder aan te geven wat dit 'iets' is of hoe dit 'iets' werkt. Wordt wel meteen aangegeven wat 'iets' is of hoe 'iets' werkt, dan is dit een definitie. Zie functie declaratie, klasse declaratie, methode declaratie, variabele declaratie.
    1. Definitie


In het algemeen: aangeven dat er 'iets' is en meteen aan te geven wat dit 'iets' is of hoe dit 'iets' werkt. Wordt niet meteen aangegeven wat 'iets' is of hoe 'iets' werkt, dan is dit een declaratie. Zie functie definitie, klasse definitie, methode definitie, variabele definitie.
    1. Event


Een Kylix-specifieke methode die onder run-time bij bepaalde gebeurtenissen wordt aangeroepen en design-time kan worden toegewezen.
    1. Functie


Een stuk code dat iets kan doen, met eventueel argumenten en een return waarde. Een functie die niets terug geeft (oftewel return type is void) wordt soms ook een procedure genoemd. Een functie binnen een klasse wordt een methode genoemd.
/* return type */ /* identifier */ ( /* argumenten */ );
double DeelDoor(const double teller, const double noemer);
    1. Functie declaratie


Het aangeven van de identifier, return type en argumenten van een functie, zonder aan te geven hoe deze functie dit doet. Wordt wel aangegeven hoe de functie werkt, dan wordt dit een functie definitie genoemd. Worden de namen van de argumenten niet genoemd, dan heet het een functie prototype.
/* return type */ /* identifier */ ( /* argumenten */ );
double DeelDoor(const double teller, const double noemer);
    1. Functie definitie


Het aangeven van de identifier, return type, argumenten van een functie en hoe deze functie dit doet. Wordt niet aangegeven hoe de functie werkt, dan wordt dit een functie declaratie genoemd.
/* return type */ /* identifier */ ( /* argumenten */ )

{

/* code */



}
int DeelDoor(const double teller, const double noemer)

{

return teller / noemer;

}

    1. Functie prototype


Een functie declaratie waarin de namen van de argumenten niet genoemd worden, slechts hun data types.
double DeelDoor(const double, const double);
    1. Generiek programmeren


Zo algemeen mogelijk programmeren, door middel van templates.
template <class T>

void Verwissel(T& a, T& b)

{

const T temp = a;

a = b;

b = temp;



}
    1. Header file


Bestand met '.h' als extensie, die vooral decaraties bevat. Het implementatie (.cpp) bestand bevat vooral definities. Een header file en een gelijknamig implementatie bestand wordt soms een Unit genoemd.
    1. Identifier


De naam van een variabele of funtie.
int x; // x is de identifier voor een int
void DoeIets(); // DoeIets is de identifier voor een void

//functie, die geen argumenten nodig heeft.


    1. Implementatie bestand


Bestand met '.cpp' als extensie, die vooral definities bevat. Een header file (.h) bevat vooral declaraties. Een header file en een gelijknamig implementatie bestand wordt soms een Unit genoemd.
    1. Initialiseren


Een variabele een eerste waarde geven
int x; //Declareer de integer x

x = 0; //Initialiseer de integer x;


Een variabele gelijk met de declaratie initialiseren wordt een variabele definitie genoemd.
    1. Klasse


Een 'slim' data type dat zorgt dat het altijd in een juiste staat verkeerd. Een klasse bestaat uit lidvariabele en methoden.
    1. Klasse declaratie


Het aangeven van de identifier en het geven van de methode declaraties en lidvariable declaraties waaruit de klasse bestaat. Zouden de methoden meteen gedefinieerd zijn, dan zou dit een klasse definitie zijn, maak vaak staan methode definities apart. Klasse declaraties staan vaak in header files (.h bestanden).
/* classe type */ /* identifier */

{

/* lidfuncties */;



/* lidvariabelen */;

};
struct MijnKlasse //Klasse declaratie

{

int Iets(const int x) const; //Methode declaratie

int mX; //Lidvariabele declaratie

};

    1. Klasse definitie


Het aangeven van de identifier, lidfuncties en lidvariabelen met hun volledige werking. Zouden de lidfuncties niet uitgewerkt zijn, dan zou dit een klasse declaratie heten. Klasse definities staan vaak in header files (.h bestanden).
/* classe type */ /* identifier */

{

/* lidfuncties */;



/* lidvariabelen */;

};
struct MijnKlasseDefinitie

{

MijnKlasseDefinitie()



: mX(1) //Variabele definitie

{
}


int MijnMethodeDefinitie(const int x);

{

mX *= x;



return mX;

}

int mX; //Variabele declaratie

};

    1. Lidfunctie


Synoniem voor methode. Zie methode.
    1. Methode


Functie binnen een klasse, die toegang heeft tot de (ook private) lidvariabelen van dezelfde klasse.
    1. Methode declaratie


In een klasse declaratie, het aangeven van een methode. Zou de werking van de methode meteen worden geschreven, dan zou dit een methode definitie zijn. Methode definities staan vaak buiten de class declaratie.
struct MijnKlasse //Klasse declaratie

{

int Iets(const int x) const; //Methode declaratie

};

    1. Methode definitie


Binnen een klasse definitie, de werking van een methode beschrijven. Omdat de declaratie van een klasse in een header (.h) file staan, staat de volledige klasse definitie ook vaak in een header (.h) file.
struct MijnKlasse //Klasse definitie

{

int Iets(const int x) const; //Methode definitie

{

return x * x * x;

}

};


Buiten een klasse declaratie, de werking van een methode beschrijven. Methode definities staan vaak in een implementatie (.cpp) bestand.
struct MijnKlasse //Klasse declaratie

{

int Iets(const int x) const; //Methode declaratie

};

int MijnKlasse::Iets(const int x) const //Methode definitie

{

return x * x * x;

}

    1. Procedure


Functie zonder return waarde, oftewel met return type void.
void /* identifier */ ( /* argumenten */ );
void ZegHallo(const String naam);
    1. Referentie


Een alias van een variable, in plaats van een kopie. Een refentie is te herkennen aan de ampersand.
void Verwissel(int& a, int& b);
    1. STL


'Standard Template Library'. De C++ platform-onafhankelijke standaard bibliotheek.
    1. Unit


Een header file en een gelijknamig implementatie bestand.
    1. Variabele


Een waarde die in het geheugen tijdelijk moet worden opgeslagen. Een variabele heeft altijd een data type en een identifier.
int x; //Declareer een variabele van data type int

//met de identifier x


    1. Variabele declaratie


Het aangeven van het data type en identifier. Het tegelijkertijd toekennen van een waarde aan deze variabele wordt een variabele definitie genoemd.
/* data type */ /* identifier */;
int x;
    1. Variabele definitie


Het aangeven van data type, identifier en een initiele waarde. Zou geen initiele waarde worden toegekend, dan wordt dit een variabele declaratie genoemd.
/* data type */ /* identifier */ = /* initiele waarde */;
int x = 12;



1   ...   41   42   43   44   45   46   47   48   49

  • Appendix A: Een plaatje laten stuiteren
  • Appendix B: Maar wat is dat dan
  • Appendix C: Sneltoetsen
  • Appendix D: Overzicht Een overzicht van de belangrijkste begrippen. Cast
  • Code De tekst waaruit je programma bestaat. Compiler
  • Lidfunctie Synoniem voor methode. Zie methode. Methode
  • STL Standard Template Library. De C++ platform-onafhankelijke standaard bibliotheek. Unit

  • Dovnload 5.04 Mb.