Thread: Protecting object members

Plenty of questions lately!

Ok, if I have a member of a class that has private scope and is a pointer (for the sake of this question it can be of any type); I have another object that is requesting information from the first object. The only way I can think of to protect the integrity of the private member is to copy to a temporary variable of the same data type and return a copy of it. Is this the most efficient way of doing this?

Code:

class foo
{
private:
   Someobject* so;
public:
    ...
   Someobject getData(void);  // Return a copy of the so data member
};

Someobject foo::getData(void)
{
  Someobject temp;

   // Assume that Someobject has an overloaded operator= defined
   temp = so;

  // Return a copy of the member object
  return temp; 
}

I think you should be able to use const in some way to protect it, so that you can only read it, not modify it. I'm not sure though.

Your right, but that would only work in the instance that you do not want to change its value through the use of an appropriate member function. In many cases you may wish to adjust the value or the contents of a private member through a member function, but still be able to return the information contained within (and not have the data inadvertantly changed by manipulating a returned pointer to the data).

Well, if you dont want the data to be modified, I guess you shouldn't return the address of the data. The obvious solution is, as you suggested, to return a copy of the data. But maybe you dont want that?

It depends on what kind of object you are returning. If someObject is a bitmap, a complete BSP structure or another kind of huge, maybe several megabytes big object, I'd just return a pointer to the object. After all, it's the objects responsibility to keeps it's integrity, not that of it's host.

However, if you want to allow limited access to the object, you could create a struct in the public scope with pointers to selected methods of the private object.

PHP Code:

class C
{
private:
    TYPE m_Variable;
public:
    const TYPE& getTYPE() const;  // Read Access
    TYPE& GetTYPE(); // Read and write access
};

const TYPE& C::getData() const
{
  return m_Variable; 
}

TYPE& C::getData()
{
  return m_Variable; 
} 


This way you have two accessor functions: a read only function that returns a constant reference, something you cannot use to change your original variable or another function you can use to modify your internal state. If you don't need the second variant, leave it out. Your compiler will pick what function to call dependent on your use.

Excellent - yeah, I reckon that is what I want.

thanks

nvoight, in your code, would I be right in saying that the function definitions SHOULD match their declaration? I assume it's a typo.