[C++] Arrays - Softwareontwikkeling

woensdag 4 april 2007 23:18

Acties:

Verwijderd

Topicstarter

Hallo

Ik heb volgende vraag voor jullie:

Ik zoek een array, een soort buffer waar ik bytes kan opslaan van pakketten. Het moet bijvoorbeeld een array zijn van 10 of 100 pakketten groot (doet er nu eigenlijk niet zoveel toe). De pakketten blijven tussen continu toestromen maar er worden er slechts een 10 of 100 tal opgeslagen per keer in een array. Het is de bedoeling dat in een array telkens het pakket verdwijnt dat er al het langste in zit en dat er dan een nieuw bijkomt;

Dus als je een array van 10 pakketten hebt: het laatste verdwijnt,moet er een nieuw bijkomen....
Hoe doe je dit?? Het is ook de bedoeling dat er op elk pakket dan een bewerking wordt uitgevoerd.

Ik hoop dat ik toch een beetje duidelijk ben, als er vragen zijn om het duidelijker voor te stellen, shoot !

merci

woensdag 4 april 2007 23:26

Acties:

kenneth

achter de duinen

Een teller bijhouden waarin je het volgende item gaat opslaan. Als je dan de rest neemt van de teller gedeeld door de arraygrootte, weet je in welke index je de volgende waarde moet opslaan. 'n Circulaire buffer krijg je dan.

Om de TS maar 'ns in een denkrichting te duwen. Maar ik vermoed toch dat er zo vijf voorgekauwde antwoorden staan ...

Look, runners deal in discomfort. After you get past a certain point, that’s all there really is. There is no finesse here.

woensdag 4 april 2007 23:30

Acties:

sonix666

Dit klinkt erg als FIFO (First In, First Out) oftewel een queue. Kijk eens naar de STL klasse std::queue. Of dat je die wilt gebruiken ligt wat aan de performance requirements, maar houdt altijd in het achterhoofd: premature optimization is the root of all evil.

woensdag 4 april 2007 23:33

Acties:

Verwijderd

Topicstarter

Bedankt vr de reacties tot nu toe.
Kenneth, kan je dit eventueel eens in een stukje code voorstellen?

donderdag 5 april 2007 00:14

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

Verwijderd schreef op woensdag 04 april 2007 @ 23:33:
Bedankt vr de reacties tot nu toe.
Kenneth, kan je dit eventueel eens in een stukje code voorstellen?

http://en.wikipedia.org/wiki/Circular_buffer

Het concept is echt geen rocket science. Je maakt een ruimte van 100 elementen, begint te vullen bij 0 en als je aan het eind komt begin je weer bij 0 (automatisch dus het oudste element) te (over)schrijven.

Verder is ook de term FIFO gevallen, daar moet je ook iets mee kunnen als je even wat verder kijkt.

Verwijderd schreef op woensdag 04 april 2007 @ 23:33:
Kenneth, kan je dit eventueel eens in een stukje code voorstellen?

Kenneth sloeg de spijker op z'n kop:

kenneth schreef op woensdag 04 april 2007 @ 23:26:
Om de TS maar 'ns in een denkrichting te duwen. Maar ik vermoed toch dat er zo vijf voorgekauwde antwoorden staan ...

Het is PRG niet de bedoeling om om kant-en-klare oplossingen te vragen. Je hebt een duw in de juiste richting en mocht je tegen (concrete!) problemen aan lopen dan ben je hier (weer) van harte welkom met een specifieke(re) vraag daaromtrent.

We verwachten op z'n minst dat je het even laat bezinken, gaat zoeken, aan de slag gaat enz.

[ Voor 55% gewijzigd door RobIII op 05-04-2007 00:19 ]

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

donderdag 5 april 2007 00:16

Acties:

kenneth

achter de duinen

Je wil steeds de oudste overschrijven. Uitgaande van 'n array van 10 elementen:

Je schrijft achtereenvolgens in indexes 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2 ...

Je kan met 'n modulo-berekening ook zo tellen. Door één bij het vorige getal op te tellen, en dan daarvan de rest van de deling door 10 (het aantal elementen):

C++:

1	x = (x + 1) % 10

Na 9 zal de waarde dus (9 + 1) = 10 % 10 = 0 (want 10/10 = 1 rest 0) weer bij het beginnen. Zo overschrijf je steeds de oudste waarde.

Look, runners deal in discomfort. After you get past a certain point, that’s all there really is. There is no finesse here.

donderdag 5 april 2007 00:18

Acties:

Bergen

Spellingscontroleur

Er wordt eigenlijk wel verwacht dat je eerst zelf iets probeert, en als het niet lukt, dat je dan vertelt wat er dan niet lukt en waarom je denkt dat het niet werkt.

Enfin, even iets pseudo-achtigs...

Eerste manier: de rij steeds opschuiven zodat het getal achteraan (het oudste) komt te vervallen...

code:

lengte = 10

function voeg_toe(getal)
{
    // de hele rij opschuiven naar rechts
    for(i=0;i<lengte-1;i++) {
        rij[i+1] = rij[i];
    }

    // nieuwe getal vooraan plaatsen
    rij[0] = getal
}

Of bijhouden wat het laatst toegevoegde getal is:

code:

laatste = 0
lengte = 10

function voeg_toe(getal)
{
    // 'laatste' opschuiven
    laatste++

    // eventueel weer resetten als we aan het eind komen
    if (laatste = lengte) {
        laatste = 0
    }

    // getal plaatsen
    rij[laatste] = getal
}

Maar zoiets kun je ook zelf bedenken, toch?

donderdag 5 april 2007 00:22

Acties:

Verwijderd

kenneth schreef op donderdag 05 april 2007 @ 00:16:
Je kan met 'n modulo-berekening ook zo tellen.

Ikzelf ben niet zo dol op modulo-berekeningen, dit, omdat ze sloom zijn.

donderdag 5 april 2007 00:34

Acties:

writser

Verwijderd schreef op donderdag 05 april 2007 @ 00:22:
[...]

Ikzelf ben niet zo dol op modulo-berekeningen, dit, omdat ze sloom zijn.

En? Gewoon een mooi circulair buffer maken met modulo, optimaliseren kan later wel. Als het al nodig is. Premature optimization is the root of all evil .. Hoewel de code van Bergen misschien nog wel duidelijker is.

Onvoorstelbaar!

donderdag 5 april 2007 01:02

Acties:

Bergen

Spellingscontroleur

Tja, 't werkt snel zat en het is ook simpeler om te bouwen als je bijvoorbeeld de mogelijkheid wilt inbouwen om een array getallen ineens toe te voegen.

donderdag 5 april 2007 01:14

Acties:

Verwijderd

Verwijderd schreef op donderdag 05 april 2007 @ 00:22:
[...]

Ikzelf ben niet zo dol op modulo-berekeningen, dit, omdat ze sloom zijn.

Dit kun je in algemene zin niet zo stellen. Optimisers van veel talen (zoals C) vervangen delingen door een tweemacht door een right-shift, en modulo door een simpele and. Dit omdat shifts en ands in vergelijking met delingen helemaal niet zo 'sloom' zijn, integendeel.

In C bijvoorbeeld betekent het bovenstaande dat wanneer je iets modulo 16 doet, dit vervangen wordt door een AND met het getal 15 (in bits: 0...01111). En delen door 16 wordt een right-shift van 4 bits. Als performance (erg) belangrijk is, is het dus een kwestie van het kiezen van de juiste deelfactor. En natuurlijk de optimiser niet vergeten te gebruiken tijdens het compileren...

donderdag 5 april 2007 01:38

Acties:

.oisyn

Moderator Devschuur®

Demotivational Speaker

Verwijderd schreef op donderdag 05 april 2007 @ 00:22:

Ikzelf ben niet zo dol op modulo-berekeningen, dit, omdat ze sloom zijn.

Geheugen is slomer. Gebruik je zeker ook niet?

Verwijderd schreef op donderdag 05 april 2007 @ 01:14:
en modulo door een simpele and.

Werkt natuurlijk alleen voor machten van 2 (itt de multiply, waarbij elke factor met een serie van shifts te implementeren is), maar bovendien is het ook niet compatible met de modulo - negatieve getallen geven doorgaans een negatieve uitkomst. Bij een and is de modulo altijd positief (en daarom is dus alleen bij unsigned ints of als de compiler de modulo sowieso altijd als positief implementeert vervangbaar door een and).

Ikzelf neem liever niet deze gok en gebruik gewoon een ringbuffer van een macht van 2 icm een and. Als dat niet kan (omdat je een specifiek aantal entries moet hebben) dan maar de modulo, zo sloom is hij helemaal niet.

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

donderdag 5 april 2007 02:59

Acties:

Soultaker

Je kunt er ook altijd nog iets als if(++index == capacity) index = 0; van maken, als je per se die modulo-operatie wil vermijden.

Verder klinkt het alsof je een queue nodig hebt. Wellicht kun je gewoon een std::queue (of direct een std::deque) voor gebruiken. Een deque werkt anders dan een circulaire buffer, omdat 'ie niet uit gaat van een van te voren ingesteld maximum. (Dat is namelijk het nadeel van de circulaire buffer: je moet van te voren de capaciteit vaststellen.)

donderdag 5 april 2007 09:14

Acties:

Verwijderd

Topicstarter

Ok :-) bedankt, ik ga eerst eens al jullie voorstellen bekijken :-).

donderdag 5 april 2007 09:29

Acties:

Verwijderd

Bij een normale modulo maakt de compiler gebruik van een idiv. Ter illustratie een post van mij op osdev.org: klik! Een simpele AND is idd beter, maar dat kan alleen met machten van 2, Als een compiler een idiv ervan maakt (lees gcc 4.nogiets) is dit vrij kostbaar, ik ben gewend om kernels te schrijven, dus als ik in mijn memory manager modulo wil gebruiken kijk ik wel twee keer uit, want feit is dat een idiv sloom is.

donderdag 5 april 2007 09:30

Acties:

Janoz

Moderator Devschuur®

!litemod

Het is nog makkelijker om de lengte van de buffer gewoon een 2 macht te maken

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'

donderdag 5 april 2007 17:02

Acties:

Verwijderd

Topicstarter

Heb dit even bekeken van die queues, maar het is niet zoiets dat ik moet hebben. Ik heb inderdaad zo iets nodig zoals kenneth zei, ik moet gebruik maken van een modulo-berekening.

Ik zal even de situatie proberen te schetsen:

Ik heb 3 arrays tot nu toe. Alle 3 deze arrays bevatten verschillende tijdstippen (zie code hieronder).

C++:

const int MAXQUEUE = 10 ;

Timestamp myarray[MAXQUEUE];
Timestamp myarray2[MAXQUEUE];
Timestamp OWDarray[MAXQUEUE];

Timestamp ts;
ts = *(p->data() + (p->length() - 8));

Timestamp now = Timestamp::now();

index = seq_nr % MAXQUEUE;
myarray[index] = ts;
myarray2[index] = now;

Timestamp OWD;
OWDarray[index] = (now - ts);

Je ziet dus 3 arrays, de laatste array is het verschil van de 2 arrays ervoor. Het zijn dus tijdstippen van pakketten dat je hier ziet. De laatste array (de OWD-array) is het verschil tussen wnr het pakket verzonden is en wnr het pakket aangekomen is (=delay). Elk pakket bevat een sequentienummer. Er worden telkens 2 pakketten vlak na elkaar verstuurd (bijna gelijktijdig dus), we hebben het dus over een pakketpaar.

Wat wil ik nu bekomen?

Het zou de bedoeling zijn dat bij elke 10 pakketten (5 pakketparen) IN DE OWDarray hieruit de kleinste OWD som (delay pakket1 + delay pakket2, deze 2 pakketten zijn dus eigenlijk een pakketpaar zoals ik al zei, maar ze hebben elk een verschillend sequentienummer) wordt gehaald.

Als dit gebeurd is moet ik van deze 2 pakketten (het beste pakketpaar) de tijd gaan halen wanneer deze aangekomen zijn. DUS de tijd dat is opgeslagen in deze array: myarray2[index] = now.

Zo.. alle hulp is welkom!

[ Voor 0% gewijzigd door een moderator op 05-04-2007 17:08 . Reden: Als je code post, gebruik dan code-tags (liefst mét taalaanduiding) ;) ]

donderdag 5 april 2007 17:10

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

Ik zie even niet waarom je hiervoor een circulaire buffer / queue nodig zou hebben? Kun je dat gedeelte ook even uitleggen?

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

donderdag 5 april 2007 17:15

Acties:

doxick

pak gewoon een linkedlistje...
alles een index geven
voegtoe() {
if ( tail->index - head->index == 100 ) {
head = head->next;
}
tail->next = new linkListNode();
tail->next->index
tail = tail->next;
}

and we're done

donderdag 5 april 2007 17:17

Acties:

.oisyn

Moderator Devschuur®

Demotivational Speaker

C++:

1	std::list<Node> nodes;

And we're done

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

donderdag 5 april 2007 18:35

Acties:

Verwijderd

Topicstarter

Kun je dit eventjes uitleggen doxick ?

donderdag 5 april 2007 18:55

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

Verwijderd schreef op donderdag 05 april 2007 @ 18:35:
Kun je dit eventjes uitleggen doxick ?

Waarom doe je zelf niet eens een beetje moeite?

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

donderdag 5 april 2007 19:52

Acties:

.oisyn

Moderator Devschuur®

Demotivational Speaker

Of je gebruikt gewoon functionaliteit die al standaard aanwezig is in C++

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

donderdag 5 april 2007 22:53

Acties:

RobIII

Admin Devschuur®

^ Romeinse Ⅲ ja!

Verwijderd schreef op woensdag 04 april 2007 @ 23:33:
Bedankt vr de reacties tot nu toe.
Kenneth, kan je dit eventueel eens in een stukje code voorstellen?

Verwijderd schreef op donderdag 05 april 2007 @ 18:35:
Kun je dit eventjes uitleggen doxick ?

Verwijderd schreef op donderdag 05 april 2007 @ 20:56:
[...]

Ik heb die zaken allemaal al gelezen, toch snap ik nog niet goed wat doxick daar in zijn code doet ...

Verwijderd schreef op donderdag 05 april 2007 @ 22:38:
[...]

Ik zal dit inderdaad bij nader inzien niet nodig hebben. Nog tips ?

Als je nou eens concreet zou aangeven wat je niet snapt dan zouden we misschien nog zinnige input kunnen geven. Verwacht je nu van ons dat we je hele concepten (waar overigens voldoende uitleg over te vinden is dankzij de vele links in dit topic) gaan voorkauwen die je prima zelf kunt bestuderen? Zo werkt het hier niet in PRG. We zien graag wat eigen inzet en ik zie jou (helaas) alleen maar vragen om kant-en-klare code en oplossingen.

Graag zou ik in een volgende post wat meer inzet van jezelf terug zien; gaat het topic op deze voet verder dan is het wat mij betreft een scriptrequest/quickfix en gaat het alsnog op slot.

[ Voor 3% gewijzigd door RobIII op 05-04-2007 22:54 ]

There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery.

Je eigen tweaker.me redirect

Over mij

vrijdag 6 april 2007 13:36

Acties:

Icelus

Verwijderd schreef op donderdag 05 april 2007 @ 00:22:
[...]

Ikzelf ben niet zo dol op modulo-berekeningen, dit, omdat ze sloom zijn.

Semi-offtopic: (zonder sprongopdrachten):

Voor de liefhebbers: Hacker's Delight

C:

signed int masker;

/* Maximale index is bijvoorbeeld 40.
 * Indien index < 40 wordt masker -1, indien gelijk aan 40 wordt masker 0.
 */
index++;
masker = (index - 40) >> 31;
index &= masker;

Developer Accused Of Unreadable Code Refuses To Comment

vrijdag 6 april 2007 18:07

Acties:

Verwijderd

@Icelus:

Als je zoals in jouw voorbeeld aangeland bent op het niveau dat je tegen de hardware aan gaat leunen voor het laatste stukje performance, dan zou ik voor kleine tabellen jouw (uitstekende) aanpak ook even benchmarken tegen het volgende, dat verhoudingsgewijs ook wel aardig presteert indien de next-array in z'n geheel in bijvoorbeeld een L1 data cache past:

C:

typedef int TIdx;    // bij grotere tabellen is 'char' te overwegen, maar daar kan een performance
                     // penalty aan verbonden zijn als sizeof(int) != sizeof(char); benchmarken dus!
TIdx next[40] = { 1, 2, .., 39, 0 };
TIdx idx = 0;
// ...
idx = next[idx];

Merk op dat je dan nogal hardware-afhankelijk bezig bent: wat optimaal is op de ene architectuur, hoeft dat niet per sé ook op de andere te zijn.

vrijdag 6 april 2007 23:44

Acties:

Verwijderd

Topicstarter

Ik heb nu dit:

C++:

 int diff = OWDarray[0]+OWDarray[1];
int index = 0;
for (int i=2; i<MAXQUEUE; i+=2) {
  if ( (OWDarray[i]+OWDarray[i+1]) < diff) {
    diff = OWDarray[i] + OWDarray[i+1];
    index = i;
  }
}

Je gaat dus uit je OWDarray de index zoeken van
het pakketpaar waar de OWD som minimaal is.

De bekomen index kan ik bijvoorbeeld dan gebruiken voor de andere twee
arrays die ik heb (waarin de tijdstippen staan).

Hoe kannek nu checken of er reeds een OWD is ingevuld in de array voor de
index i en i+1 ?

zaterdag 7 april 2007 00:41

Acties:

.oisyn

Moderator Devschuur®

Demotivational Speaker

Icelus schreef op vrijdag 06 april 2007 @ 13:36:
[...]
Semi-offtopic: (zonder sprongopdrachten):

Voor de liefhebbers: Hacker's Delight
C:
1
2
3
4
5
6
7
8
signed int masker;

/* Maximale index is bijvoorbeeld 40.
 * Indien index < 40 wordt masker -1, indien gelijk aan 40 wordt masker 0.
 */
index++;
masker = (index - 40) >> 31;
index &= masker;

Nice, let er wel op dat de shift right hier arithmetic moet zijn (is niet gedefinieerd in de standaard), en dat een int natuurlijk 32 bits moet zijn (gebruik anders CHAR_BIT - 1). Overigens kan een x86 compiler ook wel gewoon een cmov instructie genereren bij een if.

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

zaterdag 7 april 2007 01:02

Acties:

Spockz

Live and Let Live

Niet zo heel erg performant maar het idee is er:

PHP:

class queue {
private $i;
public $array;
  
  function queue() {
    $this->i = 0;
  }

  function add($string) {
    $this->array[] = $string;
    $this->i++;
    
    if($this->i === 100) {
      $this->i = 0;
    }
  }
}

C'est le ton qui fait la musique. | Blog | @linkedin
R8 | 18-55 IS | 50mm 1.8 2 | 70-200 2.8 APO EX HSM | 85 1.8

zaterdag 7 april 2007 01:21

Acties:

doxick

.oisyn schreef op donderdag 05 april 2007 @ 17:17:
C++:
1
std::list<Node> nodes;
And we're done

uiteraard zou je dat ook kunnen gebruiken,echter heb ik het er nooit zo op en kost het je 3 minuten om het zelf te maken.

reden dat ik een linkedlist aanraad is omdat hij meerdere dingen per index bij wil houden. voor programmeergemakt werkt een linkedlist dan lekker makkelijk.

mocht het snel moeten werken is het beter om de data die je per keer processed te alignen achter elkaar dus 3 gescheiden arrays (aaaaaabbbbbbcccccc ipv abcabcabcabcabcabc) maar aangezien je weinig tot geen kennis hebt wat dat betreft is het makkelijker om gewoon eerst eens zelf wat research gaat verrichten.

linkedlist -> wikipedia staat goede beschrijving

zaterdag 7 april 2007 01:32

Acties:

.oisyn

Moderator Devschuur®

Demotivational Speaker

doxick schreef op zaterdag 07 april 2007 @ 01:21:
[...]

uiteraard zou je dat ook kunnen gebruiken,echter heb ik het er nooit zo op en kost het je 3 minuten om het zelf te maken.

Het kost je ook een uur om te debuggen als je een fout maakt, daarnaast is de standaard library aardig uitgeoptimaliseerd. Als je er zelf een wilt maken om ervan te leren moet je het natuurlijk vooral doen (hoewel je als je C++ wilt leren ook wat van de standaard library moet weten), maar als je er gewoon een nodig hebt is het niet handig en bovendien zitten ze daar in het bedrijfsleven ook niet op te wachten.

[ Voor 6% gewijzigd door .oisyn op 07-04-2007 01:33 ]

Give a man a game and he'll have fun for a day. Teach a man to make games and he'll never have fun again.

zaterdag 7 april 2007 01:41

Acties:

doxick

.oisyn schreef op zaterdag 07 april 2007 @ 01:32:
[...]
Als je er zelf een wilt maken om ervan te leren moet je het natuurlijk vooral doen (hoewel je als je C++ wilt leren ook wat van de standaard library moet weten), maar als je er gewoon een nodig hebt is het niet handig en bovendien zitten ze daar in het bedrijfsleven ook niet op te wachten.

helemaal mee eens!
in dit geval zou ik hem zelf bouwen aangezien de TS beperkte kennis van c++/programmeren heeft (Waar leidt ik dit van af: hij post een vraag als dit, iets wat vrij beperkte kennis nodig heeft)

zaterdag 7 april 2007 14:23

Acties:

Icelus

.oisyn schreef op zaterdag 07 april 2007 @ 00:41:
[...]

Nice, let er wel op dat de shift right hier arithmetic moet zijn (is niet gedefinieerd in de standaard), en dat een int natuurlijk 32 bits moet zijn (gebruik anders CHAR_BIT - 1). Overigens kan een x86 compiler ook wel gewoon een cmov instructie genereren bij een if.

Tabellen kunnen uiteraard ook handig zijn. Ik ga er inderdaad (onjuist) van uit dat een shift right op een signed type zo werkt. Ben ooit één compiler tegengekomen die dat niet deed. Je zou natuurlijk ‘masker’ dan op de volgende (omslachtigere) manier kunnen berekenen:

C:

1 2	masker = (index - 40) >> 31; masker = 0 - (masker & 1);

De CMOV instructie dacht ik inderdaad niet aan (Pentium en Z80 hadden die nog niet

)

[ Voor 4% gewijzigd door Icelus op 07-04-2007 17:00 ]

Developer Accused Of Unreadable Code Refuses To Comment

maandag 9 april 2007 22:03

Acties:

Verwijderd

Topicstarter

Verwijderd schreef op vrijdag 06 april 2007 @ 23:44:
Ik heb nu dit:
C++:
1
2
3
4
5
6
7
8
 int diff = OWDarray[0]+OWDarray[1];
int index = 0;
for (int i=2; i<MAXQUEUE; i+=2) {
  if ( (OWDarray[i]+OWDarray[i+1]) < diff) {
    diff = OWDarray[i] + OWDarray[i+1];
    index = i;
  }
} 
Je gaat dus uit je OWDarray de index zoeken van
het pakketpaar waar de OWD som minimaal is.

De bekomen index kan ik bijvoorbeeld dan gebruiken voor de andere twee
arrays die ik heb (waarin de tijdstippen staan).

Hoe kannek nu checken of er reeds een OWD is ingevuld in de array voor de
index i en i+1 ?

Kan iemand mij hierbij helpen?

En als ik dit slechts wel aanroepen om de 10 packets ofzo, kan ik dan gwn schrijven:

C++:

 if(seq_nr % MAXQUEUE = 0)
{
code die ik al heb 
}

dinsdag 10 april 2007 20:52

Acties:

MSalters

Een array begint in zowel C als C++ default-geinitialiseerd, tenzij je'm expliciet initaliseert. Voor int betekent dat dat de waardes onvoorspelbaar zijn; sterker nog, je mag alleen waardes lezen die je eerst zelf geschreven hebt. Je kunt dus niet aan OWDarray[i] zien of die geschreven is, integendeel, als dat niet het geval is dan is de variabele potentieel onleesbaar.

Man hopes. Genius creates. Ralph Waldo Emerson
Never worry about theory as long as the machinery does what it's supposed to do. R. A. Heinlein

donderdag 12 april 2007 16:32

Acties:

Verwijderd

Topicstarter

Allright,

Even tussendoor: Hoe print ik een tijdstip dat ik heb opgeslagen als een aantal bytes in mijn data?

Het enige dat ik zoek is zoals je bijvoorbeeld %d (vr decimaal), %s(voor string). Ik heb ze bijna allemaal uitgeprobeerd denk ik maar geen enkel werkt.

donderdag 12 april 2007 16:50

Acties:

Janoz

Moderator Devschuur®

!litemod

Definieer 'een tijdstip'. Als het om een datum of tijd gaat dan zul je die eerst om moeten zetten naar een string en dan pas afdrukken.

Ken Thompson's famous line from V6 UNIX is equaly applicable to this post:
'You are not expected to understand this'

donderdag 12 april 2007 16:54

Acties:

leuk_he

1. Controleer de kabel!

Timestamp is geen default class dacht it zo.

als je ze hebt gebruikt:

http://www.codeguru.com/cpp/cpp/cpp_mfc/article.php/c881/

code:

1	void TimeStamp::getTimeStamp ( DATE timestamp, string & timestampStr )

ander idee: gewoon casten naar een CString of een char * en die printen?

Need more data. We want your specs. Ik ben ook maar dom. anders: forum, ff reggen, ff topic maken
En als je een oplossing hebt gevonden laat het ook ujb ff in dit topic horen.

donderdag 12 april 2007 17:17

Acties:

Verwijderd

Topicstarter

Janoz schreef op donderdag 12 april 2007 @ 16:50:
Definieer 'een tijdstip'. Als het om een datum of tijd gaat dan zul je die eerst om moeten zetten naar een string en dan pas afdrukken.

Het gaat hem om een tijd:

Timestamp::Timestamp(int32_t sec, uint32_t subsec)