"Thomas Arildsen" <tari00@kom.auc.dk> wrote in message
> "Mogens Hansen" <mogens_h@dk-online.dk> skrev i en meddelelse
> ...Resumé forkortet...
> > Det er i forvejen noget der ligner en størrelsesorden sværere at lave
> > (stabile) multi-trådet programmer end at lave enkelt trådet programmer.
> > Hvis det ikke bliver designet ordentligt fra starten bliver det værre.
>
> Grunden til, at multitrådet programmering blev valgt var, at programmet
> simulerer nogle skibe, som sejler. Jeg har så skrevet en skibs-klasse, som
> selv kan simulere sin sejlads, og så kan det så overlades til hvert enkelt
> skibs-objekt at sørge for simulation.
Ok
Jeg kan godt se at der er nærliggende at gøre hvert skibs-objekt
selveksekverende - stort set som i den virkelige verden.
> Meningen med wait funktionen var så, at et skib skulle rykke sin position
> f.eks. et sekund ad gangen.
Det er naturligvis altid "farligt" at udtale sig, for det er jo ikke sikkert
at man har forstået alle detaljer, men jeg prøver alligevel.
Umiddelbart ville jeg lave simuleringen således at alle skibs-objekter blev
bedt om at tage et skridt i simuleringen, hvor de så selv afgør i det
skridt, hvordan det vil bevæge sig.
Når alle skibe har taget et skridt kan man set hvordan den samlede situation
er.
Det kan gøres meget simpelt i en enkelt tråd.
Noget i retningen af:
#include <vector>
#include <algorithm>
#include <functional>
#include <string>
#include <iostream>
class ship
{
public:
ship(const char* name, int speed_x, int speed_y);
~ship(void); // make virtual if used as base-class
static void step(void);
private:
void do_step(void); // make pure virtual if used as base-class
std::string name_;
int speed_x_, speed_y_;
int position_x_, position_y_;
static std::vector<ship*> all_ships;
private:
// copy constructor and copy assignment not implemented
ship(const ship&);
ship& operator=(const ship&);
};
std::vector<ship*> ship::all_ships;
ship::ship(const char* name, int speed_x, int speed_y) :
name_(name),
speed_x_(speed_x),
speed_y_(speed_y),
position_x_(0),
position_y_(0)
{
all_ships.push_back(this);
}
ship:
ship()
{
all_ships.erase(std::find(all_ships.begin(), all_ships.end(), this));
}
void ship::step(void)
{
std::for_each(all_ships.begin(), all_ships.end(),
std::mem_fun(&ship::do_step));
}
void ship::do_step(void)
{
position_x_ += speed_x_;
position_y_ += speed_y_;
std::cout << name_ << " position:" << position_x_ << ", " << position_y_
<< "\n";
}
int main(void)
{
ship blue_oyster("Blue Oyster", 1, 1);
ship golden_ocean("Golden Ocean", 10, 10);
for(unsigned i = 0; 10 != i; ++i) {
ship::step();
std::cout << std::endl;
// sleep here if needed
}
}
> Hvordan håndterer man så, at det ikke
> er det samme, der skal ske, når det er timeren, der signalerer
> WaitForMultipleObjects (tag endnu en tur rundt i løkken), som når det er
> afslutnings-Event'et, der signalerer WaitForMultipleObjects (hop ud af
> løkken og afslut).
Returnværdien fra WaitForMultipleObjects indikerer hvilket object, der er
blevet signaleret på.
Dette kan så bruges til at afgøre, hvad det er der skal gøres.
Venlig hilsen
Mogens Hansen