setting member class

[Osama Aouda]

Hi All,

If you have the following class:
class foo
{
private:
int offset;
public:
void SetOffset(int InOffset);
};

foo::SetOffset(int InOffset)
{
offset = InOffset;
}

foo::DoSomething(int offset, int......)
{
// I can set offset two ways
SetOffset(InOffset); //1

offset = inOffset; //2

}
The question, within the class, should I call SetOffset, or just set
the private member. I know calling SetOffset causes an overhead (
function call), but you can say that if we make the SetOffset inline,
that will eliminate the overhead of calling function.

I always set the class memeber directly without the need to call the
function "SetOffset", but I ran into code that calls the function
instead of just changing the value of the class attributes. Any
suggestions why somebody would do that?
Question 2)

Have you seen something like this in the class declaration? why would
you do so?
foo(foo * pfoo); // foo is the class name

Thanks for the feedback.

[Salt_Peter]

Osama Aouda wrote:

Hi All,

If you have the following class:
class foo
{
private:
int offset;
public:
void SetOffset(int InOffset);

// missing:
void DoSomething(int, int);

};

foo::SetOffset(int InOffset)

void foo::SetOffset(int InOffset)

{
offset = InOffset;
}

foo::DoSomething(int offset, int......)

void foo::DoSomething(int offset, int......)

{
// I can set offset two ways
SetOffset(InOffset); //1

offset = inOffset; //2

}
The question, within the class, should I call SetOffset, or just set
the private member. I know calling SetOffset causes an overhead (
function call), but you can say that if we make the SetOffset inline,
that will eliminate the overhead of calling function.

What if SetOffset(...) has another purpose like limiting the offset
value allowed? Or maybe verifying the supplied parameter's validity in
some other way?t

void foo::SetOffset(int n)
{
offset = (n < 10) ? n : 10; // max = 10
}

try it.

>
I always set the class memeber directly without the need to call the
function "SetOffset", but I ran into code that calls the function
instead of just changing the value of the class attributes. Any
suggestions why somebody would do that?

What if you derive from class foo and would like the integer to remain
private?
What if foo is a member of another class and you need to have its
offset modified from the default?
class bar
{
foo f;
public:
void setOffset(int n)
{
// f.offset = n; // not allowed
f.SetOffset(n);
}
};

>

Question 2)

Have you seen something like this in the class declaration? why would
you do so?
foo(foo * pfoo); // foo is the class name

Imagine foo to be a node that you are inserting into a linked list.
pfoo might be a pointer to the next node in the list, which might be
null if its the last node.

>
Thanks for the feedback.

[amirkam1]

SetOffset(InOffset); //1

This might be required if you need to perform certain
operations/validations on the InOffset variable before assigning it to
member variable. If you make this inline, the overhead will not be
there, if the function just sets the value. And if the function
performs additional tasks then it will ensure that the code is not
repeated throughout the program.

foo(foo * pfoo); // foo is the class name

This type of code is usually required with recursive data structures,
where an object needs to store pointer to another object of the same
class. e.g. linked list OR parent-child structure. Take a look at
decorator design pattern, a similar code is required for its
implementation.
Amir Kamerkar

[Osama Aouda]

Thank you all for the reply.

Osama Aouda

am******@yahoo.com wrote:

SetOffset(InOffset); //1

This might be required if you need to perform certain
operations/validations on the InOffset variable before assigning it to
member variable. If you make this inline, the overhead will not be
there, if the function just sets the value. And if the function
performs additional tasks then it will ensure that the code is not
repeated throughout the program.

foo(foo * pfoo); // foo is the class name

This type of code is usually required with recursive data structures,
where an object needs to store pointer to another object of the same
class. e.g. linked list OR parent-child structure. Take a look at
decorator design pattern, a similar code is required for its
implementation.
Amir Kamerkar