Swapping pointers

I have a bit of code that I'm having some trouble with. It looks something like this (I broke it down to make it short and sweet):

Code:

---

#include <vector>
#include <string>

class MyClass
{
public:
        std::string some_string;
        double some_double;

        MyClass() : some_string(""), some_double(0.0){}
};

void function(std::vector <MyClass>*, std::vector <MyClass>*);

int main(void)
{
        std::vector <MyClass>* first_object = new std::vector <MyClass>;
        std::vector <MyClass>* second_object = new std::vector <MyClass>;
        function(first_object, second_object);

        delete first_object;
        first_object = NULL;
        delete second_object;
        second_object = NULL;

        return 0;
}

void function(std::vector <MyClass>* first_object, std::vector <MyClass>* second_object)
{
        //Do stuff to first_object.
        //...
        //Do stuff to second_object.
        //...

        *first_object = *second_object;
}

---

The problem is, *first_object and *second_object can both be very large, and function() can be called many times. The assignment at the end of function() is creating an enormous bottleneck in my program. After the assignment is done, I'm only concerned about the contents of *first_object; second_object isn't used outside of function() and it's contents are re-written in function() each call. So I figure an easy way to speed up execution would be to swap the pointers rather than do the costly assignment. So, at the end of function(), I want to do something like this:

Code:

---

        std::vector <MyClass>* temp_ptr = first_object;
        first_object = second_object;
        second_object = temp_ptr;

---

However, that code isn't doing what I want it to, and for the life of me, I can't figure out why. Any words of advice?

vector has a swap member function. You can use that. Swapping pointers won't help here because it only changes what the pointers point to in the function, not what the pointers point to in the calling code. You could pass the pointers by reference to accomplish this, but there's no need since vector has a swap method.

I realise that this is a cut down piece of code, but if you're doing this here, you're almost certainly doing it in your main code.
The issue is that you should pretty much never dynamically create a vector. Think of a vector as a pointer to an array. Why would you dynamically allocate that pointer itself?! (okay it's actually typically 3 pointers but no diff)
The array inside the vector is already dynamically allocated. Then to pass them to another function, you do so by reference (const if that function doesn't modify them)

Here's a corrected and simplified version of your sample program:

Code:

---

#include <vector>
#include <string>

class MyClass
{
public:
        std::string some_string;
        double some_double;

        MyClass() : some_double() {}
};

void function(std::vector<MyClass> &, std::vector<MyClass> &);

int main(void)
{
        std::vector<MyClass> first_object, second_object;
        function(first_object, second_object);

        return 0;
}

void function(std::vector<MyClass> &first_object, std::vector<MyClass> &second_object)
{
        //Do stuff to first_object.
        //...
        //Do stuff to second_object.
        //...

        first_object.swap(second_object);
}

---

I could tell you why your original version didn't work, but that would probably lead you furthur away from how it should be implemented.

An advice:
http://apps.sourceforge.net/mediawik...arameter_names

Quote:

---

Originally Posted by Elysia

An advice:
http://apps.sourceforge.net/mediawik...es&action=edit

---

Actually I second that, as it had actually confused me for a second when I edited the original code.
I nearly decided to reorder it anyway so that function came before main, eliminating the need for the prototype.

I agree with using the variable names in the function prototypes. It certainly makes the code easier to understand.

Quote:

---

Originally Posted by iMalc

I realise that this is a cut down piece of code, but if you're doing this here, you're almost certainly doing it in your main code.
The issue is that you should pretty much never dynamically create a vector. Think of a vector as a pointer to an array. Why would you dynamically allocate that pointer itself?! (okay it's actually typically 3 pointers but no diff)
The array inside the vector is already dynamically allocated. Then to pass them to another function, you do so by reference (const if that function doesn't modify them)

Here's a corrected and simplified version of your sample program:

Code:

---

snip

---

I could tell you why your original version didn't work, but that would probably lead you furthur away from how it should be implemented.

---

I almost asked about dynamically creating vectors in my original question, because it didn't seem right. The first draft of my program used references instead of pointers, but the swapping of vectors seemed slow (however, I wasn't using the swap() member function ... I'll try that now). In my actual program, the class can be rather large, and the vector can also be quite big (somewhere in the hundreds). I'm also calling "function()" many, many times. My thinking was that the swapping of pointers would mean exchanging an extremely small value, rather than a gigantic vector of stuff. Is my thinking way off? If so, why?

Quote:

---

Originally Posted by Mostly Harmless

I agree with using the variable names in the function prototypes. It certainly makes the code easier to understand.


I almost asked about dynamically creating vectors in my original question, because it didn't seem right. The first draft of my program used references instead of pointers, but the swapping of vectors seemed slow (however, I wasn't using the swap() member function ... I'll try that now). In my actual program, the class can be rather large, and the vector can also be quite big (somewhere in the hundreds). I'm also calling "function()" many, many times. My thinking was that the swapping of pointers would mean exchanging an extremely small value, rather than a gigantic vector of stuff. Is my thinking way off? If so, why?

---

Your concern about not wanting to swap by copying a large number of large items is a very valid concern. Fortunately it is a very common concern, and as such a method exists in the vector class to perform this function very efficiently. It just internally swaps the pointers to their internal dymanically allocated memory around.:cool: