query on design of classes

[pauldepstein]

I am working with a class which has a constructor which takes several
parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C) {} // ....}

I want to amend MyClass slightly so that it takes more parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C, AddOneMoreType D) {} // ....}
I am told not to do that because MyClass should not be changed and
because adding more parameters is seen as unwieldy. I am told to
derive a class from MyClass and to add the extra parameters such as D
of type AddOneMoreType etc. to the derived class. This must be quite
a common thing to do but I'm not sure how to design this.

Something like class MyNewClass: public MyClass{ public:
MyNewClass(AddOneMoreType D){} } but this doesn't work because this
doesn't reflect the fact that members of MyNewClass also take
parameters A, B and C from the base class.

Another idea is class MyNewClass: public MyClass{ public:
MyNewClass(SomeType A, SomeOtherType B, YetAnotherType C,
AddOneMoreType D) {} } but that leads to the objection that using
too many parameters in the constructor is seen as unwieldy.

Thank you for any suggestions.

Paul Epstein

[anon]

pa**********@att.net wrote:

I am working with a class which has a constructor which takes several
parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C) {} // ....}

I want to amend MyClass slightly so that it takes more parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C, AddOneMoreType D) {} // ....}
I am told not to do that because MyClass should not be changed and
because adding more parameters is seen as unwieldy. I am told to
derive a class from MyClass and to add the extra parameters such as D
of type AddOneMoreType etc. to the derived class. This must be quite
a common thing to do but I'm not sure how to design this.

Something like class MyNewClass: public MyClass{ public:
MyNewClass(AddOneMoreType D){} } but this doesn't work because this
doesn't reflect the fact that members of MyNewClass also take
parameters A, B and C from the base class.

Another idea is class MyNewClass: public MyClass{ public:
MyNewClass(SomeType A, SomeOtherType B, YetAnotherType C,
AddOneMoreType D) {} } but that leads to the objection that using
too many parameters in the constructor is seen as unwieldy.

class MyNewClass: public MyClass
{
public:
MyNewClass( SomeType A,
SomeOtherType B,
YetAnotherType C,
AddOneMoreType D ) : MyClass( A, B, C )
{}
}

is the correct way, but some classes are just not meant to be used as
base classes. What if MyClass has no virtual destructor?

[pauldepstein]

On Dec 5, 10:42 pm, anon <[e-mail]:

[e-mail] wrote:

I am working with a class which has a constructor which takes several
parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C) {} // ....}

I want to amend MyClass slightly so that it takes more parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C, AddOneMoreType D) {} // ....}
I am told not to do that because MyClass should not be changed and
because adding more parameters is seen as unwieldy. I am told to
derive a class from MyClass and to add the extra parameters such as D
of type AddOneMoreType etc. to the derived class. This must be quite
a common thing to do but I'm not sure how to design this.

Something like class MyNewClass: public MyClass{ public:
MyNewClass(AddOneMoreType D){} } but this doesn't work because this
doesn't reflect the fact that members of MyNewClass also take
parameters A, B and C from the base class.

Another idea is class MyNewClass: public MyClass{ public:
MyNewClass(SomeType A, SomeOtherType B, YetAnotherType C,
AddOneMoreType D) {} } but that leads to the objection that using
too many parameters in the constructor is seen as unwieldy.

class MyNewClass: public MyClass
{
public:
MyNewClass( SomeType A,
SomeOtherType B,
YetAnotherType C,
AddOneMoreType D ) : MyClass( A, B, C )
{}

}

is the correct way, but some classes are just not meant to be used as
base classes. What if MyClass has no virtual destructor?- Hide quoted text -

- Show quoted text -

Thanks a lot. I wanted to avoid long constructors. (In reality I
would be adding parameters D, E etc to MyNewClass.) Perhaps I could
accomplish this by means of just adding a pointer. I was hoping there
was some syntax available that looked a bit like class MyNewClass:
public MyClass

{
public:
MyNewClass( AddOneMoreType D ) : MyClass( A, B, C )
{}

}

I know this is illegal though (hence my question). Thanks again for
your solution.

Paul Epstein

[anon]

pa**********@att.net wrote:

On Dec 5, 10:42 pm, anon <[e-mail]:

>[e-mail] wrote:

>>I am working with a class which has a constructor which takes several
parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C) {} // ....}
I want to amend MyClass slightly so that it takes more parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C, AddOneMoreType D) {} // ....}
I am told not to do that because MyClass should not be changed and
because adding more parameters is seen as unwieldy. I am told to
derive a class from MyClass and to add the extra parameters such as D
of type AddOneMoreType etc. to the derived class. This must be quite
a common thing to do but I'm not sure how to design this.
Something like class MyNewClass: public MyClass{ public:
MyNewClass(AddOneMoreType D){} } but this doesn't work because this
doesn't reflect the fact that members of MyNewClass also take
parameters A, B and C from the base class.
Another idea is class MyNewClass: public MyClass{ public:
MyNewClass(SomeType A, SomeOtherType B, YetAnotherType C,
AddOneMoreType D) {} } but that leads to the objection that using
too many parameters in the constructor is seen as unwieldy.

class MyNewClass: public MyClass
{
public:
MyNewClass( SomeType A,
SomeOtherType B,
YetAnotherType C,
AddOneMoreType D ) : MyClass( A, B, C )
{}

}

is the correct way, but some classes are just not meant to be used as
base classes. What if MyClass has no virtual destructor?- Hide quoted text -

- Show quoted text -

Thanks a lot. I wanted to avoid long constructors. (In reality I
would be adding parameters D, E etc to MyNewClass.) Perhaps I could
accomplish this by means of just adding a pointer. I was hoping there
was some syntax available that looked a bit like class MyNewClass:
public MyClass

>{
public:
MyNewClass( AddOneMoreType D ) : MyClass( A, B, C )
{}

}

IMO this is better then inheritance:

public MyClass
{
public:
MyNewClass( MyClass C, AddOneMoreType D ) : C( C ), D( D )
{}

private:
MyClass C;
AddOneMoreType D;

}

PS Better to pass C and D via reference or a pointer - depends what
types they are.

[pauldepstein]

On Dec 5, 11:54 pm, anon <[e-mail]:

[e-mail] wrote:

On Dec 5, 10:42 pm, anon <[e-mail]:

[e-mail] wrote:
I am working with a class which has a constructor which takes several
parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C) {} // ....}
I want to amend MyClass slightly so that it takes more parameters:
class MyClass {public: MyClass(SomeType A, SomeOtherType B,
YetAnotherType C, AddOneMoreType D) {} // ....}
I am told not to do that because MyClass should not be changed and
because adding more parameters is seen as unwieldy. I am told to
derive a class from MyClass and to add the extra parameters such as D
of type AddOneMoreType etc. to the derived class. This must be quite
a common thing to do but I'm not sure how to design this.
Something like class MyNewClass: public MyClass{ public:
MyNewClass(AddOneMoreType D){} } but this doesn't work because this
doesn't reflect the fact that members of MyNewClass also take
parameters A, B and C from the base class.
Another idea is class MyNewClass: public MyClass{ public:
MyNewClass(SomeType A, SomeOtherType B, YetAnotherType C,
AddOneMoreType D) {} } but that leads to the objection that using
too many parameters in the constructor is seen as unwieldy.
class MyNewClass: public MyClass
{
public:
MyNewClass( SomeType A,
SomeOtherType B,
YetAnotherType C,
AddOneMoreType D ) : MyClass( A, B, C )
{}

}

is the correct way, but some classes are just not meant to be used as
base classes. What if MyClass has no virtual destructor?- Hide quoted text -

- Show quoted text -

Thanks a lot. I wanted to avoid long constructors. (In reality I
would be adding parameters D, E etc to MyNewClass.) Perhaps I could
accomplish this by means of just adding a pointer. I was hoping there
was some syntax available that looked a bit like class MyNewClass:
public MyClass

{
public:
MyNewClass( AddOneMoreType D ) : MyClass( A, B, C )
{}

}

IMO this is better then inheritance:

public MyClass
{
public:
MyNewClass( MyClass C, AddOneMoreType D ) : C( C ), D( D )
{}

private:
MyClass C;
AddOneMoreType D;

}

PS Better to pass C and D via reference or a pointer - depends what
types they are.- Hide quoted text -

- Show quoted text -

Thanks anon. Yes I also prefer this. This is exactly the kind of
thing I was looking for. I was surprised at the first line of your
code -- public MyClass I expected to see class MyClass
Is this an error caused by inadvertently lapsing into java or am I
missing something?

Thanks again.

Paul Epstein

[anon]

>public MyClass

>{
public:
MyNewClass( MyClass C, AddOneMoreType D ) : C( C ), D( D )
{}

private:
MyClass C;
AddOneMoreType D;

}

PS Better to pass C and D via reference or a pointer - depends what
types they are.- Hide quoted text -

- Show quoted text -

Thanks anon. Yes I also prefer this. This is exactly the kind of
thing I was looking for. I was surprised at the first line of your
code -- public MyClass I expected to see class MyClass
Is this an error caused by inadvertently lapsing into java or am I
missing something?

Stupid copy/paste.

Should be:

class MyNewClass
{
public:
MyNewClass( MyClass C, AddOneMoreType D ) : C( C ), D( D )
{}

private:
MyClass C;
AddOneMoreType D;

}