C ++：指针和抽象数组类

Question

I am relatively new to pointers and have written this merge function. Is this effective use of pointers? and secondly the *two variable, it should not be deleted when they are merged right? that would be the client´s task, not the implementer?

VectorPQueue *VectorPQueue::merge(VectorPQueue *one, VectorPQueue *two) {
int twoSize = two->size();

if (one->size() != 0) {
    for (int i = 0; i < twoSize;i++)
    {
        one->enqueue(two->extractMin());
    }
}
return one;

}

The swap function is called like this

one->merge(one, two);

Passing it the these two objects to merge

PQueue *one = PQueue::createPQueue(PQueue::UnsortedVector);
PQueue *two = PQueue::createPQueue(PQueue::UnsortedVector);

Answer 1

In your case pointers are completely unnecessary. You can simply use references.

It is also unnecessary to pass in the argument on which the member function is called. You can get the object on which a member function is called with the this pointer.

/// Merge this with other.
void VectorPQueue::merge(VectorPQueue& other) {
  // impl
}

In general: Implementing containers with inheritance is not really the preferred style. Have a look at the standard library and how it implements abstractions over sequences (iterators).

Answer 2

At first sight, I cannot see any pointer-related problems. Although I'd prefer to use references instead, and make merge a member function of VectorPQueue so I don't have to pass the first argument (as others already pointed out). One more thing which confuses me is the check for one->size() != 0 - what would be the problem if one is empty? The code below would still correctly insert two into one , as it depends only on two 's size.

Regarding deletion of two :

that would be the client´s task, not the implementer

Well, it's up to you how you want do design your interface. But since the function only adds two 's elements to one , I'd say it should not delete it. Btw, I think a better name for this method would be addAllFrom() or something like this.

Regarding pointers in general :

I strongly suggest you take a look into smart pointers. These are a common technique in C++ to reduce memory management effort. Using bare pointers and managing them manually via new/delete is very error-prone, hard to make strongly exception-safe, will almost guarantee you memory leaks etc. Smart pointers on the other hand automatically delete their contained pointers as soon as they are not needed any more. For illustrative purposes, the C++ std lib has auto_ptr ( unique_ptr and shared_ptr if your compiler supports C++ 11). It's used like this:

{ // Beginning of scope
std::auto_ptr<PQueue> one(PQueue::createPQueue(PQueue::UnsortedVector));

// Do some work with one...:
one->someFunction();
// ...

} // End of scope - one will automatically be deleted

My personal rules of thumb: Only use pointers wrapped in smart pointers. Only use heap allocated objects at all, if:

• they have to live longer than the scope in which they are created, and a copy would be too expensive (C++ 11 luckily has move semantics, which eliminate a lot of such cases)
• I have to call virtual functions on them

In all other cases, I try to use stack allocated objects and STL containers as much as possible.

All this might seem a lot at first if you're starting with C++, and it's totally ok (maybe even necessary) to try to fully understand pointers before you venture into smart pointers etc.. but it saves a lot of time spend debugging later on. I'd also recommend reading a few books on C++ - I was actually thinking I understood most of C++, until I read my first book :)