Is splitting to small classes good?

Question

I have materials.

class Material {...};
class ConcreteMaterialA : public Material {...};
class ConcreteMaterialB : public Material {...};

I want it has a name

class WithName
{
public:
    const string& Name() const          {return m_name;}
    void Rename(const string& name)     {m_name = name;}

private:
    string m_name;
}

And tracking its users

template<class UserTy>
class WithUsers
{
public:
    void AddUser(T* user)       {m_users.push_back(user);}
    const std::vector<T*>& Users() const    {return m_users;}

private:
    std::vector<T*> m_users;
};

And wrapped with pointer

template<class T>
class WithPtr
{
public:
    template<class U> T* Get() const;
    template<class U> void Reset(U* u);
    template<> T* Get<T>() const            {return m_object.get();}
    template<> void Reset<T>(T* t)          {return m_object.reset(t);}

private:
   std::unique_ptr<T> m_object;
};

Then I define my new material

class NewMaterial 
  : public WithPtr<Material>, public WithName, public WithUsers<MaterialUserType>
{}

It is kind of complex. I have many types need name, tracking users. Is it a good design? Thanks a lot.

Answer 1

It looks like what you have implemented are mixins. In the world of c++ with multiple inheritance, I think it is a good design decision as long as you make sure that the method names you are mixing in don't start overlapping - read: that your number of mixins doesn't get out of hand.

Another alternative would be to use composition instead of inheritance. Instead of extending all the classes from which you want to reuse functionality, you could keep fields which point to such instances instead.

In general, you should make sure that the functionality you are trying to reuse is complex enough to justify the overhead of inheritance/composition. For instance, your "name" mixin seems to me to be too simple and thus not worth the effort.