How can I do this with Smart Pointers?

Question

Here's what I'm trying to achieve:

#include <iostream>
using std::cout;

#include <vector>
using std::vector;

int main()
{
    vector<int> a {3, 7};

    int *p = &a.at (0); //assign 3

    for (int i = 0; i < 10; ++i) //swap and print (3,7,3...)
    {
        p = (*p == a.at (0) ? &a.at (1) : &a.at (0));
        cout << *p << '\n';
    }
}

I'd like to use smart pointers instead of raw pointers, seeing as how they are much better, but can't really figure out how to implement switching back and forth (this is to be used for taking turns in a game; It's a Player *).

I tried replacing the pointers here with std::unique_ptr and std::shared_ptr in two separate tests, using reset to switch, with both giving random numbers after the first one, as expected.

Next, I tried with std::weak_ptr as it looks like what I need, although the interface isn't really that similar. From what I've seen, the only way to use it is through lock(), so I tried prepending lock(). to the calls of reset and appending it to dereferencing, but that crashed.

How can I use std::weak_ptr instead of a raw pointer, or can I actually use one of the other ones somehow?

You don't need weak_ptr here as there's no cycle. Why isn't shared_ptr working? I'd suggest posting THAT code, the error you're getting, and ask for help there. unique_ptr will not work because, well...only one can point at the same thing...it's *unique*. — Edward Strange, May 07 '12 at 17:40
@CrazyEddie, the shared pointer doesn't work because it's the only one pointing to it, so when it switches to the other player, nothing points to the first. — chris, May 07 '12 at 19:26

Jason · Accepted Answer · 2012-05-07T17:49:28.997

4

Rather than using raw pointers for this type of indexing operation, I think you should look into using std::vector::iterator, keeping in mind that any insertion operation into a std::vector could invalidate the iterator. For instance, you could do the following:

typedef std::vector<int>::iterator iter_t;

vector<int> a {3, 7};

iter_t p = iter_t(&a.at(0)); //assign 3

for (int i = 0; i < 10; ++i) //swap and print (3,7,3...)
{
    p = (*p == a.at(0) ? iter_t(&a.at(1)) : iter_t(&a.at(0)));
    cout << *p << '\n';
}

edited May 07 '12 at 17:49

answered May 07 '12 at 17:36

Jason

31,834
7
59
78

That delete was an accident :p How would I use an iterator for that though? – chris May 07 '12 at 17:37
Although others have good points as well, I do like this best. Thanks. – chris May 07 '12 at 19:32

Thomas · Answer 2 · 2012-05-07T17:42:23.830

4

Smart pointers are not "much better" by definition. They are only useful if they need to manage the memory they're pointing to.

As your pointers are simply pointing to elements in a vector, you don't want smart pointers at all. Most smart pointers will try to delete the memory they're pointing to when they go out of scope, which in this case will result in nasal demons.

Be aware, though, that resizing the vector may cause all your pointers to be invalidated. Ensure that you're not adding or removing elements while the pointers are still in scope.

In this case, players taking turns, I would probably not use pointers at all, but rather something like this:

int main()
{
    vector<int> players {3, 7};

    int current_player = 0;

    while (!game_over())
    {
        cout << players[current_player] << '\n';
        current_player = (current_player + 1) % players.size();
    }
}

edited May 07 '12 at 17:42

answered May 07 '12 at 17:37

Thomas

174,939
50
355
478

I see, I misunderstood the use of them. I do recall reading something to just use a normal pointer for just pointing to something a bit back. I technically have class now though, so I'll be gone for a bit. – chris May 07 '12 at 17:38
@chris: See [this question](http://stackoverflow.com/questions/8706192/which-kind-of-pointer-do-i-use-when) then. – Xeo May 07 '12 at 17:42
@Xeo, very informative, thank you. I never actually found that one when searching. – chris May 07 '12 at 19:33

score 0 · Answer 3 · answered May 07 '12 at 17:49

Just realized you might mean you want a smart pointer to the int within a vector, not to change the ints in the vector to smart pointers. I wouldn't do that at all. I'd use the vector's iterators:

for (int i = 0; i < 10; ++i) {
  auto it = it.begin() + (i % 2 ? 1:0);
  f(*it);
}

Using shared, unique, or any other pointer to the inside of your vector would result in bad, bad, bad things. Using raw pointers is not warranted either as they don't indicate anything about what they're pointing at. The vector's iterators on the other hand, although probably implemented as raw pointers, have clear, documented rules regarding their use which you can document in your code by using them.

Do not forget that "smart pointer" includes iterators.

How can I do this with Smart Pointers?

3 Answers3