Re: Template functions and const array
ahuggel@gmx.net wrote:
Thanks for your answer. I'm sorry, my short example was unfortunate;
the emphasis was meant to be on the value as a template parameter
rather than a type, I didn't consider that sizeof() of course also
works with a type.
Yes, unfortunately templates require types, not values (someone, pls
correct me
if wrong). Argument deduction can derive types from the types of values
passed
as parameters. That is what I emphasized in my OP.
The question should have been: Is it possible to change the template
to use an array by value instead of a simple integer as the template
parameter?
Yes and no, using argument deduction you can derive the type of the
array (as I did)
and use this to get the associated fptr, based on specialization of
type. However
two different arrays of the same type but different values will give
you the same
result, which is not what you want.
With regards to your questions. It seems what you need is sets and
maps,
something to the effect of:
class MetaData
{
public:
typedef std::set<Lookup> Category;
typedef std::map<int, Category> MetaMap;
//...
void add( int catId, Category const& category ); //No-op if already
present...
char const* getName( int catId, int lkupId );
bool hasCategory( catId ) const;
void remove( int catId );
//etc...
private:
MetaMap metaMap_;
}
You can hide the implementation behind the MetaData interface... Hope
this helps.
Other things that spring to mind is binding Lookup to and interface if
specific action
is required, for example:
class LookupIf
{
virtual void do() = 0;
//etc...virtual destructor
};
class Lookup
{
public:
Lookup( int id, const char* name, boost::shared_ptr<LookupIf>
const& myIf );
void do(){ interface_->do(); }
bool operator <( const Lookup& rhs ) const;
bool operator ==( int id ) const;
//...
private:
boost::shared_ptr<LookupIf> interface_;
//etc...
};
Some would probably advise you to use std::string rather than literals
in Lookup.
The rationale behind using std::string instead of literal, I suppose
would be that
strings are always constructed from literals when using constructor
taking const char*
as param. Therefore the intent is clearer. Also, comparisons, copying
etc. are handled
for you.
Hope this helps, as I lack to time to help more.
W
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]