Ik denk dat ik het begin te snappen hoe het allemaal werkt, die pointers. Dat met die NULL snap ik niet. En ik las ook op wikibooks iets met new en delete bij de C++ pointers. Ik heb nu al een hele boel minder errors:
Code:
#include <iostream.h>
int get_maten(int demensie)
{
if(demensie == 2)
int arr[2];
else
int arr[3];
cout << "Geef de lengte: ";
cin >> arr[0];
cout << "Geef de breedte";
cin >> arr[1];
if(demensie == 3)
{
cout << "Geef de hoogte";
cin >> arr[2];
}
return arr;
}
bool check_maten(int demensie, int* arr)
{
if(arr[0] < 1 || arr[1] < 1 || (demensie == 3 && arr[2] < 1))
return false;
return true;
}
int get_opp_2d(int* arr)
{
return arr[0] * arr[1];
}
int get_opps_3d(int* arr)
{
int opp1 = arr[0] * arr[1];
int opp2 = arr[1] * arr[2];
int opp3 = arr[0] * arr[2];
int arr2[3] = { opp1, opp2, opp3 };
return arr2;
}
int get_volume_3d(int* arr)
{
return arr[0] * arr[1] * arr[2];
}
int main()
{
int demensie;
cout << "Is uw figuur 2D of 3D? [2/3]";
cin >> demensie;
if(demensie < 2 || demensie > 3)
cout << "Fout, de figuur moet ofwel 2D ofwel 3D zijn.";
else
{
int arr;
bool check;
arr = get_maten(demensie);
check = check_maten(demensie,&arr);
if(!check)
cout << "1 van de maten is kleiner dan 1 en is bijgevolg niet geldig/";
else
{
if(demensie == 2)
{
int opp;
opp = get_opp_2d(&arr);
cout << "De oppervlakte van deze figuur is " << opp << endl;
}
else
{
int opp[3];
int volume;
opp = get_opps_3d(&arr);
volume = get_volume_3d(&arr);
cout << "De oppervlakten zijn" << endl;
cout << opp[0] << endl << opp[1] << endl << opp[3] << endl << endl;
cout << "Het volume is " << volume << endl;
}
}
}
return 0;
}
Errors:
1) Bij die error op lijn 44 en 46 denk ik dat de fout hem zit bij die vermenigvuldiging. Ik geloof dat ie de vermenigvuldiging voor een pointer aanziet ofzo. Klopt dit?
2) Hoe kan ik die errors oplossen (met wat uitleg ook aub)?
3) Kan je dat met die NULL eens uitleggen?
4) Op wikibooks stond er wat van new en delete ivm pointers, kan je dit even toelichten?
5) Kan je wat extra info geven over memory leaks? Zijn deze gevaarlijk (hiermee bedoel ik, is dit een lek dat crackers kunnen gebruiken om hun malware te installeren)? Wat doen memory leaks?
6) Is het nuttig om bij de types bool en int gebruik te maken van pointers?
1) Ja, je can bv dit doen: const int lengte = arr[0] .. enzovoort en dan return (lengte*breedte*diepte)
4) pointers zijn enorm handig en je zult ze nog veel tegenkomen. een pointer is dus een adres van een bepaald type (DIT TYPE MOET BEPAALD ZIJN)
bv: int getal = 40;
int *ptr = &getal;
nu wijst de pointer naar het adres van getal.
dus als je nu doet cout << *ptr, dan krijg je de WAARDE waarnaar de poiner wijst
doe je cout << ptr, dan krijg je het adres van getal.
een array is eigenlijk een pointer met een vast aantal items erin.
bv als je hebt:
int arr[5]; dan heb je een array gemaakt met 5 plaatsen voor 5 ints. (dus telkens 2bytes) want een int is 2 bytes. in het geheugen ziet die array er dus uit als een aan-elkaar gekoppelde "lijn" van adressen die elk de grootte hebben van een int (2 bytes) dus je array is 10 bytes groot.
doe je nu dit:
int *ptr = &arr[0]; dan wijst deze pointer naar het eerste element van de array.
doe je cout << *ptr : dan krijg je het number dat in arr[0] zit
doe je cout << arr[0] : dan krijg je ook dat number
als je nu cout << arr[1] doet krijg je het nummer dat in arr[1] zit.
als je cout << *(ptr+1) doet dan krijg je ook het nummer dat in arr[1] zit.
wat gebeurt er nu ? eigenlijk doe je : cout << *(het adress van arr[0]+1) want ptr wijst naar arr[0]
maar een int is toch 2 bytes groot? als je er dan maar 1 bij het adres optelt krijg je toch niet het juiste ? inderdaad! maar je telt er 1 INT omdat de ptr van het type int is , dit doet de compiler automatish voor je.
je kan er ook bytes bij optellen, maar ik ben effe vergeten hoe dat moet.
new en delete kan je best later doen als je pointers helemaal snapt. het is niet zo moeilijk hoor.
een string is eigenlijk ook eenvaste aan elkaargekoppelde lijn van adressen net als een array, alleen is de inhoud van de string dynamish gealloceerd (met new en delete dus).
dus je kan een string net zo behandelen als een array en dus ook met pointers
bv:
string zin = "lolzor";
char *ptr = &zin;
cout <<zin[0] geeft "l"
cout <<*ptr geeft ook "l"
cout << zin[0]+(*(ptr+1))+zin[2] geeft "lol"
enzovoort.
5) Ja dat kan, meestal in de vorm van een buffer overflow. je kan zelf een memory leak programmeren als je dat wilt
je risceerd wel schade aan je computer natuurlijk.
er zijn veel soorten memory leaks, maar degene die jij bedoelt is waarschijnlijk die waar je de functie new gebruikt
bv:
int getal = 1;
int *pointer ;
while (true)
{
pointer = new int[getal]
}
wat je hier doet is een pointer zetten, en daarachter een lijn construeren van vaste adressen die een int bevatten
eigenlijk maak je dus een array die in omvang blijft toenemen, totdat je computergeheugen op is. en dan crashed je programma. dit is een gat in het programma waardoor crackers informatie kunnen stelen, stel maar eens dat dit probleem zig in je poortblocker voortdoet, als je poortblocker crashed heb je een open poort, waardoor aanvallers je informatie kunnen stelen ofzo.
delete dient om een adress van de zopas gemaakte "array" terug te geven aan het vrije geheugen, uit het "lijntje" verwijderen dus.
doe je nu delete[] pointer; dan vernietig je je lijntje en dan is dat geheugen weer vrij om door andere programmas gebruikt te worden.
wat is nu het nut van dynamic gealloceerde arrays? stell je wilt een naam opslaan in een array. je weet natuurlijk niet hoeveel letters de naam gaat bevatten die de gebruiker heeft. dus gebruik je new om een array te maken die net evengroot is als de aantal letters die zijn ingetypt.
als je een array hebt van 40 items groot waarvan er maar 10 gevult zijn, dat is ook maar niks, en dynamic allocatie geeft je de mogelijkheid om exact een array te maken van 10 als de gebruiker er 10 invult!
6) pointers zijn altijd nuttig
was wat lui.
het is toch niet dat je die waarde zou wille gaan veranderen in de functie. Dementies is op die wijze ook beveiligt in die functie, omdat je een copie geeft van dat getal. , voor die constanten kan je een pointer meegeven. maar wat is daar het nut van? ze zijn toch constant.
