Si une proportion spécifique des membres soit partagé entre la base et les classes dérivées?

Question

Je suis en train de concevoir les classes pour une application que je vous écris pour mon cours, et j'ai deux classes qui son comme si elles doivent être une paire de classe dérivée de base, et ne partagent en effet deux variables membres, et mon problème est qu'ils ont chacun sept variables membres et aucune opération.

La raison de la structure de ces classes est que je construis un lecteur RSS et je l'intention d'avoir ces deux classes contiennent des données sur les flux. Le premier contiendra les données sur l'alimentation elle-même, par exemple l'URL source, l'emplacement du fichier rss.xml sur le stockage local, lorsque l'alimentation a été mise à jour, etc. La seconde contiendra des informations sur les articles contenus dans le nourrir tels que la date / heure et la publication d'un indice entier en fonction de la date de publication qui sera utilisée pour trier chronologiquement les articles.

class feed
{
    string title;
    string description;
    string feed_url;
    string local_location;
    string channel;
    bool feed_is_changed; // This is a flag that will be raised and lowered
      // when the feeds are being refreshed
    double last_updated; // The last update date/time will be converted to a
      //standardised double value
}

class feed_item
{
    string title;
    string description;
    double pub_time;
    double pub_time_in_sec; // I'm separating the seconds so they can be used
      // for a 'sub-index' when there are multiple feeds with the same pubtime
      // (there are restrictions on the data types we are allowed to use
      // (concocting work-arounds will aid in understanding, etc))
    double pub_date;
    int pub_year;
    int order_in_list; // The index that will be calculated from pub_time,
      // pub_date, etc
}

Le code ci-dessus n'est pas complète, je suis en train d'identifier uniquement les variables et les fonctions, et les bits privés / publiques seront une fois qu'ils sont finalisés. Comme vous pouvez le voir dans le code ci-dessus, les deux seules variables qui sont partagées sont titre et Description.

Je ne sais pas si ça vaut la peine de les faire une paire de base de l'entité et juste désactiver les cinq variables non pertinentes, si elle est plus efficace de simplement les rendre les classes complètement séparés, ou si cela est une préoccupation tout à fait de la situation, et que peut être avancé ou l'autre manière. Mes préoccupations sont que le code peut devenir difficile à la fois maintenir et échelle, mais qu'il peut y avoir exécution frais généraux inhérents à un ou l'autre méthode. Toute réflexion et des conseils sur ce seraient les plus appréciés.

Answer 1

A feed_item n'est pas un aliment, il ne le principe de substitution Liskov et shouldn » t être une sous-classe. Je devrais vérifier vos oreilles -. Cette paire de classes ne semble pas tout à fait comme ils devraient être sous-classes

De temps en temps (très, très rarement) l'héritage de la mise en œuvre est une bonne idée, mais il est généralement mieux fait en extrayant des parties communes dans une catégorie distincte et de l'utiliser dans les deux implémentations. Ici, il est tout à fait une idée terrible - il n'y a pas grand partage de code, de sorte que les avantages sont au mieux vague. Gardez votre code simple!

Answer 2

Juste une classe dérivée? Alors presque certainement l'héritage est la conception erronée.

L'héritage est limite, et ces limites ne semblent pas souvent que plus tard prendre la décision encore plus cher.

Ma règle générale est d'éviter l'héritage à moins que je puisse faire un cas clair et convaincant à l'utiliser.

Answer 3

Si tu voulais vraiment une classe de base:

struct NamedItem {  // or maybe just "Item"
  string title;
  string description;
};

struct Feed : NamedItem {/*...*/};
struct FeedItem : NamedItem {/*...*/};

Ou, on préfère en général et un meilleur ajustement dans ce cas, le confinement d'utilisation:

struct ItemInfo {
  string title;
  string description;
};

struct Feed {
  ItemInfo info;
  //...
};
struct FeedItem {
  ItemInfo info;
  //...
};

En particulier, si vous ne savez pas comment vous allez utiliser un « namedItem » sans connaître le type le plus dérivé, il n'a pas de sens à l'héritage d'utilisation.