Question

I have a class Model:

class Model
{
    ...

    boost::shared_ptr<Deck>  _deck;
    boost::shared_ptr<CardStack> _stack[22];
};

Deck inherits from CardStack.

I tried to make _stack[0] point to the same thing that _deck points to by going:

{
    _deck = boost::shared_ptr<Deck>(new Deck());
    _stack[0] = _deck;
}

It seems that the assignment to _deck of _stack[0] results in a copy of _deck being made. (I know this because modifications to _stack[0] do not result in modifications to _deck.) How can I get them to point to the same thing?

Ok – no copy constructor is being called. I have verified this by implementing it and seeing if it gets called – it doesn’t.

However – I have a function that operates on CardStack objects:

void TransferSingleCard(CardStack & src, CardStack & dst, Face f)
{
    if( !src._cards.empty() )
    {
        src._cards.back().SetFace(f);
        dst.PushCard(src._cards.back());
        src._cards.pop_back();
    }   

}

Now – when I call:

{
    TransferSingleCard(*_stack[DECK], _someotherplace, FACEDOWN);
    std::cout << *_stack[DECK];
    std::cout << *_deck;
}

I get this output (where std::cout on a CardStack will print out the size of that stack):

Num(103) TOP
Num(104) TOP

… so I’ve concluded (incorrectly?) that _stack[DECK] points to something different.

The Deck

class Deck : public CardStack
{
public:
    Deck(int numsuits=2, StackIndex index = NO_SUCH_STACK );
    Deck::Deck( const Deck & d);
    int DealsLeft() const;
    void RecalcDealsLeft();
private:
    int _dealsleft;
};

Answer 1

This example – derives from @Neil’s answer, tries to emulate what you say is happening. Could you check that it works as expected (A and B have the same count) on your system.

Then we could try and modify this code or your code until they match.

#include <boost/shared_ptr.hpp>
#include <iostream>

class A {
    public:
    virtual ~A()
    {
        std::cerr << "Delete A" << std::endl;
    }
    int _count;
    void decrement()
    {
        _count --;
    }
};
class B : public A {
    public:
    virtual ~B()
    {
        std::cerr << "Delete B" << std::endl;
    }
};

int main()
{
    boost::shared_ptr<B> b(new B);
    b->_count = 104;
    boost::shared_ptr<A> a;
    a = b;

    a->decrement();

    std::cerr << "A:" << a->_count << std::endl;
    std::cerr << "B:" << b->_count << std::endl;
    return 0;
}

EDIT:

So from the comment, we know the original pointers are correct, so now we need to trace.

Either:

1. log pointers to see when they change.
2. Use watchpoints in a debugger to see when the pointer changes.
3. Use a third shared pointer to see which pointer is changed.
4. Introduce a function that changes both pointers at the same time.