标签: implementation

在C#中,我有一个类层次结构,顶部附近有几个抽象基类,并有相当数量的派生类.这些具体类中的一些具有一些相同实现的共同属性和方法.它让我感到浪费,因此一种解决方案可能是在另一个抽象基类中实现这种常见行为.

abstract class Control;

abstract class SquareControl: Control
{
    public int SquarishProperty;
    public void SquarishMethod();
};

class Window: SquareControl;
class Button: SquareControl;

但是,如果层次结构中的其他几个类共享某些其他行为,但是与另一个基类中的一个控件共享某些内容,该怎么办？也许有很多共同点.使用抽象基类实现对它进行建模是不切实际的吗？

abstract class FlashableControl: Control
{
    public int FlashyProperty;
    public void FlashMethod();
};

class StatusBar: FlashableControl;  // but it's also a bit square too, hmm...

那么如何在不使用基类的情况下跨类共享这样的实现呢？

我想我想将接口的实现委托给另一个类,并让该类代表所需的类实现这些属性和方法,这样对于用户来说,StatusBar和Window似乎支持标准接口,但是在涵盖它是实现它的其他东西.

我可以想象实现这种行为的聚合类,但这是否适当,是否有任何陷阱？有哪些替代方案？

谢谢

假设我们有一个包含n个元素的数组(n> 0).

我们想输出这些元素的列表,它们之间有一个分隔符.

解决此问题的常见方法是:

foreach item
  (
    output item
    output separator
  )
trim last separator

但是要做到这一点似乎有点混乱.

另一种方法是:

check that there is at least one element
loop
  (
     output element
     next element, or break if no more elements
     output separator
  )

但我不确定它是否会一直有效.

您是否看到其他聪明的方法,例如在C,C++中？

我最近回答了这个问题:

在PHP中使用静态方法有什么好理由？

当然,首先想到的是一个单身人士.除了一点点例外,其他回答者提供了相同的单例示例.但这让我思考......除了创造单身之外,我并没有真正使用静态方法或属性!

简短的搜索结合了许多关于使用静态方法的教程,几乎所有这些教程都实现了相同单例类的一些变体.

我真的很感兴趣:除了创建单例(或者只是懒惰而想要一个全局函数)之外,我们还有什么理由要创建静态方法？

有没有人有一个使用静态方法的实用例子,使用动态设计模式无法更好地完成？如果在它的上下文中有意义,那么这个例子可以是单例,但除了解决方案的单例方面之外,我还有其他原因.

function A() {
     function B() {
          ...
     }        
     B();
}

是B每次A调用创建的函数还是有一些缓存.不是像当地人一样:

function A() {
    B();
}
function B() {
    ...
}

显着的性能提升？

这样做风格选择有效吗？(B在这种情况下,它只是一个辅助函数A.)或者第二个是否应该受到速度的青睐？

是否应该使用或避免使用此样式以提高可读性？

基准.

似乎FF4内联B本地案例并删除函数调用开销.

其他浏览器怎么样？

我是一个主要使用Java的新手程序员.最近我对Ruby感兴趣,当我去下载IDE时,我惊讶地发现没有单一的实现或语言解释器.我一直在努力研究这个问题,但我并不真正理解如何创建一种语言以便知道要寻找什么.

单一语言如何有多个解释器？这是否意味着它们之间存在重要差异,这对程序员意味着什么？如果这是一个误入歧途的问题,请原谅!

+(BOOL)resolveClassMethod:(SEL)aSel {
    NSString *lString = NSStringFromSelector(aSel);

    if ([self validateLetterAndAccidental:lString]) {

        id (^noteFactoryBLOCK)(id) = ^(id aSelf) {
            return [self noteWithString:lString];
        };

        IMP lIMP = imp_implementationWithBlock(noteFactoryBLOCK);
        ...

我在最后一行收到错误,因为noteFactoryBLOCK被强制转换为void*而ARC不允许这样做.目前有办法实现我想要的吗？我想要一个IMP,我可以在运行时传递给class_addMethod.

编辑

    IMP myIMP = imp_implementationWithBlock(objc_unretainedPointer(noteFactoryBLOCK));

这条线给我一个警告而不是错误 - Semantic Issue: Passing 'objc_objectptr_t' (aka 'const void *') to parameter of type 'void *' discards qualifiers

我想知道你是否可以帮我一个简单的实现来检测C#中有向图的周期.

我已经阅读了算法,但我想找到已经实现的东西,非常简单和简短.

我不关心性能,因为数据大小有限.

我对C++比较陌生,我认为我的问题最好通过例子来理解.在我的头文件中,假设我有

class myClass{
    public:
        double getVar1();
        void setVar1(double newVar1);
        void copyVar1(myClass* dat);

    private:
        double var1;
};

在我的实现.cc文件中,在实现copyVar1方法时,我应该这样做

void myClass::copyVar1(myClass* dat){
   var1 = dat->var1;
}

要么

void myClass::copyVar1(myClass* dat){
   var1 = dat->getVar1();
}

在第二种情况下,我使用getter方法代替.两者都可以在Visual C++中正常工作,但我想知道在实践中哪个更好用.

谢谢您的意见!

我对接口编程相当新,并试图将其作为开发测试驱动的主要工具.

目前我们有很多Manager类都实现了CRUD接口.但是有些经理还没有做更新,有些不做删除,有些可能永远不会做.

没有实现异常？

是没关系,只是

throw new NotImplementedException()

直到该方法得到实施,或者甚至是永远都没有？

(显然有一个源代码注释告诉程序员"不应该使用这种方法,例如像'男'女'那样的类型永远不会被删除)？

分裂？

或者我应该将我的CRUD界面拆分为可创建,可读(可搜索),可更新和可删除？这不会弄乱我的班级定义吗？

PersonManager implements Creatable<Person>, Updateable<Person>, Deletable<Person>, Searchable<Person>

拆分并结合？

或者我应该将所有4个接口组合到CRUD中,还是其他一些组合,如Read + Update？

也许这也会创建一个接口加载,人们必须通过一个大的继承路径来找出哪个接口为当前情况实现所有所需的原子接口(我需要读取和创建,所以哪一个只实现了两个？这可以快速复杂得多)

在大型软件实现中,通常建议在API设计与其实现之间进行分离.但在某个地方,它们必须重新连接(即,实现必须重新连接到API).

以下示例显示了API设计以及通过INSTANCE对象调用其实现:

import java.util.List;

public abstract class Separation {

    public static final Separation INSTANCE = new SeparationImpl();

    // Defining a special list
    public static interface MySpecialList<T> extends List<T> {
        void specialAdd(T item);
    }

    // Creation of a special list
    public abstract <T> MySpecialList<T> newSpecialList(Class<T> c);

    // Merging of a special list
    public abstract <T> MySpecialList<? extends T> specialMerge(
        MySpecialList<? super T> a, MySpecialList<? super T> b);

    // Implementation of separation
    public static class SeparationImpl extends Separation {

        @Override
        public <T> …