How to make a copy of a pointer - c++

Question

I'm trying to copy a pointers data to another pointer, so that if I change one, the value in the other doesn't change.
I need this because I am coding a loop where I have two struct pointers, value, and lastValue. In each iteration of the loop I assign value's content to lastValue, and I fill value with new content. The problem is that because both are struct pointers, when I change value, lastValue changes too, and that's not the behavior I want. The code would be something like this (the structs are IplImages from OpenCV):
IplImage *value;
Iplimage *lastValue;
while(1)
{
lastValue=value;
value=cvQueryFrame( capture );//This fills the struct with new information
}
This would work if they where normal structs, but because they are pointers, both end up with the same value. Is there a way to get a copy of a pointer, with the same value, but different address?

Answer 1

value=cvQueryFrame( capture );
when I change value, lastValue changes too
No, it doesn't. The pointer value gets overwritten, as you desire. It is impossible for this line of code to affect lastValue.
but because they are pointers, both end up with the same value
No, it doesn't matter that they are pointers. Pointers are still objects in and of themselves.
However, cvQueryFrame returns a pointer to a buffer which you shall not modify or free as this is done for you:
Note that the image captured by the device is allocated/released by the capture function. There is no need to release it explicitly.
Though the documentation is a little unclear, it seems likely to me that the buffer is only valid until the next call to cvQueryFrame (which will then re-use the allocated memory). So even though lastValue can't and doesn't change, it happens to end up pointing to the new frame anyway.
To get around this, you can explicitly copy the object that lastValue points to:
lastValue = cvCloneImage(value);
Now you probably take on responsibility for freeing it (but again it's not entirely clear from my cursory glance at the documentation):
cvReleaseImage(&lastValue);

Answer 2

The function cvQueryFrame grabs a frame from camera or video file, decompresses and returns it. It returns the pointer to internal OpenCV buffer having the last grabbed frame. That should be the reason why you get the same value. If you want 2 frames, you should create a copy of the image.
IplImage * previousFrame, *currentFrame ;
CvCapture* video = cvCaptureFromAVI("video.avi");
currentFrame = cvQueryFrame( video );
// COPY IMAGE
previousFrame = cvCloneImage( currentFrame );
while(currentFrame = cvQueryFrame( video ))
{
//...
cvCopy( currentFrame , previousFrame);
}
//...

Answer 3

It looks like you're doing the right thing.
last_value = value; //copy pointer
but it isn't really what you want because it isn't the pointer you want to copy, it's the data inside. that's why the old pointer is updated along with the new pointer. I think what you need is a copy of the structure itself.
If the pointer points to some class you write, add a copy constructor method to it, then copy the value of the pointer like so:
last_value = new MyClass(*value); //construct object, copy from what value points to
//change value