Generic function that works with any class member?

[carlwryker]

I have several functions that return class objects from a list named tally depending on whether the object's member matches a criteria. For example, getElemById( id ) returns a copy of an object if its id matches while getElemByName( name ) returns if the object's name matches. The functions are very similar, except in a couple of lines involved in checking values (commented with '/* How do I make this generic? */'). How can I make a generic function that can be used with different class members?

    // Returns the first element that matches id.
    template < typename Type >
    Type TallyClass< Type >::getElemById( unsigned int elemId )
    {
        Type tempObj; // Object of a custom class
        if ( tally.empty() )
        {
            std::cout << "Error in getElemById(): Tally is empty. " << std::endl;
        }
        else
        {
            typename std::list< Type >::iterator it = tally.begin(); // Iterator for retrieving the object.
            while( it != tally.end() )
            {
                tempObj = *it;
                if ( tempObj.getId() == elemId ) /* How do I make this generic? */
                {
                    break;
                }
                else if ( it == ( --tally.end() ) ) // Check if last element is match
                {
                    if ( tempObj.getId() != elemId ) /* How do I make this generic? */
                    {
                        std::cout << "getElemById: No match." <<std::endl;
                        tempObj.setObjIt( tally.end() );// Set the iterator to be tally.end() so we don't accidentally store the iterator of another object.
                    }
                }
                ++it;   // Advance the iterator
            }
        }
        return tempObj;
    }
    
    // Returns the first element that matches name.
    template < typename Type >
    Type TallyClass< Type >::getElemByName( std::string elemName )
    {
        Type tempObj;
        if ( tally.empty() )
        {
            std::cout << "Error in getElemByName(): Tally is empty. " << std::endl;
        }
        else
        {
            typename std::list< Type >::iterator it = tally.begin(); // Iterator for retrieving the object.
            while( it != tally.end() )
            {
                tempObj = *it;
                if ( tempObj.getName() == elemName ) /* How do I make this generic? */
                {
                    break;
                }
                else if ( it == ( --tally.end() ) ) // Check if last element is match
                {
                    if ( tempObj.getName() != elemName ) /* How do I make this generic? */
                    {
                        std::cout << "getElemByName(): No match." <<std::endl;
                        tempObj.setObjIt( tally.end() );// Set the iterator to be tally.end() so we don't accidentally store the iterator of another object.
                    }
                }
                ++it;   // Advance the iterator
            }
        }
        return tempObj;
    }

[tcs]

You may take following code fragments as a hint:

/* ========================================================================== */
class Tst
{
private:
    int    _a;
    double _b;

public:
    Tst(int initialA = 0, double initialB = 0.0) :
        _a(initialA),
        _b(initialB)
    {}

    int a(void) const
    {
        return _a;
    }
    double b(void) const
    {
        return _b;
    }
    bool aEqual(int right) const
    {
        return this->_a == right;
    }

    bool bEqual(double right) const
    {
        return this->_b == right;
    }

} /* Tst */;

/* -------------------------------------------------------------------------- */

std::ostream &operator<<(ostream &os, const Tst &tst)
{
    os << '(' << tst.a() << ", " << tst.b() << ')';

    return os;

} /* std::ostream &operator<<(ostream&, const Tst&) */

/* -------------------------------------------------------------------------- */
class aEqual
{
public:
    aEqual() {}
    bool operator()(const Tst &left, int right) const
    {
        return left.aEqual(right);
    }

} /* aEqual */;

/* -------------------------------------------------------------------------- */
class bEqual
{
public:
    bool operator()(const Tst &left, double right) const
    {
        return left.bEqual(right);
    }

} /* bEqual */;

/* ========================================================================== */
typedef std::vector<Tst*> TstVector;

static TstVector tstVector;

template <typename ElemType, typename BaseType, typename Compare>
    ElemType *getElem(BaseType base)
{
    ElemType *itemFound = NULL;

    //...
    for (TstVector::iterator it(tstVector.begin());
         it != tstVector.end();
         it++)
    {
        if (Compare()(**it, base))
        {
            itemFound = *it;
            break;
        }
    }
    //...

    return itemFound;

} /* getElem() */

/* -------------------------------------------------------------------------- */
/*
 *  t s t
 */
static void tst(void)
{
    Tst *itemFound = NULL;

    tstVector.push_back(new Tst(2, 3.1));
    tstVector.push_back(new Tst(4, 6.2));
    tstVector.push_back(new Tst(6, 9.3));

    itemFound = getElem<Tst, int, aEqual>(4);
    if (itemFound != NULL)
    {
        std::cout << *itemFound << std::endl;
    }
    itemFound = getElem<Tst, double, bEqual>(9.3);
    if (itemFound != NULL)
    {
        std::cout << *itemFound << std::endl;
    }

} /* tst() */

/* ========================================================================== */

[carlwryker]

Thank you!