Nu mét gratis web-support!
Als je vragen hebt over C of C++, dan zit je hier goed met een (hopelijk later grote) kliek guru's.
Beperk je vragen niet tot "hij doet het niet" of "hij geeft een fout" - onze glazen bol is kapot en we willen graag van je weten wát er niet lukt en wélke foutmelding je precies krijgt.
En onthoud: lieve modjes maken dit topic centraal!
Vorige delen:
[C(++)] voor dummies - Deel 1
[C(++)] voor dummies - Deel 2
FAQ Ik wil beginnen met C/C++, wat voor IDE is het beste voor mij?Dat ligt eraan. Als je alléén voor MS Windows wilt gaan developen, is Visual Studio de beste optie. Deze kun je bovendien als je student bent via Microsoft DreamSpark of MSDN Academic Alliance gratis downloaden.
Wil je echter cross-platform (dat wil zeggen: voor b.v. Windows én Linux, of Linux én Mac) gaan developen, dan zijn Dev-C++ en Code::Blocks de beste optie voor C++. Eclipse (ook voor C) en NetBeans zijn ook goede keuzes, alleen zijn deze meer op Java gericht. Een ander IDE, van Nokia's hand, is Qt Creator. Dit IDE maakt gebruik van het Qt-framework, een set van functies, types, variabelen etc. om programmeren makkelijker te maken. Dit framework is cross-platform.
Hoe gebruik ik x/wat houdt y in?Stop! Voor vragen hoe je bepaalde ingebouwde functies, types of classes gebruikt kun je de C referentie of de C++ referentie gebruiken. Hier staat alles in wat je nodig hebt.
Wat is het verschil tussen C en C++?C++ is, eenvoudig gezegd, een nieuwere versie van C (vandaar ook de naam, C++ wil zeggen: verhoog de waarde van C met 1). Het biedt onder andere betere klasse-ondersteuning en verschillende nieuwe types, zoals vectors en maps, om er maar een paar te noemen.
Als je wilt beginnen met leren, is C++ beter, want C wordt eigenlijk niet vaak meer gebruikt.
Wat is het Windows SDK?Het Windows SDK is een set van functies, gemaakt door Microsoft, om het programmeren voor Windows te vereenvoudigen.
Als je ervoor kiest het Windows SDK te gebruiken, houd er dan rekening mee dat je applicatie Windows-only wordt!
Je kunt de laatste versie hier vinden ter download.
Handige links:
Referenties en tutorials:
• Leer C en/of C++ (engels)
• Leer programmeren met het Windows SDK (engels)
• Info over het Windows SDK (engels)
Deze OP vind je hier.
| 1 2 3 4 5 6 | #include <cstdio> int main() { printf("%c%c%c\n", 'T', 'V', 'P'); return 0; } |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 | #include <iostream> #include <vector> class Master{ protected: unsigned short i; public: Master():i(5){} virtual unsigned short get(){return 9;} }; class Sub:public Master{ public: Sub(){i=8;} unsigned short get(){return i;} }; int main(){ Master *M_ptr; Sub mySub; M_ptr = &mySub; Sub *S_ptr = dynamic_cast<Sub*>(M_ptr); if(S_ptr) // hier werkt het std::cout << "Works\n"; else std::cerr << "FAIL\n"; std::vector<Master> myVec; myVec.push_back(Sub()); Master *vec_ptr = &myVec[0]; Sub *S_ptr2 = dynamic_cast<Sub*>(vec_ptr); if(S_ptr2) // hier faalt het std::cout << "Works\n"; else std::cout << "FAIL\n"; return 0; } |
waarom werkt dynamic_cast niet als er een pointer naar een vecor wijst?
Moraal van het verhaal: value-typed class objecten zijn gewoon zwaar kut. Een van de vele designfoutenblunders in C++ om zoiets toe te laten.
um, die destructor klopt idd maar er is toch een virtual methode?quote:Op zaterdag 29 januari 2011 00:15 schreef thabit het volgende:
Nog een probleem met je code is dat je de base class niet polymorf hebt gemaakt. Er moet tenminste 1 virtual methode in zitten; het is sowieso raadzaam om de destructor virtual te maken. Dat classes niet automatisch polymorf zijn is overigens ook een designflater.
virtual unsigned short get(){return 9;}
O ja, overheen gelezen. Maar dan nog moet je geen polymorfisme toepassen op value-typed objecten.quote:
[..]
um, die destructor klopt idd maar er is toch een virtual methode?
virtual unsigned short get(){return 9;}
| 1 | mingw/bin/../lib/gcc/mingw32/3.4.5/../../../../include/c++/3.4.5/ext/new_allocator.h:52: error: forming pointer to reference type `Master&' |
en nog veel meer...
maar std::vector<Master*> werkt wel
Ja, ik heb het zo bedacht:quote:
Pas wel een beetje op dat je geen pointers naar ongedefinieerde stukken geheugen laat wijzen.
[code]
Master *M_ptr = new Sub();
myVec.push_back(M_ptr);
en dan de destructor v.e class waar Master in zit:
~Class{
for(int i = 0; i < myVec.size(); i++){
delete myVec[i];
}
myVec.clear();
}
nog een vraagje, roept een vector bij destruction ook de destructor van het type aan? dus zegmaar std::vector<int> roept die dan ook ~int() aan?
Een int heeft trouwens niet echt een destructor je kunt (denk ik) wel ~int() aanroepen, maar dat is puur om de syntax consistent de houden, de instructie doet helemaal niets.
Ja, als er een destructor bestaat zal deze aangeroepen worden. Dit geldt echter alleen als je classes (of base-types) in de vector opslaat. Als je std::vector<X*> gebruikt, zal de X::~X() destructor niet automatisch aangeroepen worden. Daarom wordt het ook als niet netjes gezien om pointers in containers op te slaan.quote:
nog een vraagje, roept een vector bij destruction ook de destructor van het type aan? dus zegmaar std::vector<int> roept die dan ook ~int() aan?
Edit: Oh, ik had het bovenstaande antwoord gemist.
Gaat tegen het idee van de stl containers in, namelijk dat de container de eigenaar van de data is. Netter zou zijn de pointer in een class te wikkelen. Dit is echter erg afhankelijk van smaak en stijl, en iedereen weet dat daarover prima te twisten valt.quote:
Niks mis met pointers in containers, mits je duidelijk aan elke new een delete koppelt.
.| 1 2 | long long troll[2]={7308604865845225588LL, 0}; printf("%s\n", (char *)troll); |
Mensen kiezen vaak voor c++ vanwege de snelheid, niet omdat de taal zo lekker netjes weg te tikken is... Daarvoor zijn veel geschiktere talen (met garbage collector etc)quote:
[..]
Gaat tegen het idee van de stl containers in, namelijk dat de container de eigenaar van de data is. Netter zou zijn de pointer in een class te wikkelen. Dit is echter erg afhankelijk van smaak en stijl, en iedereen weet dat daarover prima te twisten valt.
tja ik kan het ook in een matrix / array zetten maar dat is weer gekut als je er data aan toe wilt voegen, dan kan dat wel met classes die dan naar het volgende object wijzen maar waarom zou ik dat doen als ik ook gewoon vector<int*> kan gebruiken? en het dan via een destructor kan laten verwijderenquote:
[..]
Ja, als er een destructor bestaat zal deze aangeroepen worden. Dit geldt echter alleen als je classes (of base-types) in de vector opslaat. Als je std::vector<X*> gebruikt, zal de X::~X() destructor niet automatisch aangeroepen worden. Daarom wordt het ook als niet netjes gezien om pointers in containers op te slaan.
Edit: Oh, ik had het bovenstaande antwoord gemist.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | #include <iostream> #include <vector> class Temp{ int i; public: Temp(){} ~Temp(){ std::cout << "Destructor\n"; } }; int main(){ std::vector<Temp> myvec; myvec.push_back(Temp()); return 0; } |
| 1 2 | Destructor Destructor |
en als ik de push_back(Temp()) weglaat roept ie de destructor helemaal niet aan, maar waarom word de destructor 2x aangeroepen als er maar 1 object is?
[ Bericht 100% gewijzigd door thabit op 29-01-2011 21:11:28 (was te snel) ]
quote:
of ik te laat
Dat is mogelijk en niets om je zorgen over te maken. Bij het kopieren naar de vector is het mogelijk dat er een kopie gemaakt moet worden en dus voor het oude object een destructor aangeroepen wordt. (Sterker nog, aan de code van je kun je zien dat de compiler dit moet doen.) Ook moet een vector zichzelf vaak in geheugen verplaatsen waarbij het kopieen van objecten moet maken en de destructor kan gebruiken, evenals de copy constructor van de klasse (maar dit zou bij 1 object niet moeten gebeuren).quote:
die ~int() was even een dummie voor de vraag, maar ik heb dus zo'n vector<Player> waar maar 1 player instaat en toch word de destructor 2x aangeroepen...
Bijvoorbeeld in het vorige voorbeeld. Als je de pointer in een klasse wikkelt die de geheugenafhandeling doet, hoef je er op dit moment niet meer aan te denken. Anders moet je voor elke klasse die een vector<int*> gebruikt, een destructor, copy constructor en eventueel een operator=() schrijven, terwijl een vector<IntPointer> dit zelf op zou kunnen lossen. Maar opnieuw: dit heeft veel met persoonlijke stijl te maken.quote:tja ik kan het ook in een matrix / array zetten maar dat is weer gekut als je er data aan toe wilt voegen, dan kan dat wel met classes die dan naar het volgende object wijzen maar waarom zou ik dat doen als ik ook gewoon vector<int*> kan gebruiken? en het dan via een destructor kan laten verwijderen
Omdat er 2 Temp-objecten zijn.quote:
code bij mijn vorige post
[ code verwijderd ]
output:
[ code verwijderd ]
en als ik de push_back(Temp()) weglaat roept ie de destructor helemaal niet aan, maar waarom word de destructor 2x aangeroepen als er maar 1 object is?
. Zie je waarom?JA, ik zie het nuquote:
[..]
Omdat er 2 Temp-objecten zijn.
tenminste, omdat ie een copy maakt van de Temp() die ik declareer in de push_back() toch?Dit soort dingen zijn niet te voorkomen zeker?quote:Op zaterdag 29 januari 2011 21:20 schreef thabit het volgende:
Juist. Het zoveelste nadeel van value-typed objecten.
Als je per se wilt dat je vector geen pointers bevat (ik lees net dat references niet mogen), dan vrees ik dat dat lastig gaat worden ja.quote:
[..]
Dit soort dingen zijn niet te voorkomen zeker?
Als je een c++0x-compatible compiler gebruikt, dan moet je dit kunnen voorkomen door met std::move() een r-value-reference mee te geven aan de push_back. Dan wordt er geen kopie gemaakt. De std::vector hoort dit te ondersteunen.quote:
[..]
Dit soort dingen zijn niet te voorkomen zeker?
dus ik ga het dan nu maar op de "nette" manier doen (GS42 ook weer blij
)PS. *int is nog steeds dummie
Dan moet je misschien ook even kijken naar de unique- en shared-pointer (c++0x): http://www.icce.rug.nl/documents/cplusplus/cplusplus18.html#l286quote:
dus ik ga het dan nu maar op de "nette" manier doen (GS42 ook weer blij
Of als je op een oudere compiler zit: http://www.cplusplus.com/reference/std/memory/auto_ptr/
(EDIT: Nu ik de stof nog eens nalees, zie ik dat je de auto_prt niet moet gebruiken in containers (zie eerste link).
Dat kan je weer een klasse schrijven schelen.
[ Bericht 6% gewijzigd door GS42 op 29-01-2011 22:18:07 ]
| 1 2 3 4 5 | struct T_sptr{ Temp *_ptr T_sptr(Temp *pointer):_ptr(pointer){} ~T_sptr(){delete _ptr; _ptr=0;} }; |
alleen hiermee geeft het nog eerder een runtime fout...
Waar gaat wat dan precies fout?quote:
hmm... ik had een simpele struct geschreven
[ code verwijderd ]
alleen hiermee geeft het nog eerder een runtime fout...
Het is ook wat te kort door de bocht voor een pointer class. Als deze struct gekopierd wordt, wordt de _ptr by value gekopierd. Dan wordt het oude object vernietigd. Oftewel: het nieuwe object verwijst naar iets wat niet meer bestaat.quote:
hmm... ik had een simpele struct geschreven
alleen hiermee geeft het nog eerder een runtime fout...
Als je een eigen pointer class wilt schrijven, moet je denken aan de copy constructor, destructor, operator= en eventueel de operator* en operator->. Daarom zijn de stl-pointers ook erg handig:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | #include <iostream> #include <vector> #include <memory> int main() { std::vector< std::unique_ptr<int> > pvect; for (size_t idx = 0; idx < 10; ++idx) pvect.push_back(std::unique_ptr<int>(new int(42))); std::cout << "Adding done." << std::endl; for (size_t idx = 0; idx < 10; ++idx) std::cout << *pvect[idx] << ' '; } |
Let wel dat je compileert met -std=c++0x.
owja, dan hou ik het zelfde probleem natuurlijkquote:
[..]
Het is ook wat te kort door de bocht voor een pointer class. Als deze struct gekopierd wordt, wordt de _ptr by value gekopierd. Dan wordt het oude object vernietigd. Oftewel: het nieuwe object verwijst naar iets wat niet meer bestaat.
Als je een eigen pointer class wilt schrijven, moet je denken aan de copy constructor, destructor, operator= en eventueel de operator* en operator->. Daarom zijn de stl-pointers ook erg handig:
[ code verwijderd ]
Let wel dat je compileert met -std=c++0x.
en als ik nou eens in plaats van een vector een linked list maak?
of is dat moeilijk te realiseren? Ik heb nog nooit zo iets gemaakt namelijk
maar die unique pointer die maakt dan dus een nieuw opject aan als het gekopieerd word?
Sowieso wordt een nieuw object gemaakt, de unique_pointer is namelijk een object. Voor hetgene waar de ptr naar wijst hoeft dit echter niet te gelden. Als het mogelijk is, wordt de move constructor gebruikt waardoor dus geen deep copy nodig is. Dat is hier na te lezen.quote:
maar die unique pointer die maakt dan dus een nieuw opject aan als het gekopieerd word?
Ik verwacht niet dat in een vector kopieen worden gemaakt. Het overzetten naar een linked list hoeft niet moeilijk te zijn, je pakt bijvoorbeeld een list<> container. Maar ik denk niet dat het nodig is in dit geval.
(Het lijkt ondertussen wel alsof ik reclame maak voor de C++ Annotations.
)[ Bericht 67% gewijzigd door GS42 op 29-01-2011 22:29:15 ]
ik gebruik de C++ compiler van mingw (32-bit) maar ik kan nergens vinden of het dat -std=c++0x ondersteund... of hoe ik het aan de compiler moet mee geven, heeft iemand hier ervaring mee?quote:
[..]
Sowieso wordt een nieuw object gemaakt, de unique_pointer is namelijk een object. Voor hetgene waar de ptr naar wijst hoeft dit echter niet te gelden. Als het mogelijk is, wordt de move constructor gebruikt waardoor dus geen deep copy nodig is. Dat is hier na te lezen.
Ik verwacht niet dat in een vector kopieen worden gemaakt. Het overzetten naar een linked list hoeft niet moeilijk te zijn, je pakt bijvoorbeeld een list<> container. Maar ik denk niet dat het nodig is in dit geval.
(Het lijkt ondertussen wel alsof ik reclame maak voor de C++ Annotations.
Als je een nieuwe versie gebruikt van het MinGW pakket, dan wel. Je compiler-versie vind je zo: g++ -vquote:
ik gebruik de C++ compiler van mingw (32-bit) maar ik kan nergens vinden of het dat -std=c++0x ondersteund... of hoe ik het aan de compiler moet mee geven, heeft iemand hier ervaring mee?
En de optie kan je uiteraard op dezelfde manier meegeven. Ik zit op hetzelfde systeem (GCC 4.5.0) en compileer zo: g++ -Wall -std=c++0x -o main -enable-auto-import -O3 main.cc
waarvoor is -wall en auto-import importeert dat alle files in de map waar main staat?quote:
[..]
Als je een nieuwe versie gebruikt van het MinGW pakket, dan wel. Je compiler-versie vind je zo: g++ -v
En de optie kan je uiteraard op dezelfde manier meegeven. Ik zit op hetzelfde systeem (GCC 4.5.0) en compileer zo: g++ -Wall -std=c++0x -o main -enable-auto-import -O3 main.cc
ow hehe ik moet mn compiler maar eens even gaan updaten XD
zit op versie 3.4.5
[ Bericht 5% gewijzigd door netolk op 30-01-2011 09:49:11 ]
De -Wall is een redleijk veelvoorkomende optie die alle warnings (Warnings ALL: Wall) aanzet, waardoor je tijdens het compileren melding krijgt van legale maar mogelijk gevaarlijke dingen (zoals statements die niets doen of het vergelijken van signed met unsigned waarden).quote:
[..]
waarvoor is -wall en auto-import importeert dat alle files in de map waar main staat?
De enable-auto-import heb ik eigenlijk alleen voor MinGW hoeven gebruiken (en dus niet onder Linux), maar zorgt ervoor dat een waarschuwing over het importeren van dll's niet in beeld komt. Volgens mij is dit Windows- (en misschien zelfs MinGW-) specifiek.
Ja, het installeren van MinGW gaat bij mij ook (schijnbaar) willekeurig goed of fout. Al het oude eerst verwijderen (of verplaatsen, ik heb c:/mingw en c:/mingw_old) en dan proberen de getting started te volgen. Toen het eenmaal goed gelukt was, heb ik de map 'mingw' gekopieerd zodat ik deze bij een nieuwe installatie gewoon op een computer kan plakken, zodat ik niet dat hele installatieproces door hoef te lopen. Als het je niet lukt, kan ik je misschien mijn installatie-map (~250mb) wel doorspelen.quote:kut, nu mis ik libgmp-10.dll ... terwijl die wel gewoon op mn pc staat...
Twee dagen geleden ben ik begonnen met het leren van C++. Heb verder eigenlijk geen programmeerervaring, maar het leek me wel interessant. Mijn eerste programma heb ik nu gemaakt en het is enigszins gelukt. Het programma vraagt eerst om hoeveel getallen je bij elkaar wilt optellen, vraagt daarna om de getallen, stopt ze in een array en geeft vervolgens het antwoord. Helaas zit er wel een grote, potentiële error in, en dat is dat wanneer je bij het invoeren van de getallen geen getal invoert. Hierdoor crash hij (natuurlijk), maar ik weet niet hoe ik dmv bijv. een if of do..while die eruit kan vissen. Weten jullie hoe dat moet?
Verder heb ik zojuist geprobeerd om de ingevoerde getallen doubles ipv integers te maken. Dat lukte wel, maar steeds geeft hij op het einde een error. Hij heeft dan al wel de laatste functie uitgevoerd. Ik heb hieronder eerst de add.cpp gepost, en daarna de main.cpp.
SPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44#include "stdafx.h"
#include <iostream>
using namespace std;
void AantalGetallen(int &nAantal)
{
cout << "Hoeveel getallen wilt u bij elkaar optellen?" << endl;
cin >> nAantal;
cout << endl;
}
void Vraag(double *&pnGetallen, int nAantal)
{
for (int iii = 0; iii < nAantal; iii++)
{
cout << "Getal " << iii + 1 << ":\t";
cin >> (pnGetallen[iii]);
}
}
void PrintArray(double *pnGetallen, int nAantal)
{
for (int iii = 0; iii < nAantal; iii++)
cout << pnGetallen[iii] << " ";
}
void Bereken(double *pnGetallen, int nAantal, double &dSom)
{
dSom = 0;
for (int iii = 0; iii < nAantal; iii++)
dSom += pnGetallen[iii];
}
void GeefResultaat(double *pnGetallen, int nAantal, double dSom)
{
for (int iii = 0; iii < nAantal; iii++)
{
cout << pnGetallen[iii];
if (iii < nAantal - 1)
cout << " + ";
}
cout << " = " << dSom << endl << endl;
}
Verder heb ik ervoor gekozen om zoveel kleine functies te gebruiken, omdat ik het dan makkelijker kan uitbreiden en het overzichtelijker blijft.SPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "stdafx.h"
#include <iostream>
#include "add.h"
using namespace std;
int main()
{
int nAantal;
AantalGetallen(nAantal);
double *pnGetallen = new double;
Vraag(pnGetallen, nAantal);
double dSom;
Bereken(pnGetallen, nAantal, dSom);
GeefResultaat(pnGetallen, nAantal, dSom);
return 0;
}
Als iemand tips heeft over hoe ik mijn programma op wat voor gebied dan ook kan verbeteren zou ik het graag horen.
Kun je iets specifieker zijn in de foutmeldingen etc?quote:
Goedemiddag,
Twee dagen geleden ben ik begonnen met het leren van C++. Heb verder eigenlijk geen programmeerervaring, maar het leek me wel interessant. Mijn eerste programma heb ik nu gemaakt en het is enigszins gelukt. Het programma vraagt eerst om hoeveel getallen je bij elkaar wilt optellen, vraagt daarna om de getallen, stopt ze in een array en geeft vervolgens het antwoord. Helaas zit er wel een grote, potentiële error in, en dat is dat wanneer je bij het invoeren van de getallen geen getal invoert. Hierdoor crash hij (natuurlijk), maar ik weet niet hoe ik dmv bijv. een if of do..while die eruit kan vissen. Weten jullie hoe dat moet?
Verder heb ik zojuist geprobeerd om de ingevoerde getallen doubles ipv integers te maken. Dat lukte wel, maar steeds geeft hij op het einde een error. Hij heeft dan al wel de laatste functie uitgevoerd. Ik heb hieronder eerst de add.cpp gepost, en daarna de main.cpp.SPOILER[ code verwijderd ]Verder heb ik ervoor gekozen om zoveel kleine functies te gebruiken, omdat ik het dan makkelijker kan uitbreiden en het overzichtelijker blijft.SPOILER[ code verwijderd ]
Als iemand tips heeft over hoe ik mijn programma op wat voor gebied dan ook kan verbeteren zou ik het graag horen.
Een std::vector kan handig zijn als je met arrays wilt werken van variabele lengte.
Verder kun je in plaats van met references als argumenten te werken, de berekende waarde ook als uitkomst meegeven dus, bijvoorbeeld, int AantalGetallen() ipv void AantalGetallen(int &nAantal).
Oeh, een excuus om ongegeneerd te gaan muggenziften.quote:Als iemand tips heeft over hoe ik mijn programma op wat voor gebied dan ook kan verbeteren zou ik het graag horen.
Je gebruikt voor elk getal een int. Opzich niets mis mee, maar een int kan ook negatief zijn. In veel getallen is een negatieve waarde geen valide waarde, bijvoorbeeld als je vraagt hoeveel getallen ingelezen moeten worden of als de index van een for-loop. In dit geval kun je beter het 'type' size_t gebruiken, dat in C(++) gebruikt wordt voor een 'size', oftewel een aantal of grootte dat niet negatief kan zijn. ('Type' staat hier tussen aanhalingstekens omdat het een typedef is voor een unsigned int en geen basistype.)
Je gebruikt een postfix increment in de for-loops: idx++. Wederom opzich niets mis mee, behalve dat idx++ een extra operatie uitvoert vergeleken met ++idx. (Lees het verschil maar eens ergens.) Een nette for-loop is dus als volgt:
| 1 | for (size_t idx = 0; idx < 10; ++idx) |
Ik weet niet of het een typefout betreft, maar de declaratie
| 1 | void Vraag(double *&pnGetallen, int nAantal) |
...is raar, omdat je een referentie naar een pointer doorgeeft. Ik kan me niet voorstellen dat dat de bedoeling was.
De main() functie van C++ hoeft geen return-waarde te hebben; als deze er niet is, wordt '0' teruggegeven. Je laatste statement in de main is dus nutteloos.
Iets gevaarlijks wat je doet is het volgende:
| 1 | double *pnGetallen = new double; |
De operator new() alloceert geheugen buiten de stack en alles wat met new aangemaakt wordt, moet ook met delete verwijderd worden. Als je een pointer naar een double mee wilt geven, gebruik je daarvoor de &-operator:
| 1 2 | double d = 3.14; double *d_ptr = &d; |
Pas als je werkelijk geheugen dynamisch wilt alloceren, gebruik je de operator new.
Ik ken de headerfile "stdafx.h" ook niet: weet je zeker dat je die nodig hebt?
Voor invoercontrole kan je het uitlees-statement evalueren:
| 1 2 3 4 5 6 7 8 9 10 11 | #include <iostream> int main() { size_t input; std::cout << "Voer een (positief) getal in: "; if (std::cin >> input) std::cout << "Uw getal is " << input << '\n'; else std::cout << "Verkeerde invoer.\n"; } |
Hopelijk heb ik je niet afgeschrikt.
[ Bericht 0% gewijzigd door GS42 op 30-01-2011 17:04:15 ]
hmm die -wall deed ie hoe dan ook altijd al bij mij, maar krijg die mingw echt niet reďnstalleerd...quote:
[..]
De -Wall is een redleijk veelvoorkomende optie die alle warnings (Warnings ALL: Wall) aanzet, waardoor je tijdens het compileren melding krijgt van legale maar mogelijk gevaarlijke dingen (zoals statements die niets doen of het vergelijken van signed met unsigned waarden).
De enable-auto-import heb ik eigenlijk alleen voor MinGW hoeven gebruiken (en dus niet onder Linux), maar zorgt ervoor dat een waarschuwing over het importeren van dll's niet in beeld komt. Volgens mij is dit Windows- (en misschien zelfs MinGW-) specifiek.
[..]
Ja, het installeren van MinGW gaat bij mij ook (schijnbaar) willekeurig goed of fout. Al het oude eerst verwijderen (of verplaatsen, ik heb c:/mingw en c:/mingw_old) en dan proberen de getting started te volgen. Toen het eenmaal goed gelukt was, heb ik de map 'mingw' gekopieerd zodat ik deze bij een nieuwe installatie gewoon op een computer kan plakken, zodat ik niet dat hele installatieproces door hoef te lopen. Als het je niet lukt, kan ik je misschien mijn installatie-map (~250mb) wel doorspelen.
eens even kijken hoe het met manual install gaatDe error die ik kreeg nadat ik van enkele ints doubles had gemaakt (zodat ik ook 0.66 + 0.33 kon doen etc.):SPOILER
Verder leek het me juist handig om voids te gebruiken, zodat ik geen hele functies in functies hoefde in te voeren? (zoals GeefResultaat(Vraag(AantalGetallen(), AantalGetallen(), Bereken(Vraag(AantalGetallen), AantalGetallen(), ... etc.SPOILER
bij mij ook niet...quote:
@GS42, handmatig installeren is al helemaal niet te doen..
zou ik jou mingw mapje mogen hebben?Je kan ook iets doen als n = AantalGetallen() ipv Aantalgetallen(n)quote:
De error wanneer je geen getal invoert:De error die ik kreeg nadat ik van enkele ints doubles had gemaakt (zodat ik ook 0.66 + 0.33 kon doen etc.):SPOILER[ afbeelding ]Verder leek het me juist handig om voids te gebruiken, zodat ik geen hele functies in functies hoefde in te voeren? (zoals GeefResultaat(Vraag(AantalGetallen(), AantalGetallen(), Bereken(Vraag(AantalGetallen), AantalGetallen(), ... etc.SPOILER[ afbeelding ]
Ah, uiteraard. Zou hier niet bijvoorbeeld ook een simpele unsigned int toepasbaar zijn? Size(_t) ken ik niet, maar zoals u (jij?) het beschrijft lijkt het me dezelfde eigenschappen hebben als een unsigned int.quote:
[..]
Oeh, een excuus om ongegeneerd te gaan muggenziften.
Je gebruikt voor elk getal een int. Opzich niets mis mee, maar een int kan ook negatief zijn. In veel getallen is een negatieve waarde geen valide waarde, bijvoorbeeld als je vraagt hoeveel getallen ingelezen moeten worden of als de index van een for-loop. In dit geval kun je beter het 'type' size_t gebruiken, dat in C(++) gebruikt wordt voor een 'size', oftewel een aantal of grootte dat niet negatief kan zijn. ('Type' staat hier tussen aanhalingstekens omdat het een typedef is voor een unsigned int en geen basistype.)
kan het niet allebei? Dus ofwel dat je doet:quote:
e gebruikt een postfix increment in de for-loops: idx++. Wederom opzich niets mis mee, behalve dat idx++ een extra operatie uitvoert vergeleken met ++idx. (Lees het verschil maar eens ergens.) Een nette for-loop is dus als volgt:
[ code verwijderd ]
| 1 | for (size_t iii = 0; iii < 10; ++iii) |
| 1 | for (size_t iii = 0; iii <= 10; iii++) |
Overigens dacht ik dat bij ++iii je nooit iii = 0 krijgt?
Ik heb deze *&pnGetallen gedaan, zodat ik de Array pnGetallen kon bewerken in de void? Moet dat anders/doe ik het niet goed?quote:
Ik weet niet of het een typefout betreft, maar de declaratie
[ code verwijderd ]
...is raar, omdat je een referentie naar een pointer doorgeeft. Ik kan me niet voorstellen dat dat de bedoeling was.
Oke, bedankt voor de informatie, dat wist ik niet.quote:
De main() functie van C++ hoeft geen return-waarde te hebben; als deze er niet is, wordt '0' teruggegeven. Je laatste statement in de main is dus nutteloos.
Ik wil ook dynamisch alloceren, omdat de grootte van de array nog niet bepaald is, toch? Ik moet volgens mij wel sowieso nadat ik met new een array heb gemaakt, even delete[] pnArray doen, toch? Of gaat dat vanzelf wanneer het programma afsluit?quote:
Iets gevaarlijks wat je doet is het volgende:
[ code verwijderd ]
De operator new() alloceert geheugen buiten de stack en alles wat met new aangemaakt wordt, moet ook met delete verwijderd worden. Als je een pointer naar een double mee wilt geven, gebruik je daarvoor de &-operator:
[ code verwijderd ]
Pas als je werkelijk geheugen dynamisch wilt alloceren, gebruik je de operator new.
Die is volgens mij nodig voor de compiler die ik gebruik (Microsoft Visual C++ 2010 Express)quote:
Ik ken de headerfile "stdafx.h" ook niet: weet je zeker dat je die nodig hebt?
Oke, hierbij is dus input per definitie bijv. een int, en als de invoer geen int is geeft hij een error/kan je er iets mee doen? Bedankt.quote:
Voor invoercontrole kan je het uitlees-statement evalueren:
[ code verwijderd ]
Zeker niet, altijd goed om verbeterpunten te zien. Bedankt.quote:
dat klopt idd je kan beide methode gebruiken...quote:
Ah, uiteraard. Zou hier niet bijvoorbeeld ook een simpele unsigned int toepasbaar zijn? Size(_t) ken ik niet, maar zoals u (jij?) het beschrijft lijkt het me dezelfde eigenschappen hebben als een unsigned int.
kan het niet allebei? Dus ofwel dat je doet:
Alleen weetje met size_t zeker dat je getal altijd groot genoeg kan worden
Dit kan je zelf heel eenvoudig checken hč...quote:Overigens dacht ik dat bij ++iii je nooit iii = 0 krijgt?
| 1 2 3 4 | #include <iostream> for(int i = 0; i < 10; ++i){ std::cout << i << std::endl; } |
Je moet delete altijd aanroepen anders kan je geheugenleaks krijgenquote:Ik wil ook dynamisch alloceren, omdat de grootte van de array nog niet bepaald is, toch? Ik moet volgens mij wel sowieso nadat ik met new een array heb gemaakt, even delete[] pnArray doen, toch? Of gaat dat vanzelf wanneer het programma afsluit?
compiled die niet ook gewoon zonder die include?quote:Die is volgens mij nodig voor de compiler die ik gebruik (Microsoft Visual C++ 2010 Express)
Oke, ik zal dus wanneer ik ze nodig heb in statements ++i gebruiken. Bedankt.quote:
Het verschil tussen ++i en i++ is als volgt. Beide expressies verhogen i met 1, maar het zijn ook expressies met een waarde. ++i heeft als waarde i na de verhoging, en i++ heeft als waarde i voor de verhoging. Omdat je de expressie alleen maar als statement gebruikt, zal de compiler de waarde volkomen negeren, i++ en ++i zijn in dit geval precies hetzelfde. Maar als i een of ander class-object is waarvoor beide operatoren gedefinieerd zijn, dan zal i++ net iets meer tijd kosten om uit te voeren omdat-ie de oude waarde moet returnen ipv de nieuwe.
Size_t past zich dan ook aan aan de invoer? Want waarom zou je dan überhaupt nog ooit int gebruiken?quote:
[..]
dat klopt idd je kan beide methode gebruiken...
Alleen weetje met size_t zeker dat je getal altijd groot genoeg kan worden
Oke, bedankt. Gedaan.quote:
Je moet delete altijd aanroepen anders kan je geheugenleaks krijgen
Nee, ik heb het geprobeerd, maar ik krijg dan de volgende error:quote:
compiled die niet ook gewoon zonder die include?
1>c:\*\add.cpp(1): warning C4627: '#include <iostream>': skipped when looking for precompiled header use
Links naar de afbeeldingen:
http://img412.imageshack.us/f/errorc2.jpg/
Error wanneer ik 'A' invul.
http://img821.imageshack.us/i/errorc3.jpg/
Error nadat ik gewone getallen heb ingevuld..
| 1 2 3 4 | size_t nAantal; AantalGetallen(nAantal); double *pnGetallen = new double[nAantal]; |
ja, idd maar waarom maak je je AantalGetallen functie niet gewoon zo?quote:
Oh, bedankt, dat is een vrij opzichtige fout. Wel erg makkelijk te herstellen.. simpelweg door te schrijven:
[ code verwijderd ]
| 1 2 3 4 5 6 7 | size_t AantalGetallen(){ size_t nAantal=0; cout << "Hoeveel getallen wilt u bij elkaar optellen?" << endl; cin >> nAantal; cout << endl; return nAantal; } |
dan kan je het gewoon zo schrijven:
| 1 | double *pnGetallen = new double[AantalGetallen()]; |
Sterker nog:quote:
Het verschil tussen ++i en i++ is als volgt. Beide expressies verhogen i met 1, maar het zijn ook expressies met een waarde. ++i heeft als waarde i na de verhoging, en i++ heeft als waarde i voor de verhoging. Omdat je de expressie alleen maar als statement gebruikt, zal de compiler de waarde volkomen negeren, i++ en ++i zijn in dit geval precies hetzelfde. Maar als i een of ander class-object is waarvoor beide operatoren gedefinieerd zijn, dan zal i++ net iets meer tijd kosten om uit te voeren omdat-ie de oude waarde moet returnen ipv de nieuwe.
_asm { inc i }
is sneller dan:
++i;
wat zich vertaalt naar:
mov eax, dword ptr [i]
add eax, 1
move dword ptr [i], eax
Maar het eerste is wel minder platform onafhankelijk en het werkt alleen op primitieve typen.
Als je 'm laat optimaliseren voor snelheid dan waarschijnlijk wel. Bij mij wordt add eax, 1 wel veranderd in inc eax. De reden dat-ie nog wel eerst mov eax, dword ptr [i] doet is omdat eax wordt gebruikt als parameter bij het aanroepen van printf. eax wordt dus eerst gepusht op de stack en dan opgeslagen in het geheugen met mov dword ptr [i], eax, voordat de call naar printf plaats vindt.quote:
Het lijkt me toch dat een compiler dat nog wel moet kunnen optimaliseren.
[ Bericht 1% gewijzigd door DemonRage op 30-01-2011 18:42:45 ]
Wat nette code betreft, klopt dit, maar als antwoord op de vraag: als je programma termineert wordt gealloceerd geheugen wel teruggeven aan het OS, dus je verliest nooit geheugenruimte. (Wel kan het zijn dat destrcutors niet aangeroepen worden waarin je iets belangrijks doet (port sluiten, bestand schrijven), dus altijd delete-en, maar het geheugen zelf wordt teruggegeven.)quote:Je moet delete altijd aanroepen anders kan je geheugenleaks krijgen
Hier ligt waarschijnlijk ook je buffer overflow probleem: je alloceert geen array, je alloceert een (1) double. Arrays alloceer je met operator new[], die ook een lengte verwacht. Als je alleen new gebruikt, alloceer je slechts ruimte voor 1 double. Details zijn bijvoorbeeld hier te vinden.quote:Ik wil ook dynamisch alloceren, omdat de grootte van de array nog niet bepaald is, toch? Ik moet volgens mij wel sowieso nadat ik met new een array heb gemaakt, even delete[] pnArray doen, toch? Of gaat dat vanzelf wanneer het programma afsluit?
Edit: Oh, ik zie dat je dat al had gevonden. Naja.
[ Bericht 5% gewijzigd door GS42 op 30-01-2011 19:03:54 ]
Zal wel komen doordat printf een int als returnwaarde heeft en die worden doorgaans in eax doorgegeven.quote:
[..]
Als je 'm laat optimaliseren voor snelheid dan waarschijnlijk wel. Bij mij wordt add eax, 1 wel veranderd in inc eax. De reden dat-ie nog wel eerst mov eax, dword ptr [i] doet is omdat eax wordt gebruikt als parameter bij het aanroepen van printf. eax wordt dus eerst gepusht op de stack en dan opgeslagen in het geheugen met mov dword ptr [i], eax, voordat de call naar printf plaats vindt.
Nee, het is sneller om eax meteen te gebruiken dan om de waarde van i na de optelling uit het geheugen te plukken, want in eax zit dan toch al het resultaat van de optelling.quote:
[..]
Zal wel komen doordat printf een int als returnwaarde heeft en die worden doorgaans in eax doorgegeven.
(het gaat nog steeds om code die vóór de aanroep van printf uitgevoerd wordt)Zoiets zou ik ook kunnen doen, ja, maar mij lijkt dat minder praktisch. Dit omdat ik meerdere keren AantalGetallen() zou moeten gebruiken en hij hem dus ook meerdere keren activeert. Om dit te voorkomen zou ik er een variabele aan toe kunnen schrijven, maar dan heb je uiteindelijk meer code. Maar misschien zit ik fout, en is die andere manier toch sneller. Wel zou ik dan graag weten hoe ik kan voorkomen dat AantalGetallen() steeds opnieuw uitgevoerd wordt, zonder er een variabele aan toe te schrijven.. Tenzij een variabele eraan toeschrijven uiteindelijk toch nog sneller is dan de manier die ik al heb beschreven.quote:
[..]
ja, idd maar waarom maak je je AantalGetallen functie niet gewoon zo?
[ code verwijderd ]
dan kan je het gewoon zo schrijven:
[ code verwijderd ]
en wat is het probleem dat je een functie vaker gebruikt?quote:
[..]
Zoiets zou ik ook kunnen doen, ja, maar mij lijkt dat minder praktisch. Dit omdat ik meerdere keren AantalGetallen() zou moeten gebruiken en hij hem dus ook meerdere keren activeert. Om dit te voorkomen zou ik er een variabele aan toe kunnen schrijven, maar dan heb je uiteindelijk meer code. Maar misschien zit ik fout, en is die andere manier toch sneller. Wel zou ik dan graag weten hoe ik kan voorkomen dat AantalGetallen() steeds opnieuw uitgevoerd wordt, zonder er een variabele aan toe te schrijven.. Tenzij een variabele eraan toeschrijven uiteindelijk toch nog sneller is dan de manier die ik al heb beschreven.
Alles in een functie word opnieuw "aangemaakt" als je de functie aanroept, dus je variabele word gewoon opnieuw gemaakt.
ik volg even niet helemaal wat je bedoelt met voorkomen dat ie steeds opnieuw uitgevoerd word...
Als je die functie maar 1 x aanroept word ie ook maar 1x uitgevoerd (tenzij je een loop maakt)
maar als je 1x een getal wilt invullen en dan met dat getal allemaal dingen wilt doen kun je beter 1 variabele maken en daar je ingevulde getal in opslaan...
| 1 2 3 4 5 6 7 8 9 10 11 | #include <iostream> int main(){ size_t getal; std::cout << "Vul een getal in.\t" std::cin >> getal; std::cout << std::endl; // hier dingen doen met dat getal return 0; } |
| 1 | size_t AantalGetallen = AantalGetallen() |
qua snelheid maakt het denk ik niet merkbaar wat uit, als je via referenties (&) iets aan een functie door geeft kost dat volgens mij wel minder geheugen (verbeter me als dit niet klopt)quote:
Ja, dat is inderdaad wat ik wil. Maar ik wil dat niet in de main() doen, dus heb ik 2 opties: of ik voer de functie uit en schrijf iets van:
[ code verwijderd ]
of ik gebruik degene die ik al heb laten zien, waarin ik eerst een variabele maak, die meegeef aan een void die hem vervolgens verandert. Ik weet niet welke sneller is?
maar waarom wil je dit niet in de main doen dan? want dit is niet zo'n groot programma dus blijft het wel overzichtelijk... (tenzij je dit als oefening doet dan heb ik niks gezegd)
Ik ben nog niet zo lang bezig (2 dagen 
) en ik had dit programma vooral geschreven om te proberen de pointers en referenties toe te passen met arrays ed. Toch bedankt. ahh, ik snapquote:
Jep, ik doe dit allemaal als een oefening.
Het zijn hele handige dingen maar je moet zorgen dat je voor elke new ook een delete uitvoert vanwege de geheugen leaks... en dat is soms nog best lastig...
In C(++) is een array in principe een (const) pointer. Als je een int[5] aan een functie doorgeeft, kan je die opvangen als int*. Hierbij weet de functie de lengte van de array niet, dus wordt deze vaak als extra argument meegegeven. (De main functie, int main(int argc, char **argv) {} is hier een voorbeeld van.) Je kunt in jouw code de reference (&) dus gewoon weglaten: een reference naar een pointer is nooit nodig - ik kan ten minste geen nut verzinnen.quote:Ik heb deze *&pnGetallen gedaan, zodat ik de Array pnGetallen kon bewerken in de void? Moet dat anders/doe ik het niet goed?
In vrijwel elke implementatie is 'size_t' identiek aan 'unsigned int' en heeft dus geen speciale eigenschappen, het is een typedef voor een basistype en past zich niet aan aan de invoer. Je kunt er echter niet vanuit gaan dat size_t gelijk is aan unsigned int, omdat dit niet in de standaard staat. Veel stl-functies geven size_t's terug (std::string::length() en std::string::find(), bijvoorbeeld). Om deze op te vangen is het beter een size_t te gebruiken omdat je dan gegarandeerd het goede type hebt: als je deze immers in een unsigned int opvangt, hoop je maar dat dit hetzelfde is.quote:Size_t past zich dan ook aan aan de invoer? Want waarom zou je dan überhaupt nog ooit int gebruiken?
Je wordt dus min of meer gedwongen om size_t voor afstandsmaten te gebruiken: zo garandeer je maximale portability van je code. En waarom ook niet? Het is minder typewerk en heeft geen overhead...
En natuurlijk wil je soms wel een int gebruiken, bijvoorbeeld als negatieve waarden ook mogelijk zijn. Je wilt nooit de buitentemperatuur in een size_t zetten, maar een array-index wel. Als negatieve waarden geen (valide) betekenis in je variabele hebben, gebruik je size_t.
Ik denk niet dat het in dit geval iets uitmaakt. Een return-by-argument heeft de overhead van het maken en dereferencen van een pointer. Een standaard return moet in principe een kopie maken van het object dat hij teruggeeft. (Dit gebeurt in de praktijk zelden, elke hedendaagse compiler past indien mogelijk copy elision toe, waardoor er geen kopie gemaakt wordt.) Dus ook qua geheugengebruik verwacht ik geen merkbaar verschil.quote:qua snelheid maakt het denk ik niet merkbaar wat uit, als je via referenties (&) iets aan een functie door geeft kost dat volgens mij wel minder geheugen (verbeter me als dit niet klopt)
Oke, ik had hier gelezen dat je ze wel kunt gebruiken om de waarden van pointers te veranderen binnen functies, maar ik heb inderdaad eens geprobeerd om de reference weg te laten en het werkte. Bedankt.quote:
[..]
In C(++) is een array in principe een (const) pointer. Als je een int[5] aan een functie doorgeeft, kan je die opvangen als int*. Hierbij weet de functie de lengte van de array niet, dus wordt deze vaak als extra argument meegegeven. (De main functie, int main(int argc, char **argv) {} is hier een voorbeeld van.) Je kunt in jouw code de reference (&) dus gewoon weglaten: een reference naar een pointer is nooit nodig - ik kan ten minste geen nut verzinnen.
[..]
Wel vraag ik me af of je nu altijd dat kunt weglaten, of dat dat alleen bij een array zo is? Of is het hier zo van array = pointer. Maar een size_t 'reserveert' dus eigenlijk dubbel zoveel ruimte als een int? Of is dat alleen omdat het niet negatief kan gaan?quote:
Je wordt dus min of meer gedwongen om size_t voor afstandsmaten te gebruiken: zo garandeer je maximale portability van je code. En waarom ook niet? Het is minder typewerk en heeft geen overhead...
Verder had ik nog een vraag: met betreft het eruit filteren van tekst in plaats van getallen heb ik geprobeerd een beroep te doen op de isnan() functie. Ik had gehoord dat die in de <math.h> stond, maar wanneer ik dit heb zegt hij nog steeds dat isnan een undefined identifier is..
| 1 2 | #include <math.h> if (isnan('test')); |
Bij arrays is een reference niet nodig, bij basic types en classes is deze (of een pointer) wel nodig als je de waarde van de variabele in de functie wilt veranderen. Het geldt niet helemaal dat array == pointer, maar nadat de array opgevangen is door een functie wel (binnen de functie). Het verschil tussen een array en een pointer is dat je een pointer een nieuwe waarde kunt geven en een array-naam niet. Dus:quote:Wel vraag ik me af of je nu altijd dat kunt weglaten, of dat dat alleen bij een array zo is? Of is het hier zo van array = pointer.
| 1 2 3 4 | int arr[3] = {1, 2, 3}; // Maak array van 3 elementen int *ptr = arr; // Maak pointer die naar begin van array wijst ++ptr; // Zet pointer op tweede element van array ++arr; // ILLEGAAL! Waarde van 'arr' ligt vast en kan niet veranderd worden |
Daar is dus niets over te zeggen: dat is implementatieafhankelijk. Natuurlijk kan een unsigned int een hogere waarde bevatten dan een signed int, maar dat is omdat het bereik anders gebruikt wordt.quote:Maar een size_t 'reserveert' dus eigenlijk dubbel zoveel ruimte als een int?
Niet gebruiken. Dit is een twijfelachtige functie (of soms erger: macro) die niet in de standaard zit. Misschien werkt 'ie wel, misschien werkt 'ie anders dan je verwacht, misschien is 'ie niet aanwezig. Je kan input controleren met de evaluatie waar we het over gehad hebben, en een divide-by-zero (die 'inf' op zou moeten leveren ipv. 'nan') moet je zelf afvangen door te controleren of de noemer nul is.quote:Verder had ik nog een vraag: met betreft het eruit filteren van tekst in plaats van getallen heb ik geprobeerd een beroep te doen op de isnan() functie
Google is je vriend...quote:
[ code verwijderd ]
Hoe kan ik hem wel werkende krijgen?
http://en.wikipedia.org/wiki/Math.h
Zoals blijkt bestaat de functie 'isnan' helemaal niet... enkel 'nan' bestaat.
Verder zou ik eens kijken naar:
http://en.wikibooks.org/wiki/Subject:C_programming_language
en
http://en.wikibooks.org/wiki/Subject:C%2B%2B_programming_language
Je kan beter std::isalpha gebruiken om te kijken of het een teken is deze functie staat gedeclareerd in de <cctype> headerquote:
Verder had ik nog een vraag: met betreft het eruit filteren van tekst in plaats van getallen heb ik geprobeerd een beroep te doen op de isnan() functie. Ik had gehoord dat die in de <math.h> stond, maar wanneer ik dit heb zegt hij nog steeds dat isnan een undefined identifier is..
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 | int input; for (;;) { std::cout << "Voer een getal tussen -10 en 10 in: "; if ( (std::cin >> input) ) { if (input >= -10 && input <= 10) break; } else { std::cin.clear(); // clear error state char dump[255]; std::cin.getline(dump, 255); // Discard cin buffer } } std::cout << "Het getal is " << input << ".\n"; |
De truc is dat als lezen uit std::cin faalt, er een error flag in het object wordt geset, en je deze dus eerst moet resetten en de tekens (die blijkbaar geen cijfers zijn) uit moet lezen. Met cin.clear() reset je alle error flags en met een cin.getline() (bijvoorbeeld, er zijn andere mogelijkheden) kan je willekeurige tekens uitlezen en weggooien.
Alleen als je de juiste invoer hebt, laat je de gebruiker uit de loop komen.
Op deze manier lees je maximaal 255 characters uit de istream. Als je maximaal x characters wilt, kan je dat doen met char dump[x]. Als je x wilt laten bepalen door de gebruiker, dan kan je inderdaad dynamisch alloceren of x/n keer n chars uitlezen en deze in een string opslaan.quote:Wel vraag ik me nu af hoe je gewoon een x aantal characters kunt aflezen en weggooien en dat je dus niet afhankelijk bent van of de gebruiker meer of minder dan 255 karakters intypt.
Wat je je echter moet realiseren, is dat je niet weet hoeveel characters er in een istream buffer staan en je dus niet van tevoren dynamisch kunt alloceren op basis daarvan. Daarnaast wordt input alleen naar std::cin gestuurd na een enter, dus je kunt geen individuele characters uitlezen op het moment dat ze getypt worden (normaal gesproken dan; er zijn os-specifieke oplossingen die het wel kunnen, zoals curses).
Voor het negeren van een deel van het buffer bestaat ook nog istream::ignore, misschien dat je daar wat aan hebt. Deze kan je een te negeren lengte meegeven en een stop-byte.
Ik zie eigenlijk nooit code waar bijvoorbeeld dingen uit de std namespace zo benadert worden, met andere namespaces zie ik dat weer wel.
Wat is je vraag precies?quote:Op zaterdag 5 februari 2011 19:35 schreef nightsleeper het volgende:
Hoe kan ik het beste omgaan met namespaces? Stel ik heb twee namespaces, en ik wil in de ene namespace iets van de andere namespace pakken, dan kan ik :: voor de naam zetten, het werkt echter ook zonder.
Ik zie eigenlijk nooit code waar bijvoorbeeld dingen uit de std namespace zo benadert worden, met andere namespaces zie ik dat weer wel.
Je kunt niet zomaar iets uit een namespace pakken zonder óf de scope resolution operator (::) te gebruiken óf een using-directive (using namespace std) te op te geven. Je kunt dus niet zomaar vanuit de ene namespace iets uit een andere gebruiken.quote:Hoe kan ik het beste omgaan met namespaces? Stel ik heb twee namespaces, en ik wil in de ene namespace iets van de andere namespace pakken, dan kan ik :: voor de naam zetten, het werkt echter ook zonder.
Wél kun je in een namespace dingen gebruiken die in de global scope gedefinieerd zijn:
| 1 2 3 4 5 6 7 8 9 10 | #include <iostream> #include <cmath> namespace X { double y = cos(0); }; int main() { std::cout << X::y << '\n'; } |
Je ziet hier dat in de namespace X de globale functie cos() aangeroepen kan worden. Dit kan op deze manier, of met ::cos() omdat de lege scope resultion operator verwijst naar de globale namespace. Als je echter een conflicterende functie in je namespace hebt, kan de :: nodig zijn voor de juiste aanroep:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | #include <iostream> #include <cmath> namespace X { double cos(double in) { return 42; }; double y = cos(0); double z = ::cos(0); }; int main() { std::cout << X::y << ", " << X::z << '\n'; } |
Hier krijg je de uitvoer: 42, 1
Soms gebeurt het dat je in je namespace een conflict hebt met een globale functie, waardoor je de scope resolution nodig hebt. Ik hoop dat dit je vraag beantwoordt; zoniet zal je deze moeten verduidelijken.
[ Bericht 0% gewijzigd door GS42 op 05-02-2011 21:52:56 ]
Stel, ik heb namespace a en namespace b. In namespace a wil ik de variabele blabla van namespace b gebruiken, dan kan ik ::b::blabla doen, maar b::blabla werkt ook.quote:
Ik zie mensen vanuit namespaces ook nooit ::std::iets doen, maar bij andere namespaces wordt dat weer wel gedaan.
Gegeven wat ik hierboven schrijf, kan dat - denk ik - twee redenen hebben. Ten eerste is het gebruik van de lege scope resolution operator alleen in geval van ambiguiteit noodzakelijk, en niemand zal zelf een namespace std maken. Daarnaast wordt de lege operator ook wel gebruikt om duidelijk aan te geven dat iets uit de globale namespace komt, dus niet omdat het programmeertechnisch nodig is maar om te verduidelijken waar een object vandaan komt. Dit is niet nodig bij de std-namespace omdat iedereen weet waat deze zich bevindt.quote:Ik zie mensen vanuit namespaces ook nooit ::std::iets doen, maar bij andere namespaces wordt dat weer wel gedaan.
De taal C(++) biedt zelf geen threading functionaliteit, maar Win32 biedt hier bijvoorbeeld wel een API voor. En inderdaad, vergeleken met bijv. .NET is Win32 threading niet grappig.quote:
Je zou met threads kunnen werken, maar dat is in C++ een crime.
Zie bijvoorbeeld hier en hier voor uitleg.
maar het komt er dus op neer dat een nieuwe aanvraag word doorverwezen naar een nieuwe threat en een andere poort?
Het is mogelijk om het niet multi-threaded te doen maar alles gewoon in 1 thread af te handelen. Hiertoe zet je alle sockets op non-blocking en sla je alle connecties op in een std::vector<Client>.quote:
is hier iemand bekent met sockets??? ik snap niet goed hoe ik een server meerdere connecties kan laten hebben. [...] Iemand enig idee hoe ik dit zou kunnen maken?
Algemene aanpak: eerst loop je door alle clients heen en lees je alle gestuurde gegevens. En hierna kijk je of er toevallig nieuwe clients zijn die een connectie willen.
Alle clients afhandelen kan het beste door gebruik te maken van een fd_set i.c.m een select() aanroep. Hiermee kan je in 1 keer controleren of er clients zijn die data hebben gestuurd en áls die er zijn, welke clients data hebben gestuurd. Hierdoor hoef je niet elke client met een timeout uit te lezen. Als er data is, loop je alle clients langs en controleer je via de df_set of een client data heeft gestuurd. Als dat zo is, kan je gewoon read()'en.
Nieuwe clients accepteren gaat zoals je gewend bent met accept(); omdat deze op non-blocking staat faalt deze direct (met EAGAIN) als er geen clients zijn, waardoor je direct door kan gaan. Als er wel een client is, accepteer je deze, zet je de verbinding op non-blocking en voeg je de client toe aan je vector.
Als je op fd_set zoekt, vind je vast wel voorbeelden.
Ik zou trouwens boost::thread gebruiken, veel makkelijker ook.
kijk dit klinkt beterquote:
[..]
Het is mogelijk om het niet multi-threaded te doen maar alles gewoon in 1 thread af te handelen. Hiertoe zet je alle sockets op non-blocking en sla je alle connecties op in een std::vector<Client>.
Algemene aanpak: eerst loop je door alle clients heen en lees je alle gestuurde gegevens. En hierna kijk je of er toevallig nieuwe clients zijn die een connectie willen.
Alle clients afhandelen kan het beste door gebruik te maken van een fd_set i.c.m een select() aanroep. Hiermee kan je in 1 keer controleren of er clients zijn die data hebben gestuurd en áls die er zijn, welke clients data hebben gestuurd. Hierdoor hoef je niet elke client met een timeout uit te lezen. Als er data is, loop je alle clients langs en controleer je via de df_set of een client data heeft gestuurd. Als dat zo is, kan je gewoon read()'en.
Nieuwe clients accepteren gaat zoals je gewend bent met accept(); omdat deze op non-blocking staat faalt deze direct (met EAGAIN) als er geen clients zijn, waardoor je direct door kan gaan. Als er wel een client is, accepteer je deze, zet je de verbinding op non-blocking en voeg je de client toe aan je vector.
Als je op fd_set zoekt, vind je vast wel voorbeelden.
ik heb nu dit simpele progje gemaakt
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | #include <iostream> #include <windows.h> unsigned long WINAPI Threader(void *Data){ int i = 0; while(true){ std::cout << "Threader:\t" << i++ << '\n'; Sleep(500); } } int main(){ std::cout << "Start of program\n"; HANDLE Thread = CreateThread(0,0,Threader,0,0,0); Sleep(5000); std::cout << "Main:\tMiddel in the run\n"; getchar(); CloseHandle(Thread); return 0; } |
Ik vroeg me af wat WINAPI doet, als ik het weg laat dan kan ie Dword (*)(void*) niet converteren naar Dword (*)(void*)... weet iemand wat het precies doet?
WINAPI vertelt de compiler hoe de functie argumenten krijgt en returnt en hoe de functie gelinkt moet worden en dergelijke, voor systeemfuncties zoals threads is dat anders dan hoe het standaard in C++ functioneert.quote:
ik ben nu een beetje aan het klooien met threads, die kunnen zeker niet cross-platform geschreven worden?
ik heb nu dit simpele progje gemaakt
[ code verwijderd ]
Ik vroeg me af wat WINAPI doet, als ik het weg laat dan kan ie Dword (*)(void*) niet converteren naar Dword (*)(void*)... weet iemand wat het precies doet?
In grote lijnen - wat thabit zegt.quote:
Ik vroeg me af wat WINAPI doet, als ik het weg laat dan kan ie Dword (*)(void*) niet converteren naar Dword (*)(void*)... weet iemand wat het precies doet?
Hier stelt iemand precies dezelfde vraag, en die krijgt het volgende antwoord
"Someone has defined the WINAPI word in WinDef.h file like this: #define WINAPI __stdcall; you can find this file and definition on your computer. Therefore, WINAPI means just __stdcall, and now you have to look for this word in documentation. It provides certain features to your MyThreadFunction function, like: the function will clean the stack of arguments, and the arguments will be passed from right to left."
De verschillende calling conventions worden hier uitgelegd; de twee die in dit geval van belang zijn, zijn "cdecl" (de standaard C(++) conventie), en "stdcall" (de conventie die door de Windows API wordt gehanteerd).
Zoals je kunt lezen wordt bij "cdecl" verwacht dat de stack* opgeruimd wordt door de code die de functie aanroept, terwijl "stdcall" functies zelf de stack opruimen voordat ze retourneren. Je kunt je voorstellen dat je duidelijk moet afspreken welke conventie je aanhoudt, anders wordt de stack twee keer (of juist nooit) opgeruimd en heb je een groot probleem.
* De stack is een stuk geheugen dat zich letterlijk gedraagd als een stapel: je kunt er waardes bovenop stapelen en waardes van de bovenkant afhalen, maar niet ertussenuit. Een stack wordt voornamelijk gebruikt om, vlak voor een functieaanroep het returnadres (=de volgende opdracht na het uitvoeren van die functie) op te zetten, zodat de processor weet waar 'ie verder moet gaan als hij een return statement tegenkomt.
Echter, omdat een processor slechts een beperkt aantal registers (="variabelen") heeft, wordt de stack ook gebruikt om functie parameters op te zetten die dan door de functie zelf weer uitgelezen worden. In wezen worden dus returnadressen en functie parameters door elkaar heen op de stack opgeslagen - en dit werkt alleen zolang iedereen ervoor zorgt dat de stack altijd precies genoeg wordt opgeruimd.
Vandaar dat de compiler je een stdcall functie echt niet laat herdefineren als een cdecl functie.
ahh, ik snapquote:
[..]
In grote lijnen - wat thabit zegt.
Hier stelt iemand precies dezelfde vraag, en die krijgt het volgende antwoord
"Someone has defined the WINAPI word in WinDef.h file like this: #define WINAPI __stdcall; you can find this file and definition on your computer. Therefore, WINAPI means just __stdcall, and now you have to look for this word in documentation. It provides certain features to your MyThreadFunction function, like: the function will clean the stack of arguments, and the arguments will be passed from right to left."
De verschillende calling conventions worden hier uitgelegd; de twee die in dit geval van belang zijn, zijn "cdecl" (de standaard C(++) conventie), en "stdcall" (de conventie die door de Windows API wordt gehanteerd).
Zoals je kunt lezen wordt bij "cdecl" verwacht dat de stack* opgeruimd wordt door de code die de functie aanroept, terwijl "stdcall" functies zelf de stack opruimen voordat ze retourneren. Je kunt je voorstellen dat je duidelijk moet afspreken welke conventie je aanhoudt, anders wordt de stack twee keer (of juist nooit) opgeruimd en heb je een groot probleem.
* De stack is een stuk geheugen dat zich letterlijk gedraagd als een stapel: je kunt er waardes bovenop stapelen en waardes van de bovenkant afhalen, maar niet ertussenuit. Een stack wordt voornamelijk gebruikt om, vlak voor een functieaanroep het returnadres (=de volgende opdracht na het uitvoeren van die functie) op te zetten, zodat de processor weet waar 'ie verder moet gaan als hij een return statement tegenkomt.
Echter, omdat een processor slechts een beperkt aantal registers (="variabelen") heeft, wordt de stack ook gebruikt om functie parameters op te zetten die dan door de functie zelf weer uitgelezen worden. In wezen worden dus returnadressen en functie parameters door elkaar heen op de stack opgeslagen - en dit werkt alleen zolang iedereen ervoor zorgt dat de stack altijd precies genoeg wordt opgeruimd.
Vandaar dat de compiler je een stdcall functie echt niet laat herdefineren als een cdecl functie.
ik heb dit stukje code (ik weet dat het niet werkt)
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | unsigned long WINAPI Threader(void *Data){ std::cout << "Threader\n"; SOCKET Client = *(SOCKET*)(&Data); char Buffer[2] = {'1','2'}; if((send(Client,Buffer,2,0)) == SOCKET_ERROR) throw Error("Socket error while sending!"); if(Client != INVALID_SOCKET) closesocket(Client); } int main(){ SOCKET hClient; // socket code HANDLE Thread = CreateThread(0,0,Threader,0,0,0); Sleep(5000); CloseHandle(Thread); } |
ow enne de HANDLE moet open blijven tot de thread klaar is toch?
ik heb nu dus
| 1 | HANDLE Thread = CreateThread(0,0,Threader,&hClient,0,0); |
en
| 1 2 3 4 5 6 7 8 9 10 11 | unsigned long WINAPI Threader(void *Data){ std::cout << "Threader\n"; SOCKET Client = *(SOCKET*)(&Data); char Buffer[2] = {'1','2'}; if((send(Client,Buffer,2,0)) == SOCKET_ERROR) throw Error("Socket error while sending!"); if(Client != INVALID_SOCKET) closesocket(Client); } |
ik blijf echter nog steeds een error krijgen bij het versturen van data
| 1 2 3 4 5 6 7 | SOCKET hClient = INVALID_SOCKET; sockaddr_in ClientSockAddr = {0}; int ClientSockSize = sizeof(ClientSockAddr); hClient = accept(hSocket,reinterpret_cast<sockaddr*>(&ClientSockAddr),&ClientSockSize); if(hClient == INVALID_SOCKET) throw Error("Accept function failed!"); HANDLE Thread = CreateThread(0,0,Threader,&hClient,0,0); |
| 1 | SOCKET Client = *(SOCKET*)(&Data); |
Data is al een pointer. &Data levert dus het adres van een pointer. Dit cast je naar een Socket-pointer. En die dereference je. De compiler denkt nu dus dat het een Socket is, terwijl je eigenlijk een Socket-pointer hebt.
Probeer het volgende eens:
| 1 | SOCKET Client = *reinterpret_cast<SOCKET *>(Data); |
En let op dat de hClient nog steeds op de stack in main() staat: als hij hier uit scope raakt of overschreven wordt, dan ben je je gegevens kwijt en crasht de boel (dus beter advies is dynamisch alloceren).
hmm, wat ik dus probeerde was met die cast er voor zorgen dat de compiler idd denkt dat het een socket is en die vervolgens kopieert naar de socket in the nieuwe threadquote:
Het volgende is ook een erg rare cast:
[ code verwijderd ]
Data is al een pointer. &Data levert dus het adres van een pointer. Dit cast je naar een Socket-pointer. En die dereference je. De compiler denkt nu dus dat het een Socket is, terwijl je eigenlijk een Socket-pointer hebt.
Probeer het volgende eens:
[ code verwijderd ]
En let op dat de hClient nog steeds op de stack in main() staat: als hij hier uit scope raakt of overschreven wordt, dan ben je je gegevens kwijt en crasht de boel (dus beter advies is dynamisch alloceren).
Tsja, maar als de compiler denkt een Socket te hebben terwijl het eigenlijk het adres van een Socket is, kunnen er natuurlijk geen goede dingen gebeuren.quote:hmm, wat ik dus probeerde was met die cast er voor zorgen dat de compiler idd denkt dat het een socket is en die vervolgens kopieert naar de socket in the nieuwe thread
Sowieso is een nieuw kopie maken in Threader() onveilig, omdat er geen garantie is dat het object nog bestaat ten tijde van kopieren (tenzij jij die garantie als programmeur geeft d.m.v mutex locks of iets dergelijks).
ja das waar miss is het beter om dan de sockets in een array oid. te stoppen dynamisch geheugen alloceren zodat de treads er gebruik van kunnen makenquote:
[..]
Tsja, maar als de compiler denkt een Socket te hebben terwijl het eigenlijk het adres van een Socket is, kunnen er natuurlijk geen goede dingen gebeuren.
Sowieso is een nieuw kopie maken in Threader() onveilig, omdat er geen garantie is dat het object nog bestaat ten tijde van kopieren (tenzij jij die garantie als programmeur geeft d.m.v mutex locks of iets dergelijks).
| 1 2 3 4 5 6 7 8 | SOCKET *Clients[number]; // code for(int i = 0; i < number; i++){ delete [] Clients[i]; Clients[i]=0; } |
kan bij die delete de brakkets ("[]") weggelaten worden?
Het moet zelfs, want je delete geen gealloceerde array van Sockets, maar één enkele. In het algemeen geldt: alleen met delete[] verwijderen als je met new[] gealloceerd hebt.quote:
kan bij die delete de brakkets ("[]") weggelaten worden?
Je bovenstaande code is gevaarlijk omdat het gedrag ongedefinieerd is: per implementatie kan het resultaat verschillen (en waarschijnlijk segfaulten).
oke, ik snap die brakkets nu maar waarom waarom is het gedrag ongedefinieerd dan?quote:
[..]
Het moet zelfs, want je delete geen gealloceerde array van Sockets, maar één enkele. In het algemeen geldt: alleen met delete[] verwijderen als je met new[] gealloceerd hebt.
Je bovenstaande code is gevaarlijk omdat het gedrag ongedefinieerd is: per implementatie kan het resultaat verschillen (en waarschijnlijk segfaulten).
TL;DR versie: Omdat C++ niet beschrijft hoe deze situatie afgehandeld moet worden.quote:
oke, ik snap die brakkets nu maar waarom waarom is het gedrag ongedefinieerd dan?
Lange versie: De programmeertaal 'C++' wordt ontwikkeld door een groep mensen die precies omschrijft wat C++ moet kunnen en doen. Deze groep maakt echter geen compilers, maar alleen een beschrijving van de taal. Compilerbouwers (zoals Microsoft, GCC, Borland etc.) gebruiken deze beschrijving en moeten deze precies volgen als ze een C++-compiler willen maken.
Niet alles staat echter in beschrijving van de taal (ook wel 'standaard' genoemd). Bijvoorbeeld het onderstaande stukje beschrijft de de memberfunctie sum() van de std::valarray class:
Hierin staat dus precies wat std::valarray::sum() moet doen. Het interessante stuk is dikgedrukt. Omdat niet is gedefinieerd wat de functie moet doen als lengte = 0, kan dit verschillen per compilerbouwer. Ze kunnen er bijvoorbeeld voor kiezen te segfaulten, een exception te gooien of gewoon '0' terug te geven als resultaat. Het punt is: ze kunnen kiezen.quote:T sum () const ;
This function may only be instantiated for a type T to which operator+= can be applied. This function returns the sum of all the elements of the array.
If the array has length 0, the behavior is undefined. If the array has length 1, sum() returns the value of element 0. Otherwise, the returned value is calculated by applying operator+= to a copy of an element of the array and all other elements of the array in an unspecied order.
Als je dus goede C++ code wilt schrijven, moet je zorgen dat je nooit sum() gebruikt van een leeg std::valarray object: je weet immers niet wat er gaat gebeuren. Je kunt wel testen wat er met jouw compiler gebeurt, maar je weet dan nog niet (a) of dit met iets andere code ook zo zal zijn, (b) of dit in een andere versie van jouw compiler (ouder/nieuwer) ook zo zal zijn en al helemaal niet of (c) dit met een andere compiler ook werkt.
Het resultaat van delete[] op een gewone pointer is ook zoiets: het effect van die operatie staat niet in de standaard, dus moet je er niet vanuit gaan dat het werkt. Dat wordt bedoeld met 'ongedefinieerd gedrag': het resultaat van een operatie die niet in de standaard staat en dus per implementatie kan verschillen.
[ Bericht 0% gewijzigd door GS42 op 13-03-2011 12:21:25 ]
, dus zonder [] is het wel correcte taal dus Aangezien ze voor zover ik kan zien geen eigen hWnd hebben.
zoals grootte, locatie ect.
ik zou het alleen niet weten hoe je dit kan vinden er zijn denk ik wel tooltjes voor die dat voor je kunnen vinden
Ik wil graag libHaru, een opensource pdf library, compilen naar een dll. Op de wiki documentatie zeggen ze dat je het volgende moet doen voor windows:
- unzip libharu-X.X.X.zip
- cd libharu-X.X.X
- Microsoft VC++ Compiler: nmake -f script/Makefile.msvc_dll demo
Nu heb ik dat gedaan alleen krijg ik steeds een error:
Blijkbaar kan hij een header zlib niet vinden. Ik geloof dat deze bij de zlib hoort, http://zlib.net/. Alleen lees ik nergens in de documentatie dat je die ook moet hebben. Ook lijkt het als of je http://www.libpng.org/pub/png/ nodig hebt... ook hier lees ik niets van in de documentatie...quote:Microsoft (R) Program Maintenance Utility Version 10.00.30319.01
Copyright (C) Microsoft Corporation. All rights reserved.
cl -Fosrc\hpdf_streams.obj /MD -nologo -O2 -Iinclude -Iwin32\include -
I"../../libpng"\include -I"../../zlib"\include -DHPDF_DLL_MAKE -c src\hpdf_strea
ms.c
hpdf_streams.c
src\hpdf_streams.c(28) : fatal error C1083: Cannot open include file: 'zlib.h':
No such file or directory
NMAKE : fatal error U1077: '"C:\Program Files\Microsoft Visual Studio 10.0\VC\BI
N\cl.EXE"' : return code '0x2'
Stop.
Iemand enig idee hoe ik dit oplos? Ben niet echt bekend met het compilen van dll's en makefiles.
De code is hier te downloaden, niet van http://libharu.org/ zelf want dan mis je een aantal dirs.
De makefile
SPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278# makefile for Haru Free PDFLibrary II (Libharu)
# Copyright (C) 1999-2006 Takeshi Kanno
# For conditions of distribution and use, see copyright notice in hpdf.h
#
# To compile, type:
# .\configure; make
# If you wish to build zlib as a shared library, use: ./configure -s
# To install /usr/local/lib/libhpdf.* and /usr/local/include/hpdf.h, type:
# make install
# To install in $HOME instead of /usr/local, use:
# make install prefix=$HOME
!IFNDEF PNG_PREFIX
PNG_PREFIX = ../../libpng
!ENDIF
!IFNDEF ZLIB_PREFIX
ZLIB_PREFIX = ../../zlib
!ENDIF
RC=rc
CC=cl
PREFIX=/usr/local
LIBNAME=libhpdf.lib
SONAME=libhpdf.dll
SOVER1=.1
SOVER2=.0.0
LIBTARGET=libhpdf.dll
CFLAGS=/MD -nologo -O2 -Iinclude -Iwin32\include -I"$(PNG_PREFIX)"\include -I"$(ZLIB_PREFIX)"\include -DHPDF_DLL_MAKE
CFLAGS_DEMO=/MD -nologo -O2 -Iinclude -Iwin32\include -D__WIN32__ -DHPDF_DLL
CFLAGS_EXE=-Fe
LDFLAGS= /LIBPATH:$(PNG_PREFIX)\lib /LIBPATH:$(ZLIB_PREFIX)\lib /LIBPATH:win32\msvc libpng13.lib zlib.lib
LDFLAGS_DEMO1=
LDFLAGS_DEMO2=/link /LIBPATH:. /LIBPATH:win32\msvc libhpdf.lib
DEFNAME=win32/msvc/libhpdf.def
RESNAME=win32/msvc/libhpdf.res
OBJS = \
src\hpdf_utils.obj \
src\hpdf_error.obj \
src\hpdf_mmgr.obj \
src\hpdf_list.obj \
src\hpdf_streams.obj \
src\hpdf_objects.obj \
src\hpdf_null.obj \
src\hpdf_boolean.obj \
src\hpdf_number.obj \
src\hpdf_real.obj \
src\hpdf_name.obj \
src\hpdf_array.obj \
src\hpdf_dict.obj \
src\hpdf_xref.obj \
src\hpdf_encoder.obj \
src\hpdf_string.obj \
src\hpdf_binary.obj \
src\hpdf_encrypt.obj \
src\hpdf_encryptdict.obj \
src\hpdf_fontdef.obj \
src\hpdf_fontdef_tt.obj \
src\hpdf_fontdef_type1.obj \
src\hpdf_fontdef_base14.obj \
src\hpdf_fontdef_cid.obj \
src\hpdf_font.obj \
src\hpdf_font_type1.obj \
src\hpdf_font_tt.obj \
src\hpdf_font_cid.obj \
src\hpdf_doc.obj \
src\hpdf_info.obj \
src\hpdf_catalog.obj \
src\hpdf_page_label.obj\
src\hpdf_gstate.obj \
src\hpdf_pages.obj \
src\hpdf_page_operator.obj \
src\hpdf_destination.obj \
src\hpdf_annotation.obj \
src\hpdf_outline.obj \
src\hpdf_image.obj \
src\hpdf_encoder_jp.obj \
src\hpdf_encoder_kr.obj \
src\hpdf_encoder_cns.obj \
src\hpdf_encoder_cnt.obj \
src\hpdf_fontdef_jp.obj \
src\hpdf_fontdef_kr.obj \
src\hpdf_fontdef_cns.obj \
src\hpdf_fontdef_cnt.obj \
src\hpdf_image_png.obj \
src\hpdf_image_ccitt.obj \
src\hpdf_doc_png.obj \
src\hpdf_ext_gstate.obj \
src\hpdf_namedict.obj \
src\hpdf_3dmeasure.obj \
src\hpdf_exdata.obj \
src\hpdf_u3d.obj
PROGRAMS = \
demo\encoding_list.exe \
demo\font_demo.exe \
demo\text_demo.exe \
demo\text_demo2.exe \
demo\image_demo.exe \
demo\jpeg_demo.exe \
demo\jpfont_demo.exe \
demo\line_demo.exe \
demo\link_annotation.exe \
demo\outline_demo.exe \
demo\png_demo.exe \
demo\text_annotation.exe \
demo\ttfont_demo.exe \
demo\character_map.exe \
demo\grid_sheet.exe \
demo\arc_demo.exe \
demo\raw_image_demo.exe \
demo\encryption.exe \
demo\permission.exe \
demo\slide_show_demo.exe \
demo\ext_gstate_demo.exe \
.SUFFIXES: .c .obj
all: $(LIBTARGET)
libhpdf.res: win32\msvc\libhpdf.rc
$(RC) /FO win32\msvc\libhpdf.res win32\msvc\libhpdf.rc
$(LIBNAME): $(OBJS)
if exist *.lib del *.lib
lib -out:$@ $(OBJS)
$(SONAME): $(OBJS) libhpdf.res
-@if exist $(SONAME) del $(SONAME)
-@if exist $(LIBAME) del $(LIBNAME)
link /DLL /OUT:$(SONAME) $(OBJS) $(RESNAME) $(LDFLAGS) /DEF:$(DEFNAME)
rename libhpdf.lib $(LIBNAME)
copy $(SONAME) demo
demo: $(LIBTARGET) $(PROGRAMS)
clean:
if exist src\*.obj del src\*.obj
if exist src\*.o del src\*.o
if exist *.lib del *.lib
if exist *.dll del *.dll
if exist demo\*.exe del demo\*.exe
if exist demo\*.tds del demo\*.tds
if exist *.obj del *.obj
if exist win32\msvc\*.res del win32\msvc\*.res
install: all installfiles
installfiles:
echo target "install" is not supported on windows platforms.
.c.obj:
$(CC) -Fo$@ $(CFLAGS) -c $*.c
demo\encoding_list.exe : demo\encoding_list.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\encoding_list.c $(LDFLAGS_DEMO2)
cd demo
.\encoding_list.exe
cd ..
demo\font_demo.exe : demo\font_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\font_demo.c $(LDFLAGS_DEMO2)
cd demo
.\font_demo.exe
cd ..
demo\text_demo.exe : demo\text_demo.c demo\grid_sheet.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\text_demo.c demo\grid_sheet.c $(LDFLAGS_DEMO2)
cd demo
.\text_demo.exe
cd ..
demo\text_demo2.exe : demo\text_demo2.c demo\grid_sheet.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\text_demo2.c demo\grid_sheet.c $(LDFLAGS_DEMO2)
cd demo
.\text_demo2.exe
cd ..
demo\image_demo.exe : demo\image_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\image_demo.c $(LDFLAGS_DEMO2)
cd demo
.\image_demo.exe
cd ..
demo\jpeg_demo.exe : demo\jpeg_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\jpeg_demo.c $(LDFLAGS_DEMO2)
cd demo
.\jpeg_demo.exe
cd ..
demo\jpfont_demo.exe : demo\jpfont_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\jpfont_demo.c $(LDFLAGS_DEMO2)
cd demo
.\jpfont_demo.exe
cd ..
demo\line_demo.exe : demo\line_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\line_demo.c $(LDFLAGS_DEMO2)
cd demo
.\line_demo.exe
cd ..
demo\link_annotation.exe : demo\link_annotation.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\link_annotation.c $(LDFLAGS_DEMO2)
cd demo
.\link_annotation.exe
cd ..
demo\outline_demo.exe : demo\outline_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\outline_demo.c $(LDFLAGS_DEMO2)
cd demo
.\outline_demo.exe
cd ..
demo\png_demo.exe : demo\png_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\png_demo.c $(LDFLAGS_DEMO2)
cd demo
.\png_demo.exe
cd ..
demo\text_annotation.exe : demo\text_annotation.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\text_annotation.c $(LDFLAGS_DEMO2)
cd demo
.\text_annotation.exe
cd ..
demo\encryption.exe : demo\encryption.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\encryption.c $(LDFLAGS_DEMO2)
cd demo
.\encryption.exe
cd ..
demo\permission.exe : demo\permission.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\permission.c $(LDFLAGS_DEMO2)
cd demo
.\permission.exe
cd ..
demo\ttfont_demo.exe : demo\ttfont_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\ttfont_demo.c $(LDFLAGS_DEMO2)
cd demo
.\ttfont_demo.exe ttfont\PenguinAttack.ttf -E
cd ..
demo\character_map.exe : demo\character_map.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\character_map.c $(LDFLAGS_DEMO2)
demo\raw_image_demo.exe : demo\raw_image_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\grid_sheet.c demo\raw_image_demo.c $(LDFLAGS_DEMO2)
cd demo
.\raw_image_demo.exe
cd ..
demo\arc_demo.exe : demo\arc_demo.c demo\grid_sheet.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\grid_sheet.c demo\arc_demo.c $(LDFLAGS_DEMO2)
cd demo
.\arc_demo.exe
cd ..
demo\grid_sheet.exe : demo\grid_sheet.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) -DSTAND_ALONE $(LDFLAGS_DEMO1) demo\grid_sheet.c $(LDFLAGS_DEMO2)
cd demo
.\grid_sheet.exe
cd ..
demo\slide_show_demo.exe : demo\slide_show_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\slide_show_demo.c $(LDFLAGS_DEMO2)
cd demo
.\slide_show_demo.exe
cd ..
demo\ext_gstate_demo.exe : demo\ext_gstate_demo.c $(LIBTARGET)
$(CC) $(CFLAGS_EXE)$@ $(CFLAGS_DEMO) $(LDFLAGS_DEMO1) demo\ext_gstate_demo.c $(LDFLAGS_DEMO2)
cd demo
.\ext_gstate_demo.exe
cd ..
Zoniet, dan lijkt het erop dat je inderdaad de zlib library nodig hebt op je systeem.
ik heb de volgende code:
en dan heb ik hier de niet gedefinieerde functies gedefinieerd:SPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23class Piece{
Piece *_NEXT;
int _DATA;
public:
Piece():_NEXT(0),_DATA(0){}
Piece(Piece *next,int data):_NEXT(next),_DATA(data){}
friend class LList;
};
class LList{
Piece *_START;
public:
LList():_START(0){}
LList(Piece start):_START(&start){}
LList(Piece *start):_START(start){}
~LList();
unsigned length();
bool loop();
};
nu is het zo dat ik dit doeSPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37LList::~LList(){
Piece *temp1,*temp2;
if(_START != 0){
temp1 = _START;
while(temp1 !=0){
temp2 = temp1;
temp1 = temp1->_NEXT;
delete temp2;
}
}
}
unsigned LList::length(){
unsigned i = 0;
if(_START != 0){
i++; // start is 1e object
Piece *temp = _START;
while(temp->_NEXT != 0 && temp->_NEXT != _START){
temp = temp->_NEXT;
i++;
}
temp = 0;
}
return i;
}
bool LList::loop(){
if(_START !=0){
Piece *temp = _START;
while(temp->_NEXT != 0){
temp = temp->_NEXT;
if(temp == _START)
return true;
}
}
return false;
}
| 1 2 3 4 | LList myLList(mypiece); std::cout << "List length: " << myLList.lenght() << '\n'; std::cout << "List loop?: " << myLList.loop() << '\n'; |
dit is mijn output:
| 1 | list lenght: 5 |
dan krijg ik een error dat het programma niet meer werkt...
dit duid er dus op dat m'n length() functie niet goed opgeruimd word of zo, iemand een idee wat ik niet goed doe?
Dat is inderdaad een probleem, maar zijn fout wordt veroorzaakt door iets anders: bekijk je LList constructor LList(Piece start):_START(&start) eens goed. Wat klopt hier niet? (Hint: waar wordt 'Piece start' geinitialiseerd en wanneer wordt deze vernietigd?)quote:Op donderdag 17 maart 2011 18:10 schreef thabit het volgende:
Je lijkt dingen te deleten die niet met new worden aangemaakt. Dat kan natuurlijk niet goed gaan.
umm, hij word geďnitialiseerd bij de constructie, en weer vernietigd tijdens de destructie van LListquote:
[..]
Dat is inderdaad een probleem, maar zijn fout wordt veroorzaakt door iets anders: bekijk je LList constructor LList(Piece start):_START(&start) eens goed. Wat klopt hier niet? (Hint: waar wordt 'Piece start' geinitialiseerd en wanneer wordt deze vernietigd?)
Ik neem aan de de _START pas vernietigd word nadat de rest van de destructor is uitgevoerd...
ja, dat dacht ik dus ook al maar als ik gewoon in de main dit schrijf:quote:
Je lijkt dingen te deleten die niet met new worden aangemaakt. Dat kan natuurlijk niet goed gaan.
| 1 2 3 4 | Pice myPiece; Piece *ptr; ptr = &myPiece; delete ptr; |
Je past daar pass-by-value toe. Dat ding wordt dus meteen al vernietigd bij het verlaten van de constructor.quote:
[..]
umm, hij word geďnitialiseerd bij de constructie, en weer vernietigd tijdens de destructie van LList
ik heb ze nu idd maar weer via new gemaakt en heb de error nu ook niet meer ow kut die Piece start word natuurlijk weer vernietigd... lekker dom weer
ik was al bang dat mn length() functie een fout bevatte die ik niet snapte
bedankt in ieder geval
| 1 2 3 4 5 6 | int ifstr_loc = read.tellg(); while(b_temp){ read.seekg(ifstr_loc); std::cout << read.tellg( << '\n'; Handle_Function(read); } |
als bool b_temp = true; dan zou dit toch een oneindige loop moeten vormen die steeds read op ifstr_loc zet en dan iets gaat doen??
ik krijg nu dat Handle_Function 1x word uitgevoerd en daarna is read.tellg() -1 nadat seekg(44) is aangeroepen, kan iemand mij misschien vertellen waarom read.tellg() -1 word?
Ja, tenzij b_temp in Handle_Function aangepast wordt. Dan hoeft de loop niet oneindig te zijn.quote:
Hey heeft iemand een idee waarom dit niet werkt??
[ code verwijderd ]
als bool b_temp = true; dan zou dit toch een oneindige loop moeten vormen die steeds read op ifstr_loc zet en dan iets gaat doen??
Aannemende dat 'read' een of andere istream is, dan geeft tellg() -1 terug als deze faalt. Dit betekent hoogstwaarschijnlijk dat 'read' geen vailde status meer heeft, dus dat een of andere operatie in Handle_Function gefaald is. In het algemeen lees je nooit van een istream zonder te controleren of de istream wel leesklaar is. Probeer maar eens de statusbits van de istream af te drukken (eof, fail en bad), dan zal je zien dat dat de stream zich in een foutstaat bevindt.quote:ik krijg nu dat Handle_Function 1x word uitgevoerd en daarna is read.tellg() -1 nadat seekg(44) is aangeroepen, kan iemand mij misschien vertellen waarom read.tellg() -1 word?
[ Bericht 1% gewijzigd door GS42 op 03-04-2011 15:15:35 ]
Het klopt dat ik de check of ie valide is idd er niet in gedaan heb neequote:
[..]
Aannemende dat 'read' een of andere istream is, dan geeft tellg() -1 terug als deze faalt. Dit betekent hoogstwaarschijnlijk dat 'read' geen vailde status meer heeft, dus dat een of andere operatie in Handle_Function gefaald is. In het algemeen lees je nooit van een istream zonder te controleren of de istream wel leesklaar is. Probeer maar eens de statusbits van de istream af te drukken (eof, fail en bad), dan zal je zien dat dat de stream zich in een foutstaat bevindt.
maar ik zet eerst de read pointer terug naar 44 en dan blijft tellg() toch -1 geven voordat de Handle_Function(read); word aangeroepen
PS. read is std::ifstream
ahh, kijk dat verklaard een hoopquote:
tellg gaf al -1? Je moet de errorbits wel resetten. Weet zo uit mn hoofd niet hoe, maar is makkelijk te googlen.
EDIT:
klopt geen ene flikker van m'n code zal dat eerst eens even fixen...
bedankt in ieder geval
[ Bericht 11% gewijzigd door netolk op 02-04-2011 22:26:54 ]
ik vraag me af of dit tot geheugen leaks lijd:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | class Piece{ Piece *_NEXT; std::string _TYPE; std::string _NAME; void *_DATA; }; class LList{ Piece *_START; ~LList(); }; LList::~LList(){ Piece *temp1,*temp2; if(_START != 0){ temp1 = _START; while(temp1 !=0){ temp2 = temp1; temp1 = temp1->_NEXT; delete temp2; } } } |
word nu bij het deleten van Piece* de destructor van Piece aan geroepen? of moet ik dit regelen in de destructor van LList?
oke, dat is mooi...quote:
Bij het deleten van Piece* wordt inderdaad de destructor van Piece aangeroepen.
nog een vraagje stel ik hou een int die de grootte van het object voorstelt waar void *_DATA naar verwijst, hoe kan ik *_DATA dan ombouwen zodat het object uit het geheugen geflikkerd word? of is dit niet mogelijk in C++?
um _DATA is wel een void, en als ik delete _DATA doe dan is dat dus ongedefinieerd. Ik krijg dit ook als waarschuwing als ik het wel probeerquote:
Je kan gewoon delete _DATA doen, de delete "weet" hoeveel ruimte het object inneemt als je het met new hebt aangemaakt.
dus ik dacht ik cast het eerst naar de gebruikte grootte en dan delete ik het op die manier
Ik weet alleen niet hoe ik dat moet doen als het object bijv. 30 byte is
Het enige probleem void pointers is misschien dat er geen destructor wordt aangeroepen, dus alleen gebruiken voor pointers naar "simpele" types waar geen destructor voor nodig is.
Dat er evt. geen destructor word aangeroepen is geen probleem dat is nog wel op te lossen maar wat het is ik heb bijv.quote:
Maar als je het echt netjes wilt doen kun je ofwel een template maken en void vervangen door een typename binnen die template, of een base class waar je types die _DATA kunnen zijn van afleidt en dan _DATA dus als een pointer naar die base class declareren.
Het enige probleem void pointers is misschien dat er geen destructor wordt aangeroepen, dus alleen gebruiken voor pointers naar "simpele" types waar geen destructor voor nodig is.
| 1 | int *ptr_int = new int(8); |
| 1 | _DATA = ptr_int; |
delete [] zou dat wel goed moeten doen, maar dan moet je het wel bij arrays houden.
Gelukkig wordt er ook maar 1 int aangemaakt door new in zijn voorbeeld.quote:
Ja, dat snapt ie niet, delete zal dan simpelweg ptr_int[0] deleten en de rest laten staan.
delete [] zou dat wel goed moeten doen, maar dan moet je het wel bij arrays houden.
goed ik zal de warningcode er wel even bij plakken dan:quote:
[..]
Gelukkig wordt er ook maar 1 int aangemaakt door new in zijn voorbeeld.
| 1 2 | LList.cpp: In destructor `Piece::~Piece()': LList.cpp:3: warning: deleting `void*' is undefined |
Het lijkt er op of de void-pointers geen grootte kunnen "onthouden"
[ Bericht 4% gewijzigd door netolk op 06-04-2011 18:00:32 ]
De code werkt op vrijwel elke compiler goed, zolang de void* naar een built-in type verwijst. Als je hem naar classes laat verwijzen, dan kunnen er dingen misgaan, bijvoorbeeld omdat er dan geen destructor wordt aangeroepen.
Het memory management onthoudt de grootte van de blokken geheugen die worden gealloceerd en weet dus hoe groot het blok geheugen is waar de pointer aan verbonden is.
Ja, maar het is dus nu juist wel de bedoeling om dit oa. ook naar classes ect te laten verwijzenquote:
De C++ standaard definieert geen delete van void*s, maar dat betekent niet dat de compiler het niet gedefinieerd heeft.
De code werkt op vrijwel elke compiler goed, zolang de void* naar een built-in type verwijst. Als je hem naar classes laat verwijzen, dan kunnen er dingen misgaan, bijvoorbeeld omdat er dan geen destructor wordt aangeroepen.
Het memory management onthoudt de grootte van de blokken geheugen die worden gealloceerd en weet dus hoe groot het blok geheugen is waar de pointer aan verbonden is.
dus hoe kan het dan goed opgeruimd worden?
| 1 2 3 4 5 6 7 8 9 10 11 12 | class Piece{ Piece *_NEXT; std::string _TYPE; std::string _NAME; }; template<typename T> class TypedPiece: public Piece { T *_DATA; }; |
Zoiets bijvoorbeeld. Of je maakt van _DATA een base class waar je een templated class van afleidt.
tja de templates heb ik idd nog niet doorgewerkt maar dat zal ik eens even gaan doen dan
Wat je nu als voorbeeld hebt gemaakt kan je dat dan toch als onderdeel van Piece aanroepen?
| 1 2 3 | Piece myPiece; myPiece._DATA = ptr_int; |
Ja, das het voordeel van templates.quote:
Ja, dat moet ik idd hebben txs...
tja de templates heb ik idd nog niet doorgewerkt maar dat zal ik eens even gaan doen dan
Wat je nu als voorbeeld hebt gemaakt kan je dat dan toch als onderdeel van Piece aanroepen?
[ code verwijderd ]
bedankt voor de hulp Tabit en ralfie
Ik zou dit wel met accessormethodes aanpakken, niet direct van buiten de klasse in de data peuren.quote:
Ja, dat moet ik idd hebben txs...
tja de templates heb ik idd nog niet doorgewerkt maar dat zal ik eens even gaan doen dan
Wat je nu als voorbeeld hebt gemaakt kan je dat dan toch als onderdeel van Piece aanroepen?
[ code verwijderd ]
Nee, dat is idd ook niet de bedoeling maar Piece is een onderdeel van mijn Linked List class en ik heb het dan zo gemaakt dat het alleen mogelijk is om data te wijzigen via de Linked List classquote:
[..]
Ik zou dit wel met accessormethodes aanpakken, niet direct van buiten de klasse in de data peuren.
Ik heb een vraagje hoe kan ik aparte pixels op het scherm tekenen of kleine lijntjes??
Ik heb al wat gekeken voor openGL maar dat is niet zo heel handig om een paar lijntjes te tekenen
Iemand suggesties om dit te doen?
Je gaat al snel naar directX of openGL... Wat voor lijntjes will je tekenen? Win32 zal er misschien ook wat functies voor hebben, mits je in een formpje zit.quote:Op maandag 9 mei 2011 18:06 schreef netolk het volgende:
Hey Fokkers
Ik heb een vraagje hoe kan ik aparte pixels op het scherm tekenen of kleine lijntjes??
Ik heb al wat gekeken voor openGL maar dat is niet zo heel handig om een paar lijntjes te tekenen
Iemand suggesties om dit te doen?
ik wel horizontale,verticale en diagonale (45 graden) lijnen tekenen van 1 pixel breed en 3 pixels lang. En daar wil ik er heel veel van
Moet openGL in een win32 omgeving of kan het ook draaien in console mode?
Dan zul je toch met Win32 of Glut aan de slag moeten (glut is een laag tussen win32 en opengl in, die windowing en messaging afhandeld).
Win32 heeft een SetPixel() functie, maar die is niet echt snel. Als het snel(ler) moet, kun je een off-screen buffer alloceren, en die met SetDIBits vrij snel naar het scherm blitten.
Hmm... kut k vind die win32 dingen altijd zo'n gedoe om alleen al een window te krijgen...quote:
openGL kan zeker niet in een console, aangezien dat text-based is. Ik neem aan dat je wel onder windows werkt? (en niet linux, freebsd, mac, whatever?)
Dan zul je toch met Win32 of Glut aan de slag moeten (glut is een laag tussen win32 en opengl in, die windowing en messaging afhandeld).
Win32 heeft een SetPixel() functie, maar die is niet echt snel. Als het snel(ler) moet, kun je een off-screen buffer alloceren, en die met SetDIBits vrij snel naar het scherm blitten.
nouja het moet dan maar en k heb ondertussen de juiste code voor een lijn in openGL gevonden dus dat is opgelost
bedankt
Je kunt als je perse met OpenGL bezig wil ook prima met C# of Java aan de slag trouwens.
Ja, en dan de rest van mn programma helemaal ombouwen zeker Xdquote:
OpenGL is ook voor 2D werk handig, omdat het gebruik maakt van de hardwareversnelling van je GPU. Het enige nadeel is dat het in eerste instantie wat complexer is.
Je kunt als je perse met OpenGL bezig wil ook prima met C# of Java aan de slag trouwens.
Nee, ik maak er wel gewoon een win32 app van en dan gewoon openGL voor het tekenwerk
ik gebruik nu GetAsyncKeyState(VK_UP) programma registreert het wel maar na het afsluiten kom ik er achter dat cmd het ook nog registreert en dan dus allemaal andere commando's (die daar voor gebruikt zijn) gaat uitvoeren, weet iemand hoe ik dit kan voorkomen in een console programma?
verkeerd gelezen
In principe is dit niet mogelijk met standaard C(++). Het opvangen van toetsen is namelijk os-specifiek (invoer kan immers alleen in C(++) gelezen worden nadat de terminal het naar cin stuurt).quote:
Hey, ik heb een vraagje is het mogelijk om in een console programma de toets-status te onderscheppen??
Er zijn wel os-specifieke libraries die omgang met de terminal versoepelen, waarbij curses de grootste is in Unix-omgevingen. Ik heb curses voor iets dergelijks gebruikt, dus ik weet dat het hiermee kan. Ik lees ook net op de wiki-site dat het blijkbaar naar Windows geport is, dus wellicht dat je hier iets mee kan.
Iets als:
| 1 2 | while((c = getchar()) != '\n' && c != EOF) /* discard */ ; |
http://msdn.microsoft.com/en-us/library/ms686016
(werkt alleen op Ramen)
@hierboven: cin.flush() ? - Nee, wacht, schijnt niet te kunnen. cin.sync() dan of cin.ignore()?
Dit voorbeeld van MSDN doet echter wel precies wat je zou willen:
http://msdn.microsoft.com/en-us/library/ms685035(v=VS.85).aspx. Die laat zien hoe je input events van de console leest (toetsen indrukken, toetsen loslaten, mouse events, etc) en afhandled. Doordat je dus key-presses en key-releases krijgt, kun je dus zelf bijhouden welke toetsen ingedrukt zijn.
Volgens mij is die ReadConsoleInput trouwens wel blocking, dus lijkt het me zinvol om dat in een apparte thread te doen.
Maar als je toch Win32 gebaseerde eventhandlers gaat schrijven, waarom maak je dan nog een console applicatie?
Ik ga daar even mee klooien
met de link van Ai_KaRaMBa heb ik een thread gemaakt die de key-status bekijkt dus dan heeft mijn programma gewoon draaien en kan ik de key's uitlezen wanneer ik wil| 1 2 3 4 5 6 7 8 9 10 11 12 | class Key{ void *_HANDLE; bool _KEY_PRESSED[256]; public: Key(); ~Key() throw(); // operators ed moeten nog bool operator[](const unsigned char &n); friend unsigned long WINAPI Threader_Key(void *Data); }; |
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | unsigned long WINAPI Threader_Key(void *Data){ Thread::Key *myKey = reinterpret_cast<Thread::Key*>(Data); // declaraties en error checks hier weggelaten //dispatch the events to the appropriate handler. for(unsigned i=0; i < cNumRead;i++){ switch(irInBuf[i].EventType){ case KEY_EVENT: if(irInBuf[i].Event.KeyEvent.bKeyDown) myKey->_KEY_PRESSED[irInBuf[i].Event.KeyEvent.wVirtualKeyCode] = true; else myKey->_KEY_PRESSED[irInBuf[i].Event.KeyEvent.wVirtualKeyCode] = false; break; } } } } |
Het gaat om het deel myKey->_KEY_PRESSED[...] = true/false
Weet iemand waarom dit niet werkt? de functie draait overigens wel in een aparte thread ik weet niet of dat uit maakt, maar als ik _KEY_PRESSED 'public' maak werkt het wel...
als ik hem protected maak werkt het btw nog steeds niet maar een friend functie zou gewoon toegang moeten hebben tot alle members (dus ook de private) van een class toch?quote:
lijkt mij dat je _KEY_PRESSED dan ook als 'friend' moet declareren? Zonder aanduiding is het geloof ik standaard "private", en kan dus een friend functie er niet bij
Ja, maar _KEY_PRESSED is een member
| 1 | bool _KEY_PRESSED[256]; |
) dergelijke problemen gehad, en daar lag het aan dat de member variabelen private waren, en dat protected fucties daar niet bij konden; ik dacht dat dit probleem iets soortgelijks zou zijn 
Ik ben niet echt ervaren met C++, maar na wat googlen lijkt het inderdaad dat wel had moeten werken: in het eerste voorbeeld in http://www.cplusplus.com/doc/tutorial/inheritance/ doen ze precies hetzelfde als jij...
Mogelijk dat je namespace roet in 't eten gooit???
Nee, namespace kan het niet zijn omdat in de class staat welke functie gebruik van de private members mag maken en die functie staat niet in een namespace... Zelf denk ik meer dat het misschien te maken heeft dat de functie in een andere thread draait...quote:
Ik heb in het verleden wel eens met Java (
Ik ben niet echt ervaren met C++, maar na wat googlen lijkt het inderdaad dat wel had moeten werken: in het eerste voorbeeld in http://www.cplusplus.com/doc/tutorial/inheritance/ doen ze precies hetzelfde als jij...
Mogelijk dat je namespace roet in 't eten gooit???
| 1 | friend unsigned long WINAPI ::Threader_Key(void *Data); |
Hiertoe moet de functie wel eerst gedeclareerd zijn, geen probleem lijkt me. Ik denk dat dit de compiler-melding oplost.
Als het niet werkt, kan je altijd een access functie á la Key::setKeyPressed(unsigned char idx, bool value) inline definieren, dit zou het probleem ook oplossen en misschien zelfs netter zijn.
het forceren met :: heb ik geprobeerd maar zegt ie dood leuk dat ik hem in :: moet declareren...quote:
Dat de code in verschillende threads draait, zou voor de compiler geen verschil moeten maken. Ik denk dat je probleem toch door de namespaces komt. Je zei dat Threader_Key in de globale namespace staat? Forceer dat dan eens in je code door de friends declaratie zo te schrijven:
[ code verwijderd ]
Hiertoe moet de functie wel eerst gedeclareerd zijn, geen probleem lijkt me. Ik denk dat dit de compiler-melding oplost.
Als het niet werkt, kan je altijd een access functie á la Key::setKeyPressed(unsigned char idx, bool value) inline definieren, dit zou het probleem ook oplossen en misschien zelfs netter zijn.
Wat dus niet kan omdat ie in een apart .cpp bestand staat. Maar die oplossing van jou is idd wel netter (had ik nog niet aan gedacht) dus dan pas ik dat gewoon toe en is het probleem ook opgelost.
Bedankt, jij ook Ai_KaRaMBa voor het mee denken
Waarom kun je 'm niet declareren omdat 'ie in een appart bestand staat?quote:
[..]
het forceren met :: heb ik geprobeerd maar zegt ie dood leuk dat ik hem in :: moet declareren...
Wat dus niet kan omdat ie in een apart .cpp bestand staat.
Je kan toch prima:
| 1 | unsigned long WINAPI ::Threader_Key(void *Data); |
Trouwens: een losse set-functie is niet altijd wenselijk (de waarden zijn niet voor niets private natuurlijk); met 'friend' functies kun je nauwkeuriger controlleren waar/hoe waarden gezet gaan worden.
Nog mooier zou zijn als je bijv. een 'handleEvent' functie ofzo als member functie aanmaakt, die een enkele key-event afhandelt. De Threader_Key functie kan die memberfunctie dan in een loop aanroepen. Zo hou je controle over je private member variable binnen de klasse, zonder de variabele voor 'algemeen gebruik' open te zetten
[ Bericht 21% gewijzigd door Ai_KaRaMBa op 26-07-2011 13:27:29 ]
Ik had nu idd ook al bedacht dat dit niet ging werken neequote:
[..]
Waarom kun je 'm niet declareren omdat 'ie in een appart bestand staat?
Je kan toch prima:
[ code verwijderd ]
boven de klasse-definitie (of mooier: in een header file, die je include) zetten?
Trouwens: een losse set-functie is niet altijd wenselijk (de waarden zijn niet voor niets private natuurlijk); met 'friend' functies kun je nauwkeuriger controlleren waar/hoe waarden gezet gaan worden.
Nog mooier zou zijn als je bijv. een 'handleEvent' functie ofzo als member functie aanmaakt, die een enkele key-event afhandelt. De Threader_Key functie kan die memberfunctie dan in een loop aanroepen. Zo hou je controle over je private member variable binnen de klasse, zonder de variabele voor 'algemeen gebruik' open te zetten
omdat ik de member dan netzo goed public kan maken, ik dacht dus dat ie boven mn class al ergens gedeclareerd stond (snapte de fout-code ook al niet helemaal maar had geen zin om te zoeken) en de oplossing leek heel aardig totdat ik bedacht dat je die dan altijd kan aanroepen...Bv struct hoi; en struct hoi = new struct;
Daarnaast kun je niets toekennen aan en opvragen van data in je struct in het eerste geval, en zul je op een later tijdstip alsnog een new moeten doen.
Onder C# krijg je dan een 'object reference not set to an instance of an object' exceptie, ik weet niet of die in C ook zo heet...
new returnt een pointer, waarbij er op de heap geheugen wordt aangemaakt. In het eerste geval staat de struct op de stack.quote:
Wat is het verschil tussen type variable_naam en type variable_naam = new type?
Bv struct hoi; en struct hoi = new struct;
Bij beide declaraties wordt geheugen gealloceerd, bij de eerste aanroep gebeurt dit op de stack, bij de tweede aanroep in de common pool, waarbij new dus een pointer teruggeeft naar dit geheugen.quote:Bij de tweede alloceer je meteen geheugen. Bij de eerst niet.
Ik snap niet wat hiermee bedoeld wordt, maar uiteraard kan je de struct gewoon gebruiken en is het niet noodzakelijk om later nog een new-aanroep te doen.quote:Daarnaast kun je niets toekennen aan en opvragen van data in je struct in het eerste geval, en zul je op een later tijdstip alsnog een new moeten doen.
Kort, krachig en grotendeels juist. Alleen het gebruik van het woord heap begrijp ik niet: in de common pool is geen sprake van een datastructuur?quote:new returnt een pointer, waarbij er op de heap geheugen wordt aangemaakt. In het eerste geval staat de struct op de stack.
Gebruik 'new' alleen als je zeker weet dat je het nodig hebt. Zoniet: weglaten.
quote:In the C++ programming language, as well as in many C++-based languages, new is a language construct that dynamically allocates memory on the heap and initialises the memory using the constructor. Except for a form called the "placement new", new attempts to allocate enough memory on the heap for the new data. If successful, it initialises the memory and returns the address to the newly allocated and initialised memory. However if new cannot allocate memory on the heap it will throw an exception of type std::bad_alloc. This removes the need to explicitly check the result of an allocation. A call to delete, which calls the destructor and returns the memory allocated by new back to the heap, must be made for every call to new to avoid a memory leak.
Klopt, om duidelijk te maken dat de heap gebruikt wordt.quote:
het gaat om dit stukje
| 1 2 3 4 5 6 | struct Data{ *ptr1; *ptr2; }; Data *myData; myData = new Data[1000*1000*1000]; |
Hier loopt het programma vast maar als ik 2 vd 3 1000 naar 100 zet werkt het wel gewoon...
Ik, heb werkgeheugen om de 1,86 GB te bewaren, ik snap niet waarom dit niet werkt
alvast bedankt voor de hulp
Een pointer neemt doorgaans op een 32-bitssystem 4 bytes in en op een 64-bitssysteem 8 bytes. We kunnen dus concluderen dat het veel meer dan 1,86 GB inneemt. Om dit te adresseren heb je meer dan 4 GB en dus een 64-bitssysteem nodig. Dan kom je toch al gauw uit op 16 * 10003 bytes en dat is ongeveer 14,9 GB.quote:
Kan iemand mij uitleggen waarom dit programma een (onbekende) error geeft waardoor windows het programma sluit??
het gaat om dit stukje
[ code verwijderd ]
Hier loopt het programma vast maar als ik 2 vd 3 1000 naar 100 zet werkt het wel gewoon...
Ik, heb werkgeheugen om de 1,86 GB te bewaren, ik snap niet waarom dit niet werkt
alvast bedankt voor de hulp
Ahh, vandaarquote:
[..]
Een pointer neemt doorgaans op een 32-bitssystem 4 bytes in en op een 64-bitssysteem 8 bytes. We kunnen dus concluderen dat het veel meer dan 1,86 GB inneemt. Om dit te adresseren heb je meer dan 4 GB en dus een 64-bitssysteem nodig. Dan kom je toch al gauw uit op 16 * 10003 bytes en dat is ongeveer 14,9 GB.
ik snapte het al niet dacht dat pointers 1 byte waren Xd maar nu ik dit zo lees is het idd logisch dat ze 8 bytes zijn 
ik heb een variabele b dat een unsigned long array is. Nu heb ik het volgende stukje code:
| 1 2 3 4 | unsigned long *a = b; a[1] = iets ... a += 2 |
Nu wil ik dit graag veranderen naar
| 1 2 3 | *(b + 1) = iets ... *(b) += 2 |
Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?
Als een pointer 1 byte was, en dus 256 mogelijke waarden had, dan had je maar 256 bytes kunnen adresseren he...quote:
Ahh, vandaar
a is een pointer, wordt dus gerepresenteerd door een adres. Het statement a += 2 schuift de pointer dus twee plekken op. *a is datgene waar de pointer naar verwijst, ofwel de inhoud van het adres; idem dito voor *b. a en b verwijzen naar hetzelfde adres in jouw code.quote:Op woensdag 16 november 2011 02:46 schreef Dale. het volgende:
Vraagje
ik heb een variabele b dat een unsigned long array is. Nu heb ik het volgende stukje code:
[ code verwijderd ]
Nu wil ik dit graag veranderen naar
[ code verwijderd ]
Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?
*(b+i) is hetzelfde als b[i]. *b is dus hetzelfde als b[0] en ook hetzelfde als *a, wat niet a is.
Ok dus als ik het goed begrijp moet de laatste regel nietquote:
[..]
a is een pointer, wordt dus gerepresenteerd door een adres. Het statement a += 2 schuift de pointer dus twee plekken op. *a is datgene waar de pointer naar verwijst, ofwel de inhoud van het adres; idem dito voor *b. a en b verwijzen naar hetzelfde adres in jouw code.
*(b+i) is hetzelfde als b[i]. *b is dus hetzelfde als b[0] en ook hetzelfde als *a, wat niet a is.
*(b) += 2 worden maar gewoon b += 2?
Ik geloof niet dat je zoiets zomaar kan doen met arrays (tenzij ze een functie-argument zijn, want dan zijn het gewoon pointers).quote:
[..]
Ok dus als ik het goed begrijp moet de laatste regel niet
*(b) += 2 worden maar gewoon b += 2?
klopt, dat bedacht ik me dus na de uitleg ook... is gewoonquote:
[..]
Als een pointer 1 byte was, en dus 256 mogelijke waarden had, dan had je maar 256 bytes kunnen adresseren he...
Array's zijn toch stiekem gewoon altijd pointers???quote:
[..]
Ik geloof niet dat je zoiets zomaar kan doen met arrays (tenzij ze een functie-argument zijn, want dan zijn het gewoon pointers).
In principe wel, maar er zijn wat subtiele verschillen.quote:
[..]
Array's zijn toch stiekem gewoon altijd pointers???
Nee, *a is geen adres van b: a is het adres van b. *a is de eerste waarde uit b.quote:
Nu runt dit wel maar echter krijg ik dan een foute berekening, omdat ik geloof de laatste stement *(b) += 2 fout is. Kan iemand me ook vertellen waarom die fout is, ik geloof dat dat "*a" een adres is van b maar wat is "a" dan?
Wat probeer je te doen? Zoals tha_bit al zei, zijn jouw a[1] = iets en *(b + 1) = iets gelijk aan elkaar, omdat a het adres van de array b bevat en de operator[] onder water hetzelfde doet als jij in je tweede voorbeeld. (Trouwens, een leuk detail dat hieruit volgt is dat b[2] identiek is aan 2[b]; dit mag in C(++) ook zo worden gebruikt. Probeer maar...)
De tweede regels zijn niet gelijk aan elkaar. De code a += 2 schuift de pointer a twee adressen op (afhankelijk van de lengte van de array kan dit dus problemen opleveren). De code *b += 2 verhoogt de waarde van b[0] met 2.
Zoals tha_bit ook al zei, kan je niet b += 2 schrijven, omdat het adres waar b naar wijst niet veranderd mag worden.
Een array kan je zien als een const pointer (technisch is het een geheugenadres: de compiler vervangt de arraynaam direct door een adres en maakt dus geen variabele aan). De waarde van b mag dus niet veranderd worden, maar die van *b wel (want een arraynaam 'is' een constante pointer, geen pointer naar een constante). De uitzondering hierop zijn arrays als functie-argumenten (zoals argv[]): dit zijn altijd pointers. (Dit komt doordat de compiler gedwongen wordt het geheugenadres wel een naam te geven als deze aan een functie wordt doorgegeven.)
Dit mag dus niet. Nogmaals: wat wil je bereiken? Als je met een pointer over de array wilt itereren, heb je expliciet een pointer nodig omdat je b niet mag wijzigen.quote:Ok dus als ik het goed begrijp moet de laatste regel niet
*(b) += 2 worden maar gewoon b += 2?
en ja dat laatste wou ik dus Ander vraagje... is het mogelijk om deze expressie korter op te schrijven?
(x >> 16) & 0xff ?
Is het mogelijk dit om te schrijven naar een expressie met maar 1 actie? Geloof 't niet he?
een integer.quote:
Ja 32 bits en nice!!! Even proberen!quote:Op donderdag 17 november 2011 10:52 schreef thabit het volgende:
Hoeveel bits? Als het er 32 zijn, is de &0xff-stap niet nodig.
-edit-
Hmmm nee klopt niet. Wanneer ik de stap weghaal krijg ik een andere output.
Dit is eigenlijk me regel;
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff]
(s1 >> 16) & 0xff en (s2 >> 8) & 0xff is dus hetgene waar het over gaat en s0, s1, s2, s3 zijn alle unsigned integers.
[ Bericht 29% gewijzigd door Dale. op 17-11-2011 11:01:21 ]
Ja idd. Maar als ik alleen de & 0xff weghaal bij (s1 >> 16) dan verandert de output.quote:
Bij 8 kun je de &0xff niet weglaten uiteraard.
Ja ok, maar het gaat in dit geval niet om netjes maar puur om snelheid en dus zo min mogelijk operaties en zo efficiënt mogelijk gebruik van het geheugen en de beschikbare operaties.quote:
Als je 'netjes' wilt programmeren, moet je dit soort truuks sowieso vermijden. Zeker bij integertypes die je voor indexering gebruikt moet de code gewoon werken onafhankelijk van het aantal bits waaruit deze integers bestaan. Er bestaat een typedef die size_t heet. Die kiest automatisch het juiste integertype voor adressering; dat zal doorgaans een 32-bits integer zijn op een 32-bits syteem en een 64-bits integer op een 64-bits systeem.
Dit is het gehele algorithme trouwens, rijndael algo.
SPOILER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104unsigned int hive_rk[RKSIZE];
unsigned int hive_key[KEYLENGTH(KEYBITS)];
unsigned char hive_plaintext[16];
unsigned char hive_ciphertext[16];
void rijndaelEncrypt(void) ENTRY
{
unsigned int s0, s1, s2, s3, t0, t1, t2, t3, *rk = hive_rk;
/**
* map byte array block to cipher state
* and add initial round key:
*/
s0 = GETU32(hive_plaintext ) ^ rk[0];
s1 = GETU32(hive_plaintext + 4) ^ rk[1];
s2 = GETU32(hive_plaintext + 8) ^ rk[2];
s3 = GETU32(hive_plaintext + 12) ^ rk[3];
// round 1:
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[ 4];
t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[ 5];
t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[ 6];
t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[ 7];
// round 2:
s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[ 8];
s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[ 9];
s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[10];
s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[11];
// round 3:
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[12];
t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[13];
t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[14];
t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[15];
// round 4:
s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[16];
s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[17];
s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[18];
s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[19];
// round 5:
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[20];
t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[21];
t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[22];
t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[23];
// round 6:
s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[24];
s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[25];
s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[26];
s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[27];
// round 7:
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[28];
t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[29];
t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[30];
t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[31];
// round 8:
s0 = Te0[t0 >> 24] ^ Te1[(t1 >> 16) & 0xff] ^ Te2[(t2 >> 8) & 0xff] ^ Te3[t3 & 0xff] ^ rk[32];
s1 = Te0[t1 >> 24] ^ Te1[(t2 >> 16) & 0xff] ^ Te2[(t3 >> 8) & 0xff] ^ Te3[t0 & 0xff] ^ rk[33];
s2 = Te0[t2 >> 24] ^ Te1[(t3 >> 16) & 0xff] ^ Te2[(t0 >> 8) & 0xff] ^ Te3[t1 & 0xff] ^ rk[34];
s3 = Te0[t3 >> 24] ^ Te1[(t0 >> 16) & 0xff] ^ Te2[(t1 >> 8) & 0xff] ^ Te3[t2 & 0xff] ^ rk[35];
// round 9:
t0 = Te0[s0 >> 24] ^ Te1[(s1 >> 16) & 0xff] ^ Te2[(s2 >> 8) & 0xff] ^ Te3[s3 & 0xff] ^ rk[36];
t1 = Te0[s1 >> 24] ^ Te1[(s2 >> 16) & 0xff] ^ Te2[(s3 >> 8) & 0xff] ^ Te3[s0 & 0xff] ^ rk[37];
t2 = Te0[s2 >> 24] ^ Te1[(s3 >> 16) & 0xff] ^ Te2[(s0 >> 8) & 0xff] ^ Te3[s1 & 0xff] ^ rk[38];
t3 = Te0[s3 >> 24] ^ Te1[(s0 >> 16) & 0xff] ^ Te2[(s1 >> 8) & 0xff] ^ Te3[s2 & 0xff] ^ rk[39];
rk += 40;
/**
* apply last round and
* map cipher state to byte array block:
*/
s0 = (Te4[(t0 >> 24) ] & 0xff000000)
^ (Te4[(t1 >> 16) & 0xff] & 0x00ff0000)
^ (Te4[(t2 >> 8) & 0xff] & 0x0000ff00)
^ (Te4[ t3 & 0xff] & 0x000000ff)
^ rk[0];
PUTU32(hive_ciphertext, s0);
s1 = (Te4[(t1 >> 24) ] & 0xff000000)
^ (Te4[(t2 >> 16) & 0xff] & 0x00ff0000)
^ (Te4[(t3 >> 8) & 0xff] & 0x0000ff00)
^ (Te4[ t0 & 0xff] & 0x000000ff)
^ rk[1];
PUTU32(hive_ciphertext + 4, s1);
s2 = (Te4[(t2 >> 24) ] & 0xff000000)
^ (Te4[(t3 >> 16) & 0xff] & 0x00ff0000)
^ (Te4[(t0 >> 8) & 0xff] & 0x0000ff00)
^ (Te4[t1 & 0xff] & 0x000000ff)
^ rk[2];
PUTU32(hive_ciphertext + 8, s2);
s3 = (Te4[(t3 >> 24) ] & 0xff000000)
^ (Te4[(t0 >> 16) & 0xff] & 0x00ff0000)
^ (Te4[(t1 >> 8) & 0xff] & 0x0000ff00)
^ (Te4[ t2 & 0xff] & 0x000000ff)
^ rk[3];
PUTU32(hive_ciphertext + 12, s3);
return;
}
[ Bericht 89% gewijzigd door Dale. op 17-11-2011 11:36:29 ]
In elk geval is het zo dat de performance bottleneck vaak op hele andere plekken ligt dan het zo efficiënt mogelijk uitvoeren van elementaire bitoperaties.
kan toch met 1 move?quote:
Ander vraagje... is het mogelijk om deze expressie korter op te schrijven?
(x >> 16) & 0xff ?
| 1 | ((unsigned char*)x)[2] |
Maar pas op met portability: endianness van je systeem maakt dan plotseling uit!
Dit is zeker niet sneller. Om te adresseren zal de compiler het namelijk terug moeten casten naar een 32-bits integer.quote:
[..]
kan toch met 1 move?
[ code verwijderd ]
Maar pas op met portability: endianness van je systeem maakt dan plotseling uit!
| 1 2 3 4 5 6 7 8 9 10 11 | unsigned long tr1[255]; unsigned long t1(unsigned int x) { return tr1[(x>>16) & 0xff]; } unsigned long t2(unsigned int x) { return tr1[((unsigned char*)&x)[2]]; } |
en dit in GCC met -O2 optimalisatie gegooid, en in beide gevallen wordt de functie gecompileerd tot:
| 1 2 3 4 5 6 | pushl %ebp movl %esp, %ebp movzbl 10(%ebp), %eax popl %ebp movl tr1(,%eax,4), %eax ret |
oftewel: hij pakt idd maar 1 byte uit x en die wordt geexpand tot long om te kunnen indexen. GCC vindt een move dus ook sneller dan bitshiften + masken!
Maar goed, conclusie: een compiler is slim genoeg om dat ook te bedenken, dus met herschrijven win je niks aan performance (maar je verliest wat leesbaarheid).
Ander idee: je algorimte doet netjes steeds hetzelfde op 4 integers; kun je er geen SIMD variant van bouwen? Al blijft je lookup-table dan waarschijnlijk nog steeds de bottleneck...
Probeer eens of de extra compileroptie -fomit-frame-pointer een nog snellere output geeft. Al dat ge-ebp lijkt me een beetje onnodig hier.
.Zowel met GCC als met Microsoft Visual C(++) kun je trouwens vrij eenvoudig aangeven dat je de assembly listings van de compiler ook wil hebben: GCC met de -S switch, en in MSVC kun je in de eigenschappen van je project, bij de C compiler instellingen aangeven dat je een assembly listing (en wat je daar allemaal in wil hebben) als onderdeel van je "output files" wil hebben.
Ommitten van framepointers en __fastcall achtige dingen zetten meestal geen zoden aan de dijk (en maken debuggen een stukje lastiger). Als er echt een punt is waar dat zinnig zou zijn, kun je die functies inline-en...
mijn g++ compiler pakt -s ook maar ik kan de file niet terug vinden
het is -S met een hoofdletter. Als je een outputfile specificeert wordt de assembly daarin gemikt. Geef je geen outputfile, neemt 'ie de basis-bestandsnaam van je C file, en geeft 'm een ".s" extentie
Als ik een deel van mijn code wil debuggen doe ik nogal omslachtig. Ik maak een nieuwe project (in Eclipse) kopieer de betreffende files naar de nieuwe map en maak daar een main file om wat tests uit te voeren.
Als het klaar is, kopieer ik de files weer terug naar mijn oorspronkelijke project zodat ik zeker weet dat ik de laatste versie heb.
Kan dat niet makkelijk? Hoe doen jullie dat?
Ik gebruik zelf gewoon een versiebeheersysteem voor zoiets. Je kan dan lekker lopen klooien; met 1 commando is alles toch weer teruggedraaid.quote:
Klein vraagje:
Als ik een deel van mijn code wil debuggen doe ik nogal omslachtig. Ik maak een nieuwe project (in Eclipse) kopieer de betreffende files naar de nieuwe map en maak daar een main file om wat tests uit te voeren.
Als het klaar is, kopieer ik de files weer terug naar mijn oorspronkelijke project zodat ik zeker weet dat ik de laatste versie heb.
Kan dat niet makkelijk? Hoe doen jullie dat?
[ Bericht 0% gewijzigd door thabit op 21-11-2011 19:01:35 ]
Ik doe het voorlopig wel zo, eerst maar eens de basis van c++ onder de knie krijgen. (ik zit al uren te kloten om een functie uit een andere class aan te roepen
)Ik doe het idd meestal op de zelfde manier alleen maak ik een nieuw bestand test.cpp aan die ik dan compileer
Soms debug ik ook terwijl het programma'tje draait maar daar gebruik ik dan cheat engine voor
ik heb dit stukje code:
| 1 2 3 4 5 6 7 8 9 | SOCKET hSocket = INVALID_SOCKET; try{ std::cout << "Creating socket... "; if((hSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_ICMP)) == INVALID_SOCKET){ std::cout << "Failed!\n"; throw Error(); } std::cout << "Done.\n"; |
Ik snap alleen niet waarom dat fout gaat, het is uiteindelijk de bedoeling dat het programma ping acties kan uitvoeren (nee het is niet mogelijk om de ping.exe te gebruiken), kan iemand mij helpen?
1 van de verschillen tussen de voorbeeldcode uit MSDN en jouw code, is dat zei getaddrinfo() gebruikten om een geldige combinatie van parameters voor socket() te vinden...
Die zie ik er namelijk niet tussen staan (maar de compiler pakt hem wel)
in ieder geval bedankt voor de link er staat idd best nuttige info tussen
Je bent te onduidelijk in wat je wilt. Als je gerichter advies wilt, dan zul je beter moeten omschrijven wat je wilt bereiken.quote:Popen is een optie en volgens mij moet dat wel kunnen werken, maar zijn er ook alternatieven?
Als de broncode van scanimage openbaar is, kan je daarvan gebruik maken. Dit is echter meestal erg complex om aan de praat te krijgen bij programma's van meer dan minimale grootte.
Wat betreft popen: pipes zijn een laatste redmiddel dat je alleen wilt gebruiken als je geen andere mogelijkheden hebt. In veel gevallen kan je beter een extern programma uitvoeren voordat je jouw programma start of met een system-call waarin je de uitvoer naar een bestand laat schrijven.
Alleen als je interactief met een extern programma wilt werken, moet je pipes overwegen. In alle andere gevallen verwacht ik dat er betere oplossingen zijn.
[ Bericht 0% gewijzigd door GS42 op 02-02-2012 20:00:31 ]
Ik wil in een programma gebruik maken van scanimage, zodat de gebruiker het niet hoeft te doen. In principe kan de gebruiker dat handmatig doen in command line. Het is enkel instructie opgeven en resultaat afvangen, meer interactie is niet nodig. Ik heb geen idee hoe ik specifieker kan zijn. Een system-call lijkt mij niet handig, want ik wil juist automatiseren. Broncode downloaden en verwerken in mijn programma is wel een nette oplossing, maar misschien te veel moeite voor mijn relatief klein project. Bedankt iig voor je reactie.quote:
[..]
Je bent te onduidelijk in wat je wilt. Als je gerichter advies wilt, dan zul je beter moeten omschrijven wat je wilt bereiken.
Als de broncode van scanimage openbaar is, kan je daarvan gebruik maken. Dit is echter meestal erg complex om aan de praat te krijgen bij programma's van meer dan minimale grootte.
Wat betreft popen: pipes zijn een laatste redmiddel dat je alleen wilt gebruiken als je geen andere mogelijkheden hebt. In veel gevallen kan je beter een extern programma uitvoeren voordat je jouw programma start of met een system-call waarin je de uitvoer naar een bestand laat schrijven.
Alleen als je interactief met een extern programma wilt werken, moet je pipes overwegen. In alle andere gevallen verwacht ik dat er betere oplossingen zijn.
Ik zou geen C++ gebruiken voor zulke simpele handelingen.quote:
[..]
Ik wil in een programma gebruik maken van scanimage, zodat de gebruiker het niet hoeft te doen. In principe kan de gebruiker dat handmatig doen in command line. Het is enkel instructie opgeven en resultaat afvangen, meer interactie is niet nodig. Ik heb geen idee hoe ik specifieker kan zijn. Een system-call lijkt mij niet handig, want ik wil juist automatiseren. Broncode downloaden en verwerken in mijn programma is wel een nette oplossing, maar misschien te veel moeite voor mijn relatief klein project. Bedankt iig voor je reactie.
De handelingen die ik met het resultaat wil doen zijn minder simpel.quote:
[..]
Ik zou geen C++ gebruiken voor zulke simpele handelingen.
Specifieker hoeft niet, denk ik.quote:Het is enkel instructie opgeven en resultaat afvangen, meer interactie is niet nodig. Ik heb geen idee hoe ik specifieker kan zijn. Een system-call lijkt mij niet handig, want ik wil juist automatiseren
Een system call lijkt me in dit geval juist ideaal. Kijk eens naar de system() functie, waarmee je de shell aan kunt roepen vanuit je programma. Zo kun je jouw externe programma automatisch aan laten roepen. Als je de uitvoer van het programma nodig hebt, kan je die doorsturen een een bestandje en deze later uitlezen (denk aan "ls > .temp.txt" ofzo). Als de uitvoer een nieuwe bestand is (zoals ik verwacht van scanimages) hoef je die moeite niet eens te doen.Denk je dat je dit kunt gebruiken of zie ik iets over het hoofd?
Voor de werking lijkt het erg op pipes (in deze simpele vorm). Bedankt voor het advies, ik ga ermee aan de slag.quote:
[..]
Specifieker hoeft niet, denk ik.
Denk je dat je dit kunt gebruiken of zie ik iets over het hoofd?
Tabel klas
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import java.util.*; public class Klas { private ArrayList<Student> klas; public Klas() { ArrayList klas = new ArrayList<Student>(); } public void printoverzicht() { for(Student a : klas) { System.out.println(a.getNaam()); } } } |
tabel Student
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | public class Student { public String naam; public String woonplaats; public Student(String n, String w) { naam=n; woonplaats=w; } public String getNaam() { return naam; } } |
Bedankt alvast !
Twee opmerkingen over de manier waarop je de code presenteert:quote:
We zijn net begonnen met java en daarom een hele domme vraag, maar waarom krijg ik een foutmelding dat Student a leeg is ?
Tabel klas
[ code verwijderd ]
tabel Student
[ code verwijderd ]
trouwens, krijg het niet voor elkaar om de code in een code tag te zetten ? Ook kan ik mijn post niet previewen.
Bedankt alvast !
(1) Inspringen, dat bovenste blok is zo niet leesbaar.
(2) Geef een zo kort mogelijk doch volledig programma (dus inclusief main) dat runt en de foutmelding geeft.
Verder is Java natuurlijk geen C++. Het lijkt van de buitenkant erg op elkaar, maar onder de motorkap zijn er nog wel behoorlijke verschillen.
Dit dus, maar aangezien er geen java voor dummy's topic lijkt te bestaan vergeef ik het jequote:
[..]
Twee opmerkingen over de manier waarop je de code presenteert:
(1) Inspringen, dat bovenste blok is zo niet leesbaar.
(2) Geef een zo kort mogelijk doch volledig programma (dus inclusief main) dat runt en de foutmelding geeft.
Verder is Java natuurlijk geen C++. Het lijkt van de buitenkant erg op elkaar, maar onder de motorkap zijn er nog wel behoorlijke verschillen.
Maar volgens mij komt het gewoon omdat je een lege arraylist copieërt naar de (als het goed is ook lege) arraylist.
| 1 | ArrayList klas = new ArrayList<Student>(); |
#include <iostream>
using namespace std;
int main()
{
char line[100];
cout << "Voer een lijn in" << endl;
cin.getline( line, 100);
cout << line;
system ("PAUSE");
return 0;
}
Oké deze werkt. Maar in de aanwijzing bij de opgave staat dat ik moet inlezen met cin.getline(const char* stg, Int len).
Dat lukt me dus niet. Ik snap wel dat je in deze versie netjes met een pointer werkt. Maar m'n compiler geeft foutmeldingen.
werkt het niet...
(Ik weet overigs niet of ik het helemaal goed heb, ben relatief gezien ook nog een beginner.)
Maar je leest de string in op regel 7, via een pointer dus? Hoe mag die wel constanten zijn?
Behh ik snap het niet.
#include <iostream>
using namespace std;
int main()
{
char line[100];
cout << "Voer een lijn in" << endl;
cin.getline(const char *line, 100);
cout << line <<endl;
system ("PAUSE");
return 0;
}
zegt:
expected primary-expression before "const"
| 1 2 3 4 | char line[100]; // Hiermee reserveer je 100 karakters cout << "Voer een lijn in" << endl; // Vraag wat invoer aan de gebruiker cin.getline(line, 100); // Lees 100 karakters en schrijf deze weg naar line. cout << line <<endl; // Output line |
Ik zou een ander boek pakken.quote:
Maar in de aanwijzing bij de opgave staat dat ik moet inlezen met cin.getline(const char* stg, Int len).
. Een const char* is een pointer naar een const char. Dit zou suggereren dat de functie de chars in stg niet verandert, wat-ie natuurlijk wel doet. Die functie heeft dus een gewone char* als input, niet een const char*.Heb ik ook weer wat geleerd. Ik dacht dat een const char* een const pointer was naar een char.quote:Op zaterdag 11 februari 2012 19:39 schreef thabit het volgende:
[..]
Een const char* is een pointer naar een const char.
Een const pointer naar een char is char* const.quote:
[..]
Heb ik ook weer wat geleerd. Ik dacht dat een const char* een const pointer was naar een char.
En dan nu de ultieme test: wat is een char const* ?
In totaal heb je 4 mogelijkheden:quote:
[..]
Een const pointer naar een char is char* const.
En dan nu de ultieme test: wat is een char const* ?
• pointer naar char (char*)
• const pointer naar char (char* const)
• pointer naar const char (const char*)
• const pointer naar const char (char const * const)
Ik denk dat er meerdere schrijfnotaties zijn en dat char const* hetzelfde is als const char* (pointer naar een const char)
Juist.quote:
[..]
In totaal heb je 4 mogelijkheden:
• pointer naar char (char*)
• const pointer naar char (char* const)
• pointer naar const char (const char*)
• const pointer naar const char (char const * const)
Ik denk dat er meerdere schrijfnotaties zijn en dat char const* hetzelfde is als const char* (pointer naar een const char)
Lekker dan.... 't is een dictaat van een docent btw, maar de eerste hoofdstukken mogen toch wel goed zijn anders wordt het pittig.quote:
[..]
Ik zou een ander boek pakken.
Btw, kun je "wat-ie natuurlijk wel doet" toelichten?
quote:
Op 
De chars in stg (en dus line) wil je kunnen aanpassen, anders kan je wel leuk chars gaan intypen maar niet opslaan en gebruiken in je programma.quote:
[..]
Lekker dan.... 't is een dictaat van een docent btw, maar de eerste hoofdstukken mogen toch wel goed zijn anders wordt het pittig.
Btw, kun je "wat-ie natuurlijk wel doet" toelichten?
Dit is de code:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 | int main(){ WSAData wsaData; sockaddr_in dest,local; std::cout << "Inizializing... "; if(WSAStartup(MAKEWORD(2,0),&wsaData) == 0){ if(LOBYTE(wsaData.wVersion) >= 2){ std::cout << "Done.\n"; } else std::cout << "Failed!\nRequired version not supported.\n"; local.sin_family = AF_INET; local.sin_addr.s_addr = inet_addr(IP_SOURCE); local.sin_port = 0; dest.sin_family = AF_INET; dest.sin_addr.s_addr = inet_addr(IP_DESTINATION); dest.sin_port = 0; try{ SOCKET hSocket; std::cout << "Creating Socket... "; if(hSocket = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP) == INVALID_SOCKET){ std::cout << "Failed!\n"; throw Error(); } std::cout << "Done.\n"; std::cout << "Binding... "; if(bind(hSocket,(sockaddr*)&local,sizeof(local)) != 0){ std::cout << "Failed!\n"; std::cout << "WSA Last Error: " << WSAGetLastError() << '\n'; throw Error(); } std::cout << "Done.\n"; ICMPHeader ICMP; ICMP._TYPE = 8; // echo-request ICMP._CODE = 0; ICMP._CHECKSUM = 0; std::cout << "Sending... "; if(sendto(hSocket,(char*)&ICMP,sizeof(ICMP),0,(sockaddr*)&dest,sizeof(dest)) == SOCKET_ERROR){ std::cout << "Failed!\n"; throw Error(); } std::cout << "Done.\n"; } catch(Error){} std::cout << "Cleaning up... "; if(WSACleanup()!= 0){ std::cout << "Failed!\n"; return -1; } else std::cout << "Done.\n"; } else std::cout << "Failed!\n"; return 0; } |
Maar daarvoor heb ik al gekeken of de socket valid is en dat zou het geval moeten zijn, zou iemand mij kunnen uitleggen waarom dit niet werkt en hoe ik dit zou kunnen oplossen?
Als ik compileer, geeft de compiler een waarschuwing op de regel
| 1 | if(hSocket = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP) == INVALID_SOCKET){ |
Zie je wat daar fout gaat? Deze regel corrigeren lost volgens mij het bind-probleem op.
PS: Je code was niet gemakkelijk te compileren. Als je sneller antwoord wilt, zorg dan dat je ook de nodige headers in de code zet, erbijzet met welke libraries je linkt en eventueel ontbrekende of overbodige klassen (ICMPHeader?) verduidelijkt.SPOILERHet if-statement wordt - omdat == (equals) een hogere prioriteit heeft dan = (assignment) - gelezen als:
1 hSocket = ( socket(AF_INET,SOCK_RAW,IPPROTO_ICMP) == INVALID_SOCKET )
Dit betekent dat er eigenlijk staat: hSocket = true/false (afhankelijk van het succes van socket()). Omdat een SOCKET onder water gewoon een int is, wordt dit automatisch omgezet naar 1 of 0 en geeft de toekenning geen compileerproblemen.
Oplossing: gebruik haakjes om toekenningen als je tegelijk de waarde evalueert. De compiler controleert hierop.
Ow, enne ik Krijg geen waarschuwing van mijn compiler wat zou die waarschuwing moeten zijn?
| 1 | if( (hSocket = socket(AF_INET,SOCK_RAW,IPPROTO_ICMP)) == INVALID_SOCKET ) |
[ Bericht 0% gewijzigd door Ai_KaRaMBa op 14-02-2012 14:52:20 ]
dit is best wel heel stom
Oh, ik dacht dat de spoiler wel duidelijk genoeg was. Maar je hebt het probleem nu gevonden.quote:
Um, bij mijn weten probeerd ie eerst de socket te maken en checkt ie daarna of dat gelukt is. Maar dit is dan niet zo? Want deze manier van fout controle heb ik ook ooit eens in een tut voor tcp gezien.
Ow, enne ik Krijg geen waarschuwing van mijn compiler wat zou die waarschuwing moeten zijn?
De waarschuwing die mijn compiler (g++ 4.5) geeft is
Als je waarschuwingen wilt zien, moet je meestal een flag meegeven (in mijn geval -wall).quote:In function 'int main()':
warning: suggest parentheses around assignment used as truth value
Graag gedaan.
Hehe, had die hele spoiler niet gezien....quote:
[..]
Oh, ik dacht dat de spoiler wel duidelijk genoeg was. Maar je hebt het probleem nu gevonden.
De waarschuwing die mijn compiler (g++ 4.5) geeft is
[..]
Als je waarschuwingen wilt zien, moet je meestal een flag meegeven (in mijn geval -wall).
Graag gedaan.
ik gebruik G++ moet volgensmij idd -wall maar zonder params krijg je wel gewoon waarschuwingen over data types zoals if(unsigned i < 0 ) dat die altijd waar is ed.
struct ICMPHeader{
unsigned char _TYPE;
unsigned char _CODE;
unsigned short _CHECKSUM;
};
type = 8 en de rest is 0.
Weet iemand wat dat stuk aan data kan zijn? Overigens duurt het ook vrij lang voordat ik reactie krijg (>30 sec), terwijl ik via ping gemiddeld iets van 1 a 2 ms krijg...
Reicieve Buffer Dump (IP-Header is weggelaten):
SPOILEREDIT: dumpfile weg gehaald
1e kolom als char, 2e decimaal, 3e hexadecimaal
[ Bericht 60% gewijzigd door netolk op 17-02-2012 18:32:32 ]
Daarnaast heb ik het idee dat het pakket dat je verstuurt, niet genoeg data bevat. Lees deze website maar eens goed door, daar staan de specs duidelijk op.
Het lukt mij met het volgende (zelf geschreven) pakket:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | struct ICMPHeader { unsigned int type : 8; unsigned int code : 8; unsigned int checksum : 16; }; struct ICMPPing : ICMPHeader { unsigned int ident : 16; unsigned int sequence : 16; unsigned char data[32]; }; ICMPPing ping; ping.type = 8; ping.code = 0; ping.checksum = 0; ping.ident = 0; ping.sequence = 0; memcpy(ping.data, "abcdefghijklmnipqrstuvwxyz012345", 32); |
Maar verder ben ik bang dat je het vooral zelf uit moet puzzelen.
Ik denk dat ik die site idd maar eens grondig door zal gaan nemen
in iedergeval bedankt voor de hulp
| 1 | double my_func(double (*my_arg)(double(*)(double)) |
Ik snap dat bijv:
| 1 | double my_func(double (*my_arg)(double)) |
een pointer is naar een functie met als returntype double, maar ik snap niet wat die (double) erachter doet. Betekent dat dat de functie double my_arg één double accepteert als argument? En double (*my_arg)(double (*)(double) verwart me al helemaal
.[ Bericht 6% gewijzigd door Luchtkoker op 19-02-2012 20:05:40 ]
Ten eerste, je bovenste stukje code is geen valide C++ omdat er een haakje ontbreekt; ik neem aan dat er nog een ')' aan het einde moet staan.
Dat klopt niet, my_func is hier geen pointer naar een functie. Vervang...quote:Ik snap dat bijv:1 [code]double my_func(double (*my_arg)(double))[/code]
een pointer is naar een functie met als returntype double
| 1 | double (*my_arg)(double) |
| 1 | double a |
Je eerste voorbeeld is zo gemakkelijker te lezen:
| 1 2 3 4 5 | double my_func( double (*my_arg)( double(*)(double) ) ); |
Kom je er zo uit?
Verder snap ik het nog niet helemaal
Ik bedoelde ook niet dat my_func een pointer naar een functie was, maar my_arg. Maar goed, ik snap nog steeds niet wat bijv double(*)(double) is.Eerder in dit topic zijn al de std::thread en de move semantics van r-value references genoemd, maar er is nog veel meer toegevoegd. Zo zijn er 4 nieuwe fundamentele types (long long int, char16_t, char32_t en std::nullptr_t, waarbij vooral de laatste conceptueel interessant is), nieuwe keywords (zoals constexpr en auto) en zowel uitbreidingen op de core (zoals anonieme functies en de r-value references) als op de STL (zoals std::thread en std::unordered_map).
Ik compileer eigenlijk altijd met -std=c++0x. Een van de simpelste dingen die ik veel gebruik is het nieuwe parsen van >>. In eerdere versies van C++ is het volgende een compileerfout omdat de >> gelezen wordt als een right shift:
| 1 | std::vector<std::pair<int, int>> vb; |
In de nieuwe C++ versie is dit echter aangepast, zodat er geen spatie meer tussen hoeft. De std::unordered_map gebruik ik ook als ik een hashtable nodig heb. Als een klasse dynamisch geheugen gebruikt, geef ik die ook move-mogelijkheid (maar dit gebeurt niet erg vaak). De lambda's zijn, net als auto een mooie toevoeging die ik ook wel gebruik als het handig is.
Ik stel de vraag omdat ik benieuwd ben of de nieuwe C++ toevoegingen ook al onderwezen en gebruikt worden. In plaats van functiepointers (waar het hierboven over ging en die - zoals jullie zien - vreselijk lelijk zijn) is het bijvoorbeeld mogelijk om de nieuwe (en veel mooiere) std::function te gebruiken voor alles wat op een functie lijkt. Doen jullie dat ook?
Dus: wat gebruiken jullie in de praktijk van C++11?
Niet nodig? Te ingewikkeld? Geen compiler-ondersteuning? Nooit van gehoord? ...?
C/C++ gebruik ik voor low-level spul. Voor het hogere programmeerwerk gebruik ik Python.quote:
... Of, als jullie C++11 niet gebruiken, ben ik daar ook benieuwd naar hoor.
Niet nodig? Te ingewikkeld? Geen compiler-ondersteuning? Nooit van gehoord? ...?
Ik vind dat hele C++11 gedoe een beetje mosterd na de maaltijd om eerlijk te zijn. Er wordt gedaan alsof er allemaal nieuwe superfeatures in zitten, terwijl andere programmeertalen dit soort zaken jaren geleden al ondersteunden.
Ik denk niet dat mijn compiler het ondersteund aangezien ik een best oude gebruik omdat de nieuwe versie dll's mist oid. Maar die std::thread klinkt interessant, dat moet ik nu nog allemaal via windows doenquote:
... Of, als jullie C++11 niet gebruiken, ben ik daar ook benieuwd naar hoor.
Niet nodig? Te ingewikkeld? Geen compiler-ondersteuning? Nooit van gehoord? ...?
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | struct b8TOb16{ char _B0:8; char _B1:8; void set(char B0,char B1){_B0=B0;_B1=B1;} }; std::ofstream Write("Test.lvl",std::ios::binary); if(Write.is_open()){ b8TOb16 myb8TOb16; unsigned short _X=5,_Y=5,_Z=1; myb8TOb16 = *(b8TOb16*)(&_X); Write.put(myb8TOb16._B0); Write.put(myb8TOb16._B1); std::cout << int(myb8TOb16._B0) << '\t' << int(myb8TOb16._B1) << '\n'; Write.close(); } |
maar als ik later het bestand open en op deze manier uitlees:
| 1 2 | myb8TOb16.set(read.get(),read.get()); std::cout << *(unsigned short*)(&myb8TOb16) << '\n'; |
maar als ik het op deze manier doe:
| 1 2 3 | char temp1=read.get(),temp2=read.get(); myb8TOb16.set(temp1,temp2); std::cout << *(unsigned short*)(&myb8TOb16) << '\n'; |
| 1 | myb8TOb16.set(read.get(),read.get()); |
Het klassieke voorbeeld is:
| 1 2 | int i = 0; functie(i++, i++); |
Hierin weet je niet of functie(0, 1) aangeroepen wordt of functie(1, 0) omdat de compiler beide mag doen. In jouw geval worden de argumenten blijkbaar van rechts naar links verwerkt. Oplossing: minimaal 1 temp value gebruiken.
[ Bericht 2% gewijzigd door GS42 op 07-03-2012 18:12:00 ]
quote:
Je komt wel altijd met leuke voorbeelden.
[ code verwijderd ]
Deze regel in ongedefinieerd, omdat C++ de argumenten van de functie in willekeurige volgorde mag evalueren.
Het klassieke voorbeeld is:
[ code verwijderd ]
Hierin weet je niet of functie(0, 1) aangeroepen wordt of functie(1, 0) omdat de compiler beide mag doen. In jouw geval worden de argumenten blijkbaar van rechts naar links verwerkt. Oplossing: minimaal 1 temp value gebruiken.
, oke dat is idd wel stom , bedankt voor de uitlegC++11 is gewoon 'normaal C++', he? Het betreft een nieuwe versie, geen alternatief op de standaard ofzo. Natuurlijk is het wel zo dat de veranderingen niet zo belangrijk zijn als je net de taal leert, maar onderscheid tussen 'normaal C++' en C++11 is er niet.quote:Ik ga maar eerst normaal C++ verder leren, zodat ik het mogelijk nut van C++11 kan inzien.
Wordt er zo over gehyped? Dat heb ik niet zo meegekregen.quote:Ik vind dat hele C++11 gedoe een beetje mosterd na de maaltijd om eerlijk te zijn. Er wordt gedaan alsof er allemaal nieuwe superfeatures in zitten, terwijl andere programmeertalen dit soort zaken jaren geleden al ondersteunden.
Sommige dingen - auto, lambda's en range-based for loops bijvoorbeeld - zijn inderdaad syntactische suiker (zoals dat zo leuk wordt genoemd), namelijk manieren om iets mooier te schrijven zonder dat het verdere winst oplevert. De code wordt er misschien netter van, maar zeker niet sneller.
De twee dingen die echt de moeite waard zijn, vind ik de r-value references en de std::thread (met alle bijbehorende klasses). De r-value references kunnen bestaande code veel sneller maken en is dus relevant vanuit het oogpunt van efficientie, terwijl de multithread opties gewoon noodzakelijk zijn voor een moderne programmeertaal.
ik gebruik mingw op windows 7 64-bit
en nu krijg ik dus die geweldige error libgmp-10.dll, nu heb ik op internet gevonden dat ik mingw aan Path (of PATH??) moest toevoegen ofzo, maar ik heb dus geen idee hoe dat moet
Kan iemand mij hier mee helpen?
Let op dat je er geen dingen uit verwijdert en dat je nieuwe toevoeging achteraan zet. De entries worden gescheiden door punt-komma's. Waarschijnlijk voeg jij dus zoiets toe: ;C:/MinGW/bin/ (afhankelijk van waar je MinGW staat, natuurlijk).
Succes.
nu krijg ik alleen wel een hoop error's die ik met de vorige compiler niet kreeg
waaronder dat class-members private zijn terwijl de functie die ze bewerkt friend is van die class
en dit soort error's:
| 1 | error: using temporary as lvalue [-fpermissive] |
moet ik dingen dan anders gaan schrijven dan in C++ gebruikelijk is(/was)?
Kun je minimale code posten die dat soort foutmeldingen geeft? Je hebt grote kans dat de code sowieso al niet helemaal jofel was, maar dat de oude compiler het allemaal door de vingers zag.quote:
oke, na mn computer opnieuw te hebben opgestart bleek het wel te werken
nu krijg ik alleen wel een hoop error's die ik met de vorige compiler niet kreeg
waaronder dat class-members private zijn terwijl de functie die ze bewerkt friend is van die class
en dit soort error's:
[ code verwijderd ]
terwijl dit dus enum's zijn...
moet ik dingen dan anders gaan schrijven dan in C++ gebruikelijk is(/was)?
Ondertussen weet ik al waarom die class-members een error opleveren omdat ik een thread via windows maakte en dat nu oud is en niet meer ondersteund wordquote:
[..]
Kun je minimale code posten die dat soort foutmeldingen geeft? Je hebt grote kans dat de code sowieso al niet helemaal jofel was, maar dat de oude compiler het allemaal door de vingers zag.
maar dit stukje code blijft wel een error geven:
| 1 2 3 4 5 6 7 8 9 10 11 | struct Fluid{ enum Fluid_Type{ None, Fresh_Water,Salt_Water, Beer,Rum, Unknown }_TYPE; } _FLUID._TYPE = Fluid::None |
| 1 | error: using temporary as lvalue [-fpermissive] |
Ik wil leren ontwikkelen in C++. Hoe zijn jullie begonnen? En kan ik C++ applicaties werkende krijgen op Linux én Windows?
Ik ben ooit begonnen met een tut te volgen om pengo (een spel) te maken. Echter leer je hier niet zo veel van en heb ik toen een boek gekochtquote:Op vrijdag 9 maart 2012 08:21 schreef Computerfluisteraar het volgende:
Een vraagje aan de mensen met verstand van C++:
Ik wil leren ontwikkelen in C++. Hoe zijn jullie begonnen? En kan ik C++ applicaties werkende krijgen op Linux én Windows?
Het is inderdaad mogelijk om programma's voor zowel Linux al Windows te maken maar als je niet moeilijk wilt doen zal dat wel alleen in een console zijn
Is het onder Windows noodzakelijk Visual Studio te gebruiken? Verschilt de manier waarop je programma's schrijf onder Windows met Linux?quote:
[..]
Ik ben ooit begonnen met een tut te volgen om pengo (een spel) te maken. Echter leer je hier niet zo veel van en heb ik toen een boek gekocht
Het is inderdaad mogelijk om programma's voor zowel Linux al Windows te maken maar als je niet moeilijk wilt doen zal dat wel alleen in een console zijn
Bestaat er ook een Nederlandse uitgave van C++ voor Dummies?
Ik zou gewoon met iets als minGW compiler werken en iets van notepad++ (als kladblok) en dan gewoon beginnen of idd een IDE gebruiken maar dan zou ik persoonlijk niet voor Visual studio gaanquote:
Ik heb ook gehoord dat het goed is om te programmeren onder Linux, gezien je het systeem dan beter leert kennen. Hoe zit dat nou?
Oke, bedanktquote:
[..]
Ik zou gewoon met iets als minGW compiler werken en iets van notepad++ (als kladblok) en dan gewoon beginnen of idd een IDE gebruiken maar dan zou ik persoonlijk niet voor Visual studio gaan
Heb je al kennis van andere talen? C, Java, Basic?quote:
Ik heb ook gehoord dat het goed is om te programmeren onder Linux, gezien je het systeem dan beter leert kennen. Hoe zit dat nou?
Windows of Linux maakt vrij weinig uit. Ligt er een beetje aan wat je wilt, code maken die op zowel Windows als Linux draait blijft lastig en zou ik in het begin niet proberen.
Onder Windows sowieso voor Visual Studio gaan. Dat is niet voor niets de standaard in de commerciele softwarebedrijven. Alleen al vanwege de debugger stukken handiger dan een notepad en een losse compiler.
De gratis Express-versie is voor een beginner prima.
Nee, heb ik helaas niet. Ik denk dat ik standaard voor Linux wil gaan programmeren.quote:
[..]
Heb je al kennis van andere talen? C, Java, Basic?
Windows of Linux maakt vrij weinig uit. Ligt er een beetje aan wat je wilt, code maken die op zowel Windows als Linux draait blijft lastig en zou ik in het begin niet proberen.
Onder Windows sowieso voor Visual Studio gaan. Dat is niet voor niets de standaard in de commerciele softwarebedrijven. Alleen al vanwege de debugger stukken handiger dan een notepad en een losse compiler.
De gratis Express-versie is voor een beginner prima.
Ik zou voor Qt gaan.quote:
Een vraagje aan de mensen met verstand van C++:
Ik wil leren ontwikkelen in C++. Hoe zijn jullie begonnen? En kan ik C++ applicaties werkende krijgen op Linux én Windows?
Welk deel snap je niet van ik wil ontwikkelen in C++???quote:
In/Met Qt kan je c++-applicaties ontwikkelen die werken in Linux en Windows?quote:
[..]
Welk deel snap je niet van ik wil ontwikkelen in C++???
sorryquote:
[..]
In/Met Qt kan je c++-applicaties ontwikkelen die werken in Linux en Windows?
mijn fout, dacht dat het een andere taal wasmisschien moet ik de volgende keer eerst is kijken voordat ik onzin lul...
Die parameters worden direct aan main() gevoerd. Ik zie niet waarom je allerlei vage libraries daarvoor nodig zou hebben.quote:
Ik gebruik getopt om wat parameters binnen te halen zoals -h voor help en -s voor scan, maar ik heb nou er nog ééntje nodig voor save. De s is al 'bezet', dus ik wil van -s -scan maken. Moet ik per se een andere library gebruiken zoals getoptpp of kan ik wat aanpassen zodat zoiets ook mogelijk is met de standaard lib?
Is dit de beste IDE of zijn er nog meer die geschikt zijn?quote:
Qt is niet alleen een IDE, maar ook een UI cross-platform framework. http://qt.nokia.com/products/quote:
[..]
Is dit de beste IDE of zijn er nog meer die geschikt zijn?
[C(++)] voor dummies - Deel 4
[ Bericht 89% gewijzigd door FastFox91 op 12-03-2012 19:10:53 ]