🚀 go-pugleaf

Sjoerd Schreuder wrote in message <3C730AE7.40FF0F97@wanadoo.nl>...
>Stef wrote:
[diverse knipjes]
>> Ik zou niet weten waarom niet. Je hoeft mij geen cursus OO te geven, die
>> moet ik maar eens ergens gaan volgen. Vertel nou gewoon eens wat je nu
>> eigenlijk van die code verwacht.
>
>Dat die code de hele array doorloopt, en voor alle elementen in die
>array de memberfunctie foo() aanroept. De elementen in de array
>moeten van klasse B en C kunnen zijn. A is een superklasse van
>zowel B als C.
>
Kijk, dat is me een stuk duidelijker.

>> Nooit van OO gehoord hebben is misschien wat overdreven, toepassen is een
>> ander verhaal.
>
>Als je niet weet wat een superklasse is, ben je nooit verder dan de
>term 'OO' gekomen, maar weet je totaal niet wat het inhoudt.
>
Dat klopt wel zo ongeveer en ik heb ook al diverse malen aangegeven niet
gehinderd te worden door enige OO kennis. :-)

>C++ compilers zijn er voor net zoveel computers als C: er zijn
>namelijk C++ compilers die C code als uitvoer genereren.
>Dus als er een C compiler beschikbaar is voor je processor, dan
>is het dus ook mogelijk om C++ code te compileren voor die processor.
>
Zo is C++ dan ook begonnen: Als pre-processor voor C compilers.
Je gaat er dan wel vanuit dat er voor elke processor een C compiler
beschikbaar is. In veel gevallen is dat zo, maar voor de kleine processoren
(bijv. PIC) zijn deze vrij beperkt en ik denk dat je dan ook niet met een
standaard C++ pre-processor uit de voeten kan. En dan wordt het ook nog een
probleem om alles efficient in 512 bytes code, 32 bytes RAM en een 2-level
hardware stack te krijgen. Maar goed, als je het echt wilt is het soms
mogelijk om C++ te gebruiken.

Het bestaan van een dergelijke pre-processor toont natuurlijk wel aan dat je
alles wat je in C++ kunt doen ook in C kunt doen. ;-)


>> Om nog even op je orginele vraag terug te komen:
>> | Geef mij eens voorbeeldcode waar je een array doorloopt en telkens de
>> | abstracte functie foo() aanroept in C en in VB. De superklasse moet A
>> | heten met twee subklassen B en C.
>>
>> Je stelt hem zo ongeveer in C++ en vraagt dan om dit in C of VB te doen.
>
>Wat is er C++ aan de vraag? Het woord "array", "abstract", "functie",
>"superklasse" of "subklasse"? Dat zijn allemaal algemeen aanvaarde
>begrippen binnen de OO wereld.
>
OK, weer een blijk van mijn onkunde op OO gebied.

[knip verhandeling over Jasper]
Ik heb dat stuk van de thread gemist.

>Zeker als het gaat om advies aan beginners, kun je onterechte
>claims niet onbestreden laten. En dat is wat hier gebeurde:
>een beginner vraagt advies, iemand geeft een totaal ongefundeerd
>antwoord, en wordt vervolgens teruggefloten. Dat jij je daarna
>aangevallen voelt, tja....
>
Onterechte claims moeten natuurlijk altijd bestreden worden.
Ik voelde mij pas "aangevallen" op het moment dat C omschreven wordt als
"geschikt voor device drivers" en er mensen over grotten ed. beginnen.

>[knip: C code die totaal geen antwoord op de vraag is]
>
Dat wist ik ook nog wel, maar het beoogde effect is behaald: Een (voor mij)
duidelijker uitleg van wat er nu eigenlijk gevraagd werd en een voorbeeld in
C++.

[knip voorbeeld code]
>Verwachte output:
>BCBCBCBCBC
>Of afhankelijk van je vulalgorithme elke andere volgorde van B's en C's.
>
>Succes met je implementatie in C!
>
Dank je!

Er zijn een aantal aanpakken mogelijk:
- Zorg voor dezelfde output, da's wel heel triviaal en dat was in C++ in dit
geval ook handiger geweest.
- Haal jouw code door voornoemde pre-processor, beetje te makkelijk.
- Schrijf zelf iets, zie onder

Hierbij mijn poging. Ik had natuurlijk ook B en C in een struct kunnen
stoppen, maar dat vond ik hier wat overdreven. Ik zie dat Raaf dit inmiddels
wel gedaan heeft. (Ik had dit stukje code vanochtend al even snel geklopt).

#include <stdio.h>
#include <stdlib.h>

#define MYSIZE 10

typedef struct {
  void (*foo)();
} A;

void B(void)
{
  putchar('B');
}

void C(void)
{
  putchar('C');
}

void vul(A *arr[], int size)
{
  int i;

  for(i = 0; i < size; i++) {
    arr[i] = malloc(sizeof *arr);
    if(i % 2)
      arr[i]->foo = C;
    else
      arr[i]->foo = B;
  }
}

int main(void)
{
  int i;
  A *array[MYSIZE];

  vul(array, MYSIZE);

  for(i = 0; i < MYSIZE; i++) {
    array[i]->foo();
  }
  putchar('\n');

  return 0;/* over geheugenlekken doen we hier niet moeilijk */

}


Stef