2 classes, 1 method

[earthwormgaz]

So, I've got a class, A, and it does loads more than I want ..

class A {
doStuffIDontCareAbout() { } // loads of these
methodIDoNeed() { }
};

I've started writing a slim version that comes without all the cruft.
However, I've found there's methodIDoNeed. What's the best way to
share it between the two classes?

 

[earthwormgaz]

"Share"?  Yon can write a [relatively] simple wrapper around the 'A' and
provide only the functionality you need:

    class MyA {
         A a;
    public:
         void methodIDoNeed() { return a.methodIDoNeed(); }
    };

Is that what you call "share"?

Trouble is, A is bloated for my needs and does loads of stuff I don't
want. I just want a way for both classes to be able to use this
method.

I am thinking I could do it by pulling that method out into a function
which A and MyA can both call, but that's not very OO

 

[Joe Greer]

So, I've got a class, A, and it does loads more than I want ..

class A {
doStuffIDontCareAbout() { } // loads of these
methodIDoNeed() { }
};

I've started writing a slim version that comes without all the cruft.
However, I've found there's methodIDoNeed. What's the best way to
share it between the two classes?

You can always refactor it (and the data it needs) into a base class and
inherit that from both (privately if it's an implementation detail
only).

class base {
public:
methodIDoNeed(){}
private:
// data needed by methodIDoNeed()
};

class A : private /* or public */ base {
doStuffIDon'tCareAbout(){}
};

class SlimA : private base {
};


Or, if SlimA is a true subset of A, then just move stuff to SlimA, and
inherit SlimA from A.


class SlimA {
public:
methodIDoNeed(){}
private:
// data needed by methodIDoNeed()
};

class A : private /* or public */ SlimA {
doStuffIDon'tCareAbout(){}
};


That will get you code sharing anyway. Be careful with these kinds of
refactorings though. If you aren't careful to keep thing logically
meaningful, you can end up with a spaghetti-like mess and not be able to
make heads or tails of anything.

If you just want a smaller interface to the existing A, then you define
an abstract base class with the interface you want, inherit that
publicly in A and make your methods etc use the interface instead of A.

class ISlimA {
public:
virtual ~ISlimA(){}
virtual methodIDoNeed() = 0;
};

class A : public ISlimA {
doStuffIDontCareAbout() { } // loads of these
methodIDoNeed() { }
};

A a;

ISlimA & sa = a;
..
..
..

I didn't actually compile any of the above, but I think it's right.

HTH,
joe