Question

I’m templatizing a queue class so I can use it with anything from ints to whatever structs I need to define.

I need to pass a comparison function to the class constructor, a predefined comparison function for ints and alike then leave it up to the client to provide any comparison functions they may want. But how do I do this?

template<typename Type>
int cmpFn(Type one, Type two)
{
    if (one < two) return -1;
    if (one > two) return 1;
    return 0;
}

template <typename Type>
class Queue
{
    public:
        Queue()
        {
            Type *list = new Type[size];
            // What do I do now?
            // How to define this constructor?
            // It must pass a comparison function
            // to a private sort method in this class.
        }
    private:
        void sortFunc(Type list, int(fn)(Type one, Type  two)=cmpFn);
};

There’s probably some mistakes in the above code since I just wrote it down from the top of my head to make my question more clear. But all I’m interested in is how to pass a comparison function to a sort method when defining a class.

This is a personal exercise, I’m not enrolled in any course nor have I access to any tutors. I’ve been googling this for a while now, but I couldn’t come up with the right answer… I guess I wasn’t asking the right question to Mr. Google.

P.S.
The client may want to provide comparison functions for any sort of data, like:

struct individual
{
    string name;
    int age;
    double height;
};

I guess that the constructor has to be like this:

Queue(int (*fn)(Type, Type) = cmpFn);

But how do I define/implement this? It’s not a Queue object itself who will use this callback function, but its method: sort();

Answer 1

Here’s a working, compilable example of what I think you want:

#include <cstddef>
#include <string>
#include <iostream>

template<typename Type>
int cmpFn(Type one, Type two)
{
    if (one < two) return -1;
    if (one > two) return 1;
    return 0;
}

template <typename Type>
class Queue
{
    public:
        // This is the typedef for your callback type
        typedef int (*callback)(Type one, Type two);

        Queue(Type *list, size_t size, callback func = cmpFn)
        {
            sortFunc(list, size, func); // works too
        }

    private:
        void sortFunc(Type *list, size_t size, callback func) {
            for (size_t i=0; i<size; i++) {
                for (size_t j=0; j<size; j++) {
                    if (i == j) continue;

                    int val = (*func)(list[i], list[j]);
                    switch (val) {
                        case 1:
                            std::cout << list[i] << " is greater than " << list[j] << "\n";
                            break;
                        case -1:
                            std::cout << list[j] << " is greater than " << list[i] << "\n";
                            break;
                        case 0:
                            std::cout << list[i] << " and " << list[j] << " are equal\n";
                            break;
                    }
                }
            }
        }

};

int stringCmp(std::string one, std::string two) {
    if (one.size() < two.size()) return -1;
    if (one.size() > two.size()) return 1;
    return 0;
}

int main() {
    // compare ints, use generic comparison function (cmpFn)
    int myInts[2] = {1, 2};
    Queue<int> qi(myInts, 2);

    // compare strings, use our own comparison function (stringCmp)
    std::string myStrings[2] = {"foo", "bar"};
    Queue<std::string> qs(myStrings, 2, stringCmp);

    return 0;
}

Compiling and executing the program above should give you this output:

2 is greater than 1
2 is greater than 1
foo and bar are equal
bar and foo are equal

Basically what it does:

• The Queue constructor accepts a list array, its size and a callback function.
• If the callback function is not provided, it uses the generic one (cmpFn).
• It then calls sortFunc which loops though all the elements in the list array and compare them using the callback function.

In the code above, you have an example with int and std::string.