[C++/VC6] Functie pointers en templates

[Olaf van der Spek]

Ik probeer een pointer naar een functie met templates te gebruiken als functie pointer, maar de compiler vind dit niet leuk.
Doe ik iets niet goed, ondersteund de compiler het niet of ondersteund c++ het niet?

C++:

class Cucr_container
{
};

template <class T>
Cucr_container* new_container()
{
    return new T;
}

Cucr_container* new_container_2()
{
    return new Cucr_container;
}

typedef Cucr_container* (*t_new_container_f)();

int main()
{
    t_new_container_f f_2 = new_container_2;
    t_new_container_f f = new_container<Cucr_container>; // 21

    /*
    main.cpp(21) : error C2440: 'initializing' : cannot convert from '' to 'class Cucr_container *(__cdecl *)(void)'
        None of the functions with this name in scope match the target type
    */

    return 0;
}

[Verwijderd]

G++ compileert deze code zonder errors, lijkt me daarom een VC6 probleem.

[ Voor 5% gewijzigd door Verwijderd op 27-12-2002 20:31 ]

[Zoijar]

Ja klopt heb ik zelf ook al eerder last van gehad, VC6 heeft moeite met templated functie pointers...niets aan te doen vrees ik...behalve overstappen op Comeau dan

[Olaf van der Spek]

Heeft VC7 dit probleem ook dan?

[MSalters]

Als workaround: werkt

code:

t_new_container_f f = &new_container<Cucr_container>;

?

Dan is het expliciet dat je ergens een adres van neemt.

[.oisyn]

VC6 probleem idd, VC7 heeft er geen last van

[Olaf van der Spek]

MSalters schreef op 27 december 2002 @ 21:53:
Als workaround: werkt

code:

t_new_container_f f = &new_container<Cucr_container>;

?

Dan is het expliciet dat je ergens een adres van neemt.

Nee, geeft zelfde foutmelding.

[.oisyn]

ik geloof dat expliciet casten wel werkt:

C++:

t_new_container_f f = (t_new_container_f) new_container<Cucr_container>;

[ Voor 4% gewijzigd door .oisyn op 27-12-2002 22:03 ]

[Olaf van der Spek]

Ik geloof van niet:

code:

        None of the functions with this name in scope match the target type

[.oisyn]

Hmmm ik heb het wel een keer opgelost in VC6... ik dacht met die cast, maar blijkbaar niet dus. Ik zal het eens opzoeken, ogenblik

.edit: helaas, het was een iets ander probleem dan ik dacht, dus ik kan je geen oplossing geven

[ Voor 28% gewijzigd door .oisyn op 27-12-2002 22:37 ]

[Olaf van der Spek]

Misschien dat iemand dan een andere oplossing weet voor het 'grotere' probleem:
Ik heb een aantal derived classes om verschillende file types mee te openen.
De user moet kiezen welke class gebruikt wordt (later wil ik ook nog auto-detectie toevoegen) en dan moet die class met new 'gemaakt' worden.
Omdat er run-time geen code meer te genereren is wilde ik dat met die template functie doen. Ik zou ook aan elke derived class een static create functie kunnen toevoegen, maar dat is niet zo netjes.

Een switch om te kiezen vind ik ook niet netjes.

[Soultaker]

OlafvdSpek schreef op 28 December 2002 @ 12:15:
Ik zou ook aan elke derived class een static create functie kunnen toevoegen, maar dat is niet zo netjes.

Waarom niet? Dat lijkt me juist een erg geschikte methode, zeker als sommige klassen op een specifieke manier geconstrueerd moeten worden (constructor met argumenten, bijvoorbeeld, of een expliciete initialisatie).

Dat in veel gevallen dubbele code ontstaat, moet je maar voor lief nemen (als dat je bezwaar is). In theorie kun je je template functie aanroepen in je static member function (die een soort factory method geworden is) en zo overbodige code reduceren tot een minimum, maar in dit geval schiet je daar niets mee op: dan kan je net zo goed gelijk die new-call uitvoeren.

[Olaf van der Spek]

Nadat de user een class uit een lijst heeft geselecteerd moet die class gecreeerd worden. Dit wilde ik doen door (een pointer naar) die create functie ook in de lijst te zetten. Speciale parameters zijn dan toch niet mogelijk. Ik wilde inderdaad dubbele code voorkomen.

[Zoijar]

Zoek is op '(abstract) factory pattern'

[ Voor 40% gewijzigd door Zoijar op 28-12-2002 13:31 ]

[MSalters]

Prototype pattern?

Elementen:

code:

// Setup
virtual std::auto_ptr<Base> Base::Clone(); 
std::map< Key, Base*> prototypes;

// gebruik:
std::auto_ptr<Base> create_new_object( Key k)
{
  return prototypes[k]->Clone();
}

Een iets nettere versie checkt of k een valide key is, ipv een 0-pointer dereference te doen