move constructor is ignored?

[GeoRanger]

Hi,

I've just written my first move constructors and move assignment operators. They seem to compile just fine, but when I try to set a breakpoint inside them, the debugger acts like they don't even exist. It acts like the source code for them is a comment, such that the breakpoints move to the first lines of code after them. This is with VS 2010.

I can't post the exact code but it looks something like this:

// In .h file
class OuterClass
{
    class InnerClass;
    // Other stuff...
};
 
// In .cpp file
class OuterClass::InnerClass
{
public:
    // Copy constructor
    InnerClass(InnerClass const & rhs)
    :
        m_WrapperAroundHugeMemberDataStructure(StaticConstIntegerId)
    {
        *this = rhs;
    }
    // Move constructor
    InnerClass(InnerClass && rhs)
    :
        m_WrapperAroundHugeMemberDataStructure(StaticConstIntegerId)
    {
        m_WrapperAroundHugeMemberDataStructure.SwapHugeData(&rhs.m_WrapperAroundHugeMemberDataStructure);
    }
    // Destructor
    ~InnerClass(void) {}
    // Other stuff...
};

When I set a breakpoint anywhere in the move constructor, the breakpoint jumps down to the destructor.

The same thing happens with the move assignment operator in this class. I have another class with a move constructor and move assignment which has the same problem, and it is also an inner class.

Am I doing anything obviously wrong here? Do move constructors have some subtlety when used with inner classes?

[Lindley]

If your code never actually invokes the move constructor, then it's possible it could be optimized out.

[GeoRanger]

Thank you for your interest and response. Looking at it closer, I think you're right. I wrote this a couple of years ago and tried to pass everything around with pointers when possible and I'm using reference counting in the container class. I didn't think I had been that thorough!

I did find one additional oddity in that if the inner class in my previous post is A, then A contains a collection of B and B contains a collection of C. Class C is the other inner class previously mentioned where the move constructor and move assignment are apparently optimized out. I realized I should also add a move constructor and move assignment operator to class B. In those, I'm using std::move to try to deliberately invoke the move operators I had already added to C. When I do that, I can successfully add a breakpoint to the move operator in B, but as judged by still not being able to set a breakpoint in C, its move operator is still apparently optimized out!? Also, the breakpoint in B is never hit when I do a test run, even though I can set it, but that’s probably just because the move code in A is never called.

[Lindley]

Perhaps if you distilled your test code into a simple, compilable package we could offer more insight.