Global scope and passing pointer

I'm trying to debug some code and have narrowed it down to my non-understanding of passing pointers. I've reviewed the forums but still haven't figured it out.

something like this:

Code:

objectContainer::objectContainer(devhandle* dev){}
objectContainer::dosomething1(){
VME_write(dev, data);
}

devhandle *dev;
getVMEhandle(dev);                    // get the device handle using library call
objectContainer Device1(dev);     // make an object that will contain the handle
...
Device1.dosomething1;
Device1.dosomething2;
...

But what's happening is that when I step into the objectContainer class functions using gdb and query the contents of "dev" they are changed. And of course when I step back into the global scope they haven't.

The result is that none of the containerized hardware calls will not work until I can pass the pointer correctly through the several layers of scope.

Looking for insight,
Dave++

post your code for objectContainer.

Code:

class objectContainter
   {
   private:
    vme_dev_handle *dev;     // Device Handle                                                                       
    long *Data;
    long *Data1;
...
   public:
    int icount;
    objectContainer(vme_dev_handle*);
...
};

objectContainer::objectContainer(vme_dev_handle* dev){
int count=1;
...
}

The only thing that the constructor needs to do is grab the handle for use by all its methods.
My question is, "how to pass the global scope pointer through multiple layers of calls?"

Thanks

I don't see your constructor actually storing the pointer in the object.

Originally Posted by CornedBee

I don't see your constructor actually storing the pointer in the object.

Wouldn't this happen automatically with the call?

Code:

private:
int a;
int b;
...

object::object(int a){
a = a;  // unnecessary?
b = a;  // extra effort?
}

As I continue to experiment I'm seeing that with each level of scope I could add another copy of the pointer (bad) or do my best to hold on to the original (goal).

Dave

Your Andromeda galaxy avatar is nice.

No, class variables are not automatically assigned values by the constructor. You have to do it yourself. Keep in mind that if a parameter has the same name as a class variable, you have to use this->variable to access the class variable.

Code:

class c {
private:
    int x;
    c(int x);
};

c::c(int x) {
    this->x = x;
}

Also, you might want to use initializers rather than code inside the constructor:

Code:

class c {
private:
    int x;
    c(int x) : x(x);
};

c::c(int x) {

}

Code:

class object
{
public:
    object(int);
private:
    int a;
    int b;
};

object::object(int a)
{
     a = a;  // assigns local a to local a. the one above this line. wastes time.
     b = a;  // assigns local a to object::b, otherwise known as this->b
}

dwks,
Thanks for the inputs. I was reviewing another thread while waiting for help...
Overloading -> (and ->*)

And began to see that their pointer wrapper is what I was attempting. I'll do some more testing and probably get back with results or more questions tomorrow (or later this evening).

Also, you obviously know some astronomy to know M31 (http://en.wikipedia.org/wiki/Andromeda_Galaxy)

dave.thanks(10^6);