Member function overloading/template specialization issue

Question

I've been trying to call the overloaded table::scan_index(std::string, ...) member function without success. For the sake of clarity, I have stripped out all non-relevant code.

I have a class called table which has an overloaded/templated member function named scan_index() in order to handle strings as a special case.

class table : boost::noncopyable
{
public:
    template <typename T>
    void scan_index(T val, std::function<bool (uint recno, T val)> callback) {
        // code
    }

    void scan_index(std::string val, std::function<bool (uint recno, std::string val)> callback) {
        // code
    }
};

Then there is a hitlist class which has a number of templated member functions which call table::scan_index(T, ...)

class hitlist {
public:
    template <typename T>
    void eq(uint fieldno, T value) {
        table* index_table = db.get_index_table(fieldno);
        // code
        index_table->scan_index<T>(value, [&](uint recno, T n)->bool {
            // code
        });
    }
};

And, finally, the code which kicks it all off:

hitlist hl;
// code
hl.eq<std::string>(*fieldno, p1.to_string());

The problem is that instead of calling table::scan_index(std::string, ...), it calls the templated version. I have tried using both overloading (as shown above) and a specialized function template (below), but nothing seems to work. After staring at this code for a few hours, I feel like I'm missing something obvious. Any ideas?

    template <>
    void scan_index<std::string>(std::string val, std::function<bool (uint recno, std::string val)> callback) {
        // code
    }

Update: I dropped the <T> decoration from the scan_index() call. The result was that the calls with a string parameter compile just fine, but calls with other types (e.g. double) resulted in the following error:

cannot convert parameter 1 from 'double' to 'std::string'

So I went back to using template specialization. Now I get this error:

error C2784: 'void table::scan_index(T,std::tr1::function<bool(uint,T)>)' :
  could not deduce template argument for 'std::tr1::function<bool(uint,T)>'
  from '`anonymous-namespace'::<lambda5>'

FYI: I am using VC++ 10.0

Solution: I fixed this problem by dropping the templated scan_index() function from the table class and simply writing four overloaded functions (three of which are identical except for the signature). Luckily, they're all pretty short (less than ten lines) so it's not so bad.

I strongly suspect you are running in to a Koenig name lookup issue. — John Dibling, Jan 05 '11 at 18:54
Potentially related: http://stackoverflow.com/questions/4217733/distance-calculation-error-in-c/4218731#4218731 — John Dibling, Jan 05 '11 at 18:56
I had a problem similar to this here: http://stackoverflow.com/questions/3406004/define-a-specific-case-for-a-templated-function-c — Grammin, Jan 05 '11 at 18:58
non-template version cannot be called, because you explicitly calling template `index_table->scan_index...` — Gene Bushuyev, Jan 05 '11 at 19:01

score 7 · Accepted Answer · answered Jan 05 '11 at 18:59

7

You explicitly call templated member here:

index_table->scan_index<T>(value, [&](uint recno, T n)...

Since value is the template parameter you should be fine replacing that with:

index_table->scan_index(value, [&](uint recno, T n)...

answered Jan 05 '11 at 18:59

Nikolai Fetissov

82,306
11
110
171

score 3 · Answer 2 · answered Jan 05 '11 at 19:00

3

You shouldn't explicitly specify the template argument- you should leave it to template argument deduction and overload resolution. This should allow the overload you posted in the very original code to be picked up and used.

answered Jan 05 '11 at 19:00

Puppy

144,682
38
256
465

score 1 · Answer 3 · answered Jan 05 '11 at 19:07

prepared this simplified test (sorry, I don't have C++0x compiler atm):

class table
{
public:
    template <typename T>
    void scan_index(T val) {
        std::cout << "template\n";
    }

    template <>
    void scan_index<int>(int val) {
        std::cout << "specialization\n";
    }

    void scan_index(int val) {
        std::cout << "overloaded\n";
    }
};

class hitlist {
public:
    template <typename T>
    void eq(T value) {
        table tbl;
        tbl.scan_index<T>(value);
    }
};

int main(int argc, char* argv[])
{
    int i = 0;
    hitlist hl;
    hl.eq(i);
    return 0;
}

output is "specialization" (VC9). it's because hitlist::eq explicitly uses template version, so only template specialization will be considered. if you change tbl.scan_index<T>(value); to tbl.scan_index(value); overloaded version will be called.

tbh I don't know why your template specialization doesn't work, probably because of lambda, not complete C++0x support? which compiler?

This has nothing to do with C++0x. The problem relates to picking overloads, and his lambda code is perfectly valid. — Puppy, Jan 05 '11 at 19:14
"I have tried using both overloading (as shown above) and a specialized function template (below)" it's why I was thinking it's something related with lambdas — Andriy Tylychko, Jan 05 '11 at 19:19
This only compiles on Visual C++ because of an extension allowing in-class specialization. For other compilers (e.g. GCC) the specialization must be defined outside the class. (See http://stackoverflow.com/a/2098016/2319122.) — Ben C, Nov 19 '16 at 15:48

score 1 · Answer 4 · answered Jan 05 '11 at 20:04

Isn't the template specialisation be something like:

template <typename T>
void scan_index(T val, std::function<bool (uint recno, T val)> callback) {
    // code
}
template <>
void scan_index(std::string val, std::function<bool (uint recno, std::string val)> callback) {
    // code
}

This way C++ compiler recognizes scan_index has a specialisation rather than looking for the overloaded method. And I believe if you wanted it the way you can coded, you should probably put the specialised code before the template like this:

    void scan_index(std::string val, std::function<bool (uint recno, std::string val)> callback) {
        // code
    }
template <typename T>
    void scan_index(T val, std::function<bool (uint recno, T val)> callback) {
        // code
    }

Member function overloading/template specialization issue

4 Answers4