4

问题比正常时间长，但我试图详细说明。请耐心等待并阅读整个问题，这可能是一个有趣的问题

我目前有一个方法 A，它接受一个具有两个属性List<X>但代表两个不同实体的对象，因此该属性被恰当地命名为 R 和 S。类结构是

class A
{
   List<X> R;
   List<X> S;
}

现在我有一个方法可以接受 A 类型的输入，并且可以同时使用（集合，方法签名如下）

public void updateMe(A objA)
{

}

现在我有一个需要重用此方法的情况，但现在的情况是我不需要区分实体，因此有一个列表List<X>T。

现在我的问题是如何重构该方法以使用单个列表，但仍然提供在早期情况下区分两个列表的能力。

我的方法将更新这些集合，因此要么添加到列表中，要么从中删除。

我目前的解决方案是创建新类来表示从 X 派生的两个不同实体，然后将这个基类列表传递给我的方法并让方法更新这个基类，然后在阅读它时我将能够识别哪个对象是什么类型。

因此我的新课程将是

public class X1:X
{
}

public class X2:X
{
}



class A
{
   List<X> R;
}

这是最好的解决方案还是我可以在这里采取任何其他方法.. 我似乎不喜欢扩展一个类只是为了识别类型而不添加任何属性的想法..

4

2 回答 2

0

似乎目标是在类的内容上实现一种形式的多态性。从这个意义上说，您应该为内部内容隔离一个类，因此我的回答侧重于导致您提出问题的目标，而不是问题本身。

一般来说，对于您的问题的先验，我会说两个集合之间的区别，每个集合代表一个不同的实体，不是代表类型的问题，假设它是正确的，而是调用者的责任。
我的回答遵循这条路径，但是以强类型的方式实现变量内部表示和更新逻辑，具有静态多态性（由于时间原因，省略了向您解释这个选择）。

作为决定是否使用 的子类的规则X，您应该问自己：操作和updateMe更新的逻辑，它是根据对象的细节来做的吗？List<X> RList<X> SX

我从你的问题中假设这并不总是两个列表，我的解决方案也概括了集合的类型。
我希望能给你一个起点。如果我猜到你的要求，我会说明更多。

template <class staticPolimorphicAInnerT>
class A 
{
    public:
        void updatMe (const A& ref) {
            // <do something pre if necessary>
            updateInnerMe (A.innerObj);
            // <do some other post if necessary>
        }

        void updateInnerMe (const staticPolimorphicAInnerT& innerRef) {
            innerObj.updateMe (innerRef);
            // or better: 
            // inner_update_method (innerRef)
        }

    private:
        // is used to request the static polymorphism
        typedef void (staticPolimorphicAInnerT::* inner_update_method) (const staticPolimorphicAInnerT&)
        staticPolimorphicAInnerT innerObj; 
        //<something more i hope> 

}

template <class T>
class AInnerFirst
{
    public:
        void updatMe (const AInnerFirst& ref) {
            // <do something with R>
            // <do something with S>
        }

    private:
        List<T> R;
        List<T> S;
}

template <class T>
class AInnerSecond 
{
    public:
        void updatMe (const AInnerSecond& ref) {
            // <do something with W>
        }

    private:
         Vector<T> W;
}
于 2014-04-25T10:10:35.257 回答
0

我会说，要么： 1. 使用 ENUM :) 2. 使用抽象方法 getList() 使类 Y&Z 扩展抽象 X。但这对于简单的情况来说肯定是矫枉过正。所以，回到 1 - 只需使用枚举 :)

于 2012-10-04T12:36:13.310 回答