模板化 function 中的 shared_ptr 析构函数崩溃

Question

In my 32-bit VS2015 application, I have a templated function that accesses functions of a library (BTK). Depending on the type of this function, a specific overload of a function of this library is called.

This works fine, but recently I'm using this same code and library (same binaries and code) in another (also VS2015 32-bit) application, and it segfaults/access violation in the destructor of shared_ptr . To be precise, it crashes at the (interlocked) decrement of the use count.

void _Decref()
{   // decrement use count
    if (_MT_DECR(_Uses) == 0) // BOOM
    {   // destroy managed resource, decrement weak reference count
        _Destroy();
        _Decwref();
    }
}

Now comes the interesting part, when I replace my templated function with a non-templated version, it works fine..

So, if I replace this:

template<class T>
bool SetParameters(const std::string& group, const std::string& param, const std::vector<T>& values, const std::vector<uint8_t>& dims)
{
    btk::MetaData::Pointer pParam = GetBtkMetaData(group, param);
    if (!pParam)
    {
        pParam = AddBtkMetaData(group, param);
    }

    if (!pParam->HasInfo())
    {
        pParam->SetInfo(btk::MetaDataInfo::New(dims, values));
    }
    else pParam->GetInfo()->SetValues(dims, values);

    return true;
}

with this:

bool C3DFile::SetParameters(const std::string& group, const std::string& param, const std::vector<int16_t>& values, const std::vector<uint8_t>& dims)
{
    btk::MetaData::Pointer pParam = GetBtkMetaData(group, param);
    if (!pParam)
    {
        pParam = AddBtkMetaData(group, param);
    }

    if (!pParam->HasInfo())
    {
        pParam->SetInfo(btk::MetaDataInfo::New(dims, values));
    }
    else pParam->GetInfo()->SetValues(dims, values);

    return true;
}

It works fine... Apparantly, the template-instantiation has some effect on the shared pointers. I have three questions:

• What kind of effect could templates have on this? I can imagine that the code instantiation could have some effect, but I'm not sure.

• Why would the templated version work, with the same binaries etc, in one 32-bit VS2015 app, but not in the other? (Where I need to resort to non-templated functions)

• Which compiler/linker options could be relevant? I checked the compiler and linker options, but couldn't find a relevant difference.

Any help would be appreciated.

Ben

Answer 1

What kind of effect could templates have on this? I can imagine that the code instantiation could have some effect, but I'm not sure.

ADL: the template method will use ADL to find the dependent methods (in your case btk::MetaDataInfo::New(dims, values) ), whereas the non template only considers visible declarations, so the possible difference.

Example:

struct A{};

void fooT(const void*) { std::cout << "void*\n"; }
template <typename T> void barT(const T* p) { fooT(p); }
void fooT(const A*) { std::cout << "A*\n"; }

void foo(const void*) { std::cout << "void*\n"; }
void bar(const A* p) { foo(p); }
void foo(const A*) { std::cout << "A*\n"; }

int main()
{
    A a{};

    barT(&a); // fooT(const A*)   -> A*
    bar(&a);  // foo(const void*) -> void*
}

Demo