[C(++)] voor dummies - Deel 4

Wat delete precies dealloceert in dit geval is volgens mij niet door de standaard gedefinieerd. Als delete zo geïmplementeerd is dat het free() gebruikt, dan zal die waarschijnlijk de hele array dealloceren, maar dat is dus allemaal implementatie-afhankelijk.

quote:

Op vrijdag 3 augustus 2012 19:43 schreef thabit het volgende:
Wat delete precies dealloceert in dit geval is volgens mij niet door de standaard gedefinieerd. Als delete zo geïmplementeerd is dat het free() gebruikt, dan zal die waarschijnlijk de hele array dealloceren, maar dat is dus allemaal implementatie-afhankelijk.

Ik kijk wel even in mijn C++11 documentation van x aantal euro's...

Ik ben nu ook met Project Euler bezig.
In C++ en asm amd64.

quote:

Op vrijdag 3 augustus 2012 19:11 schreef t4rt4rus het volgende:

[..]

Wat versta je onder verwijderen?

Volgens mij deallocaten delete en delete[] beide een array,
delete callt alleen de destructor van de eerste.

Of denk ik fout?

Nee, volgens mij klopt dit niet. Opzich zijn new en delete niet lastig:

De operator new doet twee dingen:
1. Alloceert ruimte voor het object en
2. Initialiseert het object met diens constructor _{tenzij het een basistype betreft en geen constuctor-notitie is gebruikt, dan wordt het misschien niet geinitialiseerd, zie de annotations}.

Hetzelfde maar omgekeerde geldt voor operator delete. Deze:
1. Roept de destructor van het object aan (als deze bestaat) en
2. Geeft het gealloceerde geheugen weer vrij.

Idem voor operator new[] en delete[], behalve dat deze het voor meerdere objecten doen.

Jij vraagt je volgens mij af wat er gebeurt als je delete aanroept op een pointer die met new[] is aangemaakt. Het simpele antwoord: geen idee. C++ zegt hier niets over. In het allerbeste geval snapt jouw compiler wat je bedoelt en verwijdert deze de hele array. In het slechtste geval crasht je programma. In ieder geval is je code slecht. Oftewel, niet doen.

Ik weet niet waarom gekozen is voor twee verschillende vormen van delete. Ik kan wel gokken: waarschijnlijk het is sneller. Als je voor elk enkel gealloceerd object moet onthouden dat het om een array van 1 object gaat, of altijd bij elke delete moet controleren of je een enkel object of een array verwijdert, verlies je tijd.

Ok zullen we het nu over `operator new' en `placement new' hebben?
Zijn ook nog vormen van new.

quote:

Op vrijdag 3 augustus 2012 22:06 schreef t4rt4rus het volgende:
Ik ben nu ook met Project Euler bezig.
In C++ en asm amd64.

Hoe ver ben je? Ik heb 1 tm 10 en 12 nu gedaan. Voor 11 moet ik nog uit zien te vogelen hoe je een matrix laadt.

quote:

Op zaterdag 4 augustus 2012 00:35 schreef thenxero het volgende:

[..]

Hoe ver ben je? Ik heb 1 tm 10 en 12 nu gedaan. Voor 11 moet ik nog uit zien te vogelen hoe je een matrix laadt.

Heb 1 en 2 vandaag gedaan.
Wil je mijn oplossing zien?

Nummer 2 is echt nice in asm

quote:

Op zaterdag 4 augustus 2012 00:37 schreef t4rt4rus het volgende:

[..]

Heb 1 en 2 vandaag gedaan.
Wil je mijn oplossing zien?

Nummer 2 is echt nice in asm

Doe maar via DM

thenxero had een vraag over hoe je kan zien hoe een getal even of oneven is.
Hij deed dit zelf met `x % 2', maar dit kan echter ook met `x & 1'.

De eerst maakt gebruik van de modulo operator.
`x % y' geeft je de rest (remainder) van het delen van x door y.
Als x deelbaar is door y geeft dit 0.

Even getallen zijn deelbaar door 2,
met `x % 2' kan je dus kijken of x even of oneven is.

Er is echter ook een andere mogelijkheid en dat is de bitwise AND operator `&'.
`x & y' geeft de logical AND van x en y per bit.

Bijvoorbeeld:
11 & 6,
in binaire weergave
1011 & 0110 = 0010

Omdat even getallen een 0 hebben in de eerste bit,
kan je met `x & 1' testen of x even of oneven is.


Andere bitwise operators in C zijn:
`|' inclusive OR;
`^' exclusive OR;
`~' complement;
en de right en left shift, `>>' en `<<'.

[ Bericht 10% gewijzigd door t4rt4rus op 04-08-2012 15:03:11 ]

Bedankt, dat wist ik niet. Jouw methode is ongetwijfeld sneller omdat er niet gerekend hoeft te worden.

[ Bericht 21% gewijzigd door thenxero op 04-08-2012 16:30:52 ]

Dat is toch de rest? Het enige probleem is dat C(++) er vreemde conventies op nahoudt wat betreft positief en negatief.

Je hebt gelijk.

En over wat voor vreemde conventies heb je het? Met modulus?

a%b heeft in C hetzelfde teken als a, dus -9 % 2 = -1 en niet 1. Dat is een nogal debiele conventie, het zou alleen van de restklasse van a moeten afhangen, niet van het teken.

quote:

Op zaterdag 4 augustus 2012 17:03 schreef thabit het volgende:
a%b heeft in C hetzelfde teken als a, dus -9 % 2 = -1 en niet 1. Dat is een nogal debiele conventie, het zou alleen van de restklasse van a moeten afhangen, niet van het teken.

Komt dat niet gewoon doordat -9%2 geïnterpreteerd wordt als -(9%2) ?

quote:

Op zaterdag 4 augustus 2012 18:43 schreef thenxero het volgende:

[..]

Komt dat niet gewoon doordat -9%2 geïnterpreteerd wordt als -(9%2) ?

Nee, de unaire - heeft prioriteit over %.

quote:

Op zaterdag 4 augustus 2012 17:03 schreef thabit het volgende:
a%b heeft in C hetzelfde teken als a, dus -9 % 2 = -1 en niet 1. Dat is een nogal debiele conventie, het zou alleen van de restklasse van a moeten afhangen, niet van het teken.

Zover ik weet was dit vroeger afhankelijk van de implementatie: C en C++ gaven geen garanties over het teken van het resultaat als een van de argumenten van de modulo-operator negatief was.

In de C++11 standaard staat dit:

quote:

5.6.4
The binary / operator yields the quotient, and the binary % operator yields the remainder from the division of the first expression by the second. If the second operand of / or % is zero the behavior is undefined. For integral operands the / operator yields the algebraic quotient with any fractional part discarded; if the quotient a/b is representable in the type of the result, (a/b)*b + a%b is equal to a.

Dit laat zien waarom je wel wilt dat het resultaat negatief is. Immers, je wilt dat (-10/3) * 3 + (-10%3) == -10 en dat geldt alleen als het resultaat van beide negatief is. Maar ga er in oudere C++ versies dus niet zomaar vanuit dat het resultaat werkelijk negatief is: oppassen dus.

quote:

Op zaterdag 4 augustus 2012 16:25 schreef thenxero het volgende:
Bedankt, dat wist ik niet. Jouw methode is ongetwijfeld sneller omdat er niet gerekend hoeft te worden.

Ik verwacht in de praktijk van niet. De compiler optimaliseert hier ongetwijfeld voor: deze zal dezelfde code genereren voor beide statements.

De / operator is dus ook niet goed, die zou a/b altijd naar beneden moeten afronden als b>0. Naar 0 afronden is duidelijk bedacht door iemand die geen wiskundig inzicht heeft.

Gelukkig doet Python het wel goed:

gcc 4.7.1-5 met -std=c++11 geeft daar

edit:
En dit klopt toch ook gewoon...?
Volgens mij klopt python niet echt.

edit 2:
Euh beiden kloppen...
Als -5/3 = -2 is dan moet -5%3 = 1 zijn.
Is -5/3 = -1 dan moet -5%3 = -2 zijn.

Ik vind de laatste echter wat logischer...

-5/3 = -(5/3)
-5%3=-(5%3)

[ Bericht 13% gewijzigd door t4rt4rus op 04-08-2012 20:46:02 ]

Logischer is als (a + b) / b altijd gelijk is aan a / b + 1. Dat is bij C niet het geval.

Ohja voor referenties zie deze site http://cppreference.com
die is wel goed

quote:

Op zaterdag 4 augustus 2012 19:05 schreef GS42 het volgende:

[..]

Ik verwacht in de praktijk van niet. De compiler optimaliseert hier ongetwijfeld voor: deze zal dezelfde code genereren voor beide statements.

Ik heb het even getest door dergelijke expressies miljarden keren uit te voeren. Het blijkt dat de & statement 1.8 keer sneller is dan de % statement, dus er zit wel degelijk verschil in.

quote:

Op zaterdag 4 augustus 2012 23:57 schreef thenxero het volgende:

[..]

Ik heb het even getest door dergelijke expressies miljarden keren uit te voeren. Het blijkt dat de & statement 1.8 keer sneller is dan de % statement, dus er zit wel degelijk verschil in.

Heb je optimalisatieflags meegegeven?

quote:

Op zondag 5 augustus 2012 00:00 schreef thabit het volgende:

[..]

Heb je optimalisatieflags meegegeven?

Nee, ik weet niet hoe dat werkt

Welke compiler gebruik je?