C++

[ceeda]

Hallo iedereen, ik heb overmorgen examen C++.

Er kwam in een vorig examen een sleutelvraag voor met gis-correctie. Zeer belangrijk dus.

De vraag gaat over het hoofdstuk "Pointers".

Gegeven de volgende declaraties (die uiteraard in orde zijn!).Hierna volgen 10 toewijzingen of instructies. Omcirkel de korrekte en doorkruis de foute toewijzingen(elke fout wordt met -1 bestraft, elke juiste aanduiding met +1 beloond!)

int ch[20], c, *p, *s, q; double *k, tab[30]; char woord[20], letter;

woord[5] = letter; letter = woord[5] + 3; p = s - 7;

p = k - tab[2]; p = (k - &tab[2]) + s; letter = "woord";



*k = *p + 3.2; letter = letter + c; q = *(p - (k - tab));

ch[10] = (k - &tab[12]) + c;

Is er iemand die deze vraag zo snel mogelijk kan beantwoorden aub?

Heel erg bedankt

grtz C

[jhnbk]

Hetn forum "Site- en softwaregerelateerd" gaat specifiek over dit forum. Derhalve heb ik jouw topic naar het forum Praktische en overige technische wetenschappen > Programmeren verplaatst.

[Rogier]

Is er iemand die deze vraag zo snel mogelijk kan beantwoorden aub?

Ja maar daar leer je waarschijnlijk minder van dan als je het vanuit eigen begrip oplost.

Een paar hints: normale "single value" variabelen (int, char of double) mag je niet zomaar aan pointers toewijzen en andersom. Pointers mag je niet optellen. Pointers mag je wel van elkaar aftrekken, dat levert een adresverschil op en dat is een int. Ints mag je bij pointers optellen en aftrekken, dat levert weer een pointer op.

Hoe ver kom je zelf? Over welke twijfel je?

[ceeda]

mja ik heb beetje research gedaan en kom tot volgende vaststelling

- geen adressen optellen (wel aftrekken -> geeft een int)

- adressen zijn afhankelijk per type dus a=q kan niet!

- geen types gelijkstellen aan elkaar (behalve int en char)

- char = "woord" kan niet

klopt dit ongeveer?

[Rogier]

- adressen zijn afhankelijk per type dus a=q kan niet!

Klopt, al kun je ze wel converteren (casten). Maar pointers van verschillende types van elkaar aftrekken kan niet (zou ook niet logisch zijn, want het verschil wordt uitgedrukt in een aantal elementen, dan moeten die elementen wel hetzelfde zijn)

- geen types gelijkstellen aan elkaar (behalve int en char)

double = int mag ook, en (weliswaar met een warning) int = double ook

- char = "woord" kan niet

Een letterlijke string zoals "woord" is een array van chars. Dus char = "woord" kan inderdaad niet. Een *char = "woord" zou wel kunnen.

[ceeda]

toch heb ik bij 1 een probleempje:

p = *(q - (k - tabel));

hier geeft c++ geen fout wanneer ik er wel 1 verwacht. Ik denk dat als je gewoon tabel (zonder []) het adres word genomen en dan kom je ; k- tabel (2 adressen aftrekken) = int; q-int (adres - int mag dus); en dan neem je de waarde van het bekomen adres (door *) en geef je die waarde aan p.

Klopt dit? Of wat zou ik in de plaats van de prof antwoorden?

thx

[Rogier]

p = *(q - (k - tabel));

hier geeft c++ geen fout wanneer ik er wel 1 verwacht.

Dat lijkt me stug, want ongeacht waar je het aan toewijst (in dit geval p), alleen al die expressie rechts van de = is ongeldig.

Want k-tab(el?) is een verschil tussen twee pointers, dus een int. q is een int, dus q min dat vorige is weer een int.

Maar *(iets) wil zeggen: de waarde waar hetgeen tussen haakjes heen point, dus dan moet iets een pointer zijn, en geen int.

[ceeda]

Heel erg bedankt voor de informatie. Er is nog een vraagje ivm procedures en pointers:

We kregen de vraag



Schrijf een procedure om in een woord bestaande uit letters van 'a' tot 'z', welke reeds alfabetisch geordend zijn, een vooropgegeven letter in te voegen zodat in het nieuwe woord de letters opnieuw alfabetisch geordend zijn!(de in te voegen letter is opnieuw van 'a' tot 'z', onderstel verder dat er "plaats" genoeg is om een letter in te voegen!). Achteraf moet het nieuwe woord omgezet worden in hoofdletters. Gebruik enkel schuivende pointers!

na overleg leerkracht en medestudenten kwamen we dit uit:

void voeg (char *p, char l)

{

char *q; // hulp variabele

while (*p!='.') p++; // Naar het einde van de tabel gaan . is stopcode

p=p+1; // De volgende waarde in de tabel stopcode maken.

*p='.';

p--;

while(*p>l || *p=='.') //iedere waarde vgl met l, is de waarde groter, waarde = waarde vroeger in de tabel

{ cout<<*p<<endl;

q=p;

q--;

*p=*q;

p--; // teruglopen in de tabel

}

}

int main(void)

{ char l, char tabel[20]={'a','b','c','e','f','g','i','l','.'}, *p;

cout<<"geef l= "; cin>>l;

p=tabel;

voeg(p,l);

for (int i=0; tabel!=0; i++){ cout<<tabel;}

}

Onze prof zei dat hij op het examen een nieuwe soort vraag zal stellen :

van 'A' tot 'Z' nu , welke reeds omgekeerd (dalend!) alfabetisch geordend zijn, een vooropgegeven letter in te voegen zodat in het nieuwe woord de letters opnieuw omgekeerd(dalend) alfabetisch geordend zijn!(de in te voegen letter is opnieuw van 'A' tot 'Z', onderstel verder dat er "plaats" genoeg is om een letter in te voegen!). Achteraf moet het nieuwe woord omgezet worden in kleine letters. Gebruik enkel schuivende pointers!



Enig idee hoe dit op te lossen?

[Rogier]

na overleg leerkracht en medestudenten kwamen we dit uit:

Dat lijkt me fout, zo op het eerste gezicht voeg je de nieuwe letter (die char l) nergens toe in de lijst, check je niet of je misschien voorbij het begin van de lijst gaat (als er geen 'a' in zit en de nieuwe toe te voegen letter is een 'a' ga je volgens mij door random geheugen lopen ploegen), en het resultaat wordt niet naar hoofdletters omgezet.

En het lijkt me nodeloos ingewikkeld, waarom precies die q apart bijhouden? (dat kan ook met p[1] of p[-1], of *(p+1) resp. *(p-1) als je dat fraaier vindt).

Onze prof zei dat hij op het examen een nieuwe soort vraag zal stellen :

(...)

Enig idee hoe dit op te lossen?

Da's toch vrijwel exact hetzelfde probleem?

[Revelation]

Je functie is inderdaad niet echt de beste oplossing.

Wat vind je hiervan:

Code: Selecteer alles

#include <stdio.h>

int main(void)

{

char tabel[20]={'a','b','c','e','f','g','i','l','.'};

char ref ='d'; // hier je referentie

char* p = tabel;

while (*(p++) != '.'); // deze komt uit op einde + 1

while ((*(--p) > ref || (*p == '.')) && (p >= tabel))

 *(p + 1) = *p;

*(p + 1) = ref;

// als bonus: omzetting naar caps

for (p = tabel; *p != '.'; (*(p++) ^= 0x20)); // mooie ascii-hack

printf("%10s", tabel);

}

Alles wat je wilt in effectief 5 regels.

edit: kleine bufferfout, waar Rogier hierboven op wees gefixed.

[Rogier]

// als bonus: omzetting naar caps

for (p = tabel; *p != '.'; (*(p++) ^= 0x20)); // mooie ascii-hack

En deze kun je ook gebruiken voor die andere vraag, om caps naar lowercase om te zetten

[Cycloon]

Maar ik vermoed dat een docent zoiets niet graag zal hebben

[Vladimir Lenin]

Volledig mee eens. Hoewel overdrijven volgens mij ook niet goed is. In het begin begon ik zelfs elke lijn te becomentarieeren in de code