🚀 go-pugleaf

gert <gert@easynet.be> wrote:
> -------------------------
> #include <iostream>

> int main(){
>   std::cout << "test";
>   return(0);
> }
> ------------------------
> <iostream> Is dat ook een header file of lijkt het meer op een cpp file?

iostream is ook een header file. iostream.h en iostream bevatten
normaal gezien dezelfde declaraties maar met 1 cruciaal verschil,
zie hieronder!

> Als ik std::cout zie denk ik direct aan een classe std met als methode 
> cout en verwacht iets in den aard van.

De notatie wordt in C++ ook gebruikt voor wat met noemt 'namespaces'.
Een namespace is een verzameling min of meer samenhangende declaraties
(bv van classes, functies, variabelen). Het nut van namespaces komt
vooral naar voor in grote projecten. Wanneer je verschillende libraries
begint te gebruiken, kan het wel eens voorkomen dat zowel library
A als library B bv de functie init() willen declararen.

Het idee is dat iedere library zijn eigen 'namespace' gebruikt en
dat de 'init' van A dus A::init() is en de init van B::init().
Je kan namespaces dus beschouwen als een ge-institutionaliseerde
prefix. En uiteraard heeft ook de standaard library een eigen
namespace. Die is std::

Dus in theorie zou je alle zaken uit de standard library met std::
moeten beginnen. Bv std::cout, std::endl, std::string etc...

Het lastige van de zaak is dat in een klein project er helemaal
geen probleem is met libraries die dezelfde naam willen gebruiken.
En je dus met die namespaces veel extra typewerk op de hals haalt.
Wil je dat vermijden kan je in je file zeggen : vanaf nu ga ik
deze prefix weglaten. En dat doe je dus met

using namespace std;

En dan komen we nu terug op het cruciale verschil tussen <iostream>
en <iostream.h>. De eerste 'versies' van C++ kenden geen namespaces,
en alles van de standaard library zat in de header files met
een .h suffix zoals <iostream.h>

Toen men namespace introduceerde vond men uiteraard dat ook de standard
library in een namespace moest. Probleem was dat er natuurlijk al hopen
code was geschreven die 

1. #include <iostream.h> deed
2. nergens geen std:: prefix gebruikte

Men moest op 1 of andere manier vermijden dat al die code zou gecorrigeerd
moeten worden. Dus liet men de iostream.h versies zoals ze waren en
voegde gewoon een heel nieuw setje headers in die identiek waren, maar
die wel alles netjes in de std:: namespace plaatsten. Oude code blijft
zo werken en bovendien wordt vanaf dan aangenomen dat nieuwe code
best de headers nieuwe-stijl gebruikt. In de (ijdele) hoop dat de
headers oude-stijl ooit in de vergetelheid zullen geraken...

(Daarnaast had je code nog wel wat andere problemen, maar ik veronderstel
dat je compiler je daar wel op gewezen heeft). Nog een laatste tip
om een int aan een string toe te voegen. Er zijn verschillende
mogelijkheden, maar een van de eenvoudigste (en meest C++-achtige
is deze)

#include <iostream>
#include <sstream>

unsigned int score_belgen = 2;
unsigned int score_japan = 2;

std::string origineel = "Belgie - Japan : ";
std::ostringstream format;
format << origineel << score_belgen << "-" << score_japan << std::endl;

std::string scorebord = format.str();

Opmerkelijke van de zaak is dus dat een std::ostringstream een stream is
die je op net dezelfde manier kan gebruiken als std::cout (dus alles
wat je in std::cout kan steken, kan je ook in een std::ostringstream
steken). Het verschil is dat std::cout alles op het scherm plaatst
en dat een std::ostringstream alles in een string steekt. En die
string vraag je dan met de str() functie op, zoals de laatste regel
code demonstreert.

Hier is een functie die een int naar een std::string converteert volgens
hetzelfde principe

std::string inttostring(int a)
{
	std::ostringstream format;
	format << a;
	return format.str();
}

Een keer je die hebt kan je dingen gaan schrijven als

std::string scorebord;
scorebord += inttostring(2) + "-" + inttostring(2);

cu bart

-- 
http://www.irule.be/bvh/