Need help with switch() mess

[Christopher Benson-Manica]

At the moment, I've got the following situation (not my code):

// Assume appropriate headers have been included

enum MyType { ctypeNone, ctypeA, ctypeB, ctypeC };

class MyBaseClass {
static MyBaseClass* Create( const char * );
static MyType PickAClass( const char * );
};

class TypeA : public MyBaseClass {
typeA( const char * );
};

class TypeB : public MyBaseClass {
typeB( const char * );
};

class TypeC : public MyBaseClass {
typeC( const char * );
};

// actual implementation of Type* constructors omitted

MyType MyBaseClass::PickAClass( const char *str ) {
// do secret voodoo with str
return ctypeA; // or ctypeB, or ctypeC, or ctypeNone
}

MyBaseClass* MyBaseClass::Create( const char *str ) {
switch( PickAClass(str) ) {
case ctypeA: return( new TypeA(str) );
case ctypeB: return( new TypeB(str) );
case ctypeC: return( new TypeC(str) );
default: return NULL;
}
}

(Here there are only 3 types - in the actual code, there are 20.)

Now, this setup works correctly, but it strikes me as being
distinctively suboptimal. I'd like to create an array of function
pointers to the Type* constructors, so I could just index into that
array instead of messing with a 21-case switch statement. I don't
suppose I can take the address of a constructor, right? If so, what
is its type? If not, and if it is in fact worth the effort to revamp
this code, what do you suggest?

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Sharad Kala]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in message
news:c0**********@chessie.cirr.com...

At the moment, I've got the following situation (not my code):

// Assume appropriate headers have been included

enum MyType { ctypeNone, ctypeA, ctypeB, ctypeC };

class MyBaseClass {
static MyBaseClass* Create( const char * );
static MyType PickAClass( const char * );
};

class TypeA : public MyBaseClass {
typeA( const char * );
};

class TypeB : public MyBaseClass {
typeB( const char * );
};

class TypeC : public MyBaseClass {
typeC( const char * );
};

// actual implementation of Type* constructors omitted

MyType MyBaseClass::PickAClass( const char *str ) {
// do secret voodoo with str
return ctypeA; // or ctypeB, or ctypeC, or ctypeNone
}

MyBaseClass* MyBaseClass::Create( const char *str ) {
switch( PickAClass(str) ) {
case ctypeA: return( new TypeA(str) );
case ctypeB: return( new TypeB(str) );
case ctypeC: return( new TypeC(str) );
default: return NULL;
}
}

(Here there are only 3 types - in the actual code, there are 20.)

Now, this setup works correctly, but it strikes me as being
distinctively suboptimal. I'd like to create an array of function
pointers to the Type* constructors, so I could just index into that
array instead of messing with a 21-case switch statement. I don't
suppose I can take the address of a constructor, right? If so, what
is its type? If not, and if it is in fact worth the effort to revamp
this code, what do you suggest?

Have you looked at the factory pattern?

[Christopher Benson-Manica]

Sharad Kala <no*****************@yahoo.com> spoke thus:

Have you looked at the factory pattern?

I will if you tell me where it is :)

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[David Harmon]

On Fri, 6 Feb 2004 13:55:37 +0000 (UTC) in comp.lang.c++, Christopher Benson-Manica <at***@nospam.cyberspace.org> was alleged to have written:

I'd like to create an array of function
pointers to the Type* constructors, so I could just index into that
array instead of messing with a 21-case switch statement. I don't
suppose I can take the address of a constructor, right?

You would point not to the constructor, but a static function that returns a pointer to a "new"ly allocated instance.

[Jeremy Cowles]

"Sharad Kala" <no*****************@yahoo.com> wrote in message
news:c0*************@ID-221354.news.uni-> > MyBaseClass*
MyBaseClass::Create( const char *str ) {

switch( PickAClass(str) ) {
case ctypeA: return( new TypeA(str) );
case ctypeB: return( new TypeB(str) );
case ctypeC: return( new TypeC(str) );
default: return NULL;
}
}

Have you looked at the factory pattern?

The code he posted actually is a /crude/ factory.

[Sharad Kala]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in message
news:c0**********@chessie.cirr.com...

Sharad Kala <no*****************@yahoo.com> spoke thus:

Have you looked at the factory pattern?

I will if you tell me where it is :)

oh..it's a design pattern.
I am referring to the GoF (gang of four) book "Design Patterns".
http://www.amazon.com/exec/obidos/tg...48-0909450?v=g
lance

[David Harmon]

On Fri, 6 Feb 2004 14:16:16 +0000 (UTC) in comp.lang.c++, Christopher
Benson-Manica <at***@nospam.cyberspace.org> was alleged to have written:

Sharad Kala <no*****************@yahoo.com> spoke thus:

Have you looked at the factory pattern?

I will if you tell me where it is :)

_Design Patterns - Elements of Reusable Object Orient Design_
Gamma, Helm, Johnson, and Vlissides (the Gang of Four)
Addison-Wesley 1995

Also http://www.google.com/search?q=factory+pattern

[Rolf Magnus]

Christopher Benson-Manica wrote:

Sharad Kala <no*****************@yahoo.com> spoke thus:

Have you looked at the factory pattern?

I will if you tell me where it is :)

All over the world. One way to find it would be by using google.

[Christopher Benson-Manica]

Jeremy Cowles <jeremy.cowles[nosp@m]asifl.com> spoke thus:

The code he posted actually is a /crude/ factory.

"Crude" is right :) Is making a better one worth the effort?

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Christopher Benson-Manica]

David Harmon <so****@netcom.com> spoke thus:

Also http://www.google.com/search?q=factory+pattern

I do appreciate that, although from the sound of it it was some
special library or implementation... UML isn't too useful ;)

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cyberspace.org | don't, I need to know. Flames welcome.

[Chris Theis]

"Christopher Benson-Manica" <at***@nospam.cyberspace.org> wrote in message
news:c0**********@chessie.cirr.com...

David Harmon <so****@netcom.com> spoke thus:

Also http://www.google.com/search?q=factory+pattern

I do appreciate that, although from the sound of it it was some
special library or implementation... UML isn't too useful ;)

Googling gives me tons of descriptions of the factory pattern (including
sample code). If you want to have a sophisticated solution you might try
http://www.cuj.com/documents/s=7994/cujcexp1906hyslop/

Cheers
Chris

[Thomas Matthews]

Christopher Benson-Manica wrote:

At the moment, I've got the following situation (not my code):

// Assume appropriate headers have been included

enum MyType { ctypeNone, ctypeA, ctypeB, ctypeC };

class MyBaseClass {
static MyBaseClass* Create( const char * );
static MyType PickAClass( const char * );
};

class TypeA : public MyBaseClass {
typeA( const char * );
};

class TypeB : public MyBaseClass {
typeB( const char * );
};

class TypeC : public MyBaseClass {
typeC( const char * );
};

// actual implementation of Type* constructors omitted

MyType MyBaseClass::PickAClass( const char *str ) {
// do secret voodoo with str
return ctypeA; // or ctypeB, or ctypeC, or ctypeNone
}

MyBaseClass* MyBaseClass::Create( const char *str ) {
switch( PickAClass(str) ) {
case ctypeA: return( new TypeA(str) );
case ctypeB: return( new TypeB(str) );
case ctypeC: return( new TypeC(str) );
default: return NULL;
}
}

(Here there are only 3 types - in the actual code, there are 20.)

Now, this setup works correctly, but it strikes me as being
distinctively suboptimal. I'd like to create an array of function
pointers to the Type* constructors, so I could just index into that
array instead of messing with a 21-case switch statement. I don't
suppose I can take the address of a constructor, right? If so, what
is its type? If not, and if it is in fact worth the effort to revamp
this code, what do you suggest?

One method I use is to implement static creation methods
in each class. The method takes an ID parameter and will
return a pointer to a new instance if the ID is for the
class.

class TypeA
: public MyBaseClass
{
public:
static MyBaseClass * create(const char * id_text);
};

MyBaseClass *
TypeA ::
create(const char * id_text)
{
return (strcmp(id_text, "TypeA") == 0)
? new TypeA
: NULL;
}

In another method, called a factory, I call each creation
function. If the creation returns non-NULL, then I break
out of the loop. {If all creation functions return NULL,
then an exception.}
--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library