标签: implementation

我有回收收集和协方差的问题,我想知道是否有人有更好的解决方案.

场景是这样的:

我有2个版本的实现,我想保持版本实现完全分离(即使它们可能具有相同的逻辑).在实现中,我想返回一个项目列表,因此在界面中,我将返回该项目的接口列表.但是,在实际的接口实现中,我想返回该项的具体对象.在代码中,它看起来像这样.

interface IItem
{
    // some properties here
}

interface IResult
{
    IList<IItem> Items { get; }
}

然后,将有2个名称空间具有这些接口的具体实现.例如,

命名空间版本1

class Item : IItem

class Result : IResult
{
    public List<Item> Items
    {
        get { // get the list from somewhere }
    }

    IList<IItem> IResult.Items
    {
        get
        {
            // due to covariance, i have to convert it
            return this.Items.ToList<IItem>();
        }
    }
}

在命名空间Version2下会有另一个相同的实现.

要创建这些对象,将有一个工厂接受版本并根据需要创建适当的具体类型.

如果调用者知道确切的版本并执行以下操作,则代码可以正常工作

Version1.Result result = new Version1.Result();
result.Items.Add(//something);

但是,我希望用户能够做到这样的事情.

IResult result = // create from …

我已经完成了90%的项目,我想只为它添加Cocos2D.我不需要Box2D或Chipmunk.我该怎么做？我添加了哪些文件？我真的需要这样做,所以最后如果需要的话,还会提供赏金.

谢谢!

我正在阅读ASP.NET MVC3的源代码,我在ControllerBase的代码中遇到了以下内容:

public interface IController
{
    void Excecute(RequestContext requestContext);
}


public abstract class ControllerBase : IController
{

    protected virtual void Execute(RequestContext requestContext)
    {
        if (requestContext == null)
        {
            throw new ArgumentNullException("requestContext");
        }
        if (requestContext.HttpContext == null)
        {
            throw new ArgumentException(MvcResources.ControllerBase_CannotExecuteWithNullHttpContext, "requestContext");
        }

        VerifyExecuteCalledOnce();
        Initialize(requestContext);

        using (ScopeStorage.CreateTransientScope())
        {
            ExecuteCore();
        }
    }

    void IController.Execute(RequestContext requestContext)
    {
        Execute(requestContext);
    }
}

ControllerBase提供了一个实现Execute,但它有一些提供...的定义IController.Execute？

为什么要这样做,它实现了什么？似乎没有任何意义.

问题标题的可怕性是我想要解决的问题.例:

在Ruby中,Enumerable是一个界面,在某种意义上我可以实现一些东西并将其记录为:

def myfancymethod(please_pass_me_an_Enumerable_here)

但另一方面,Enumerable是一种对#each作为其中一种方法的接口的放大.如果我有课

class Foo
  def each
    :bar
  end
end

对于那些不熟悉的Ruby,如果混入可枚举模块中的一类,你会得到许多方法,只有依靠#each的方法来提供类似的东西#map,#select等等.

我可以说我的Foo班级是可枚举的或可枚举的兼容或什么？什么术语描述了"成为一个可枚举者需要什么？","你必须拥有#each"的答案

同样,在Ruby中

(Array.new.methods - Object.new.methods).size # 111

这是否意味着伪造一个Array接口,我必须实现111个方法？没办法,但我怎么找出哪些方法是Array的"本质".它只是#[],#[]=而且#size？怎么理解它？

尝试在不同的编译器上编译以下代码给我两个不同的结果:

struct S{};
struct T{S S;};
int main(){}

正如您所看到的,在内部T,我有一个与之前定义的类名称相同的对象S.

在GCC 4.7.2上,我收到与S S;内部声明有关的以下错误T:

错误:声明'ST :: S'[-fpermissive]
错误:从'struct S'改变'S'的含义[-fpermissive]

但是,将它移到课堂外(或进入main)可以正常工作:

struct S{};
S S;
int main(){}

它给我的错误究竟是什么意思？

在Visual Studio 2012中,整个事件编译并运行没有任何错误.将它粘贴到这个Clang 3.0编译器中也没有错误.

哪个是对的？我真的可以这样做吗？

我目前正在Squeak环境中学习Smalltalk,而我正在阅读"Squeak - 快速前往ObjectLand".我使用Python和Java的一些先验知识进入面向对象的范例,第36页的书中的这句话让我想到:

Smalltalk是面向对象语言的基于类的实现.

短句但非常有趣.在OO中,类,对象,实例等所有术语似乎都是明确定义的,并且似乎指向唯一的真实含义,并且您可能会遇到类似"对象是类的实例"的通用句子.
但是你很少听到实施策略.什么是实现面向对象的概念,在这种情况下,是什么意思？除了类之外是否还有OO语言的实现？

我们所知道的std::advance是以下内容:

template <class InputIterator, class Distance>
void advance (InputIterator& i, Distance n);

目的

i按n元素推进迭代器.

如果i是随机访问迭代器,函数使用一次operator+或operator-,否则,该函数使用重复的增加或减少经营者(operator++或operator--),直到n元件已经前进.

我的问题如下:如何std::advance实现它识别是否it是随机访问迭代器？怎么知道它可以operator+代替operator++？

我得到了一个trie背后的概念.但是在实施方面我有点困惑.

我认为构建Trie类型最明显的方法是Trie维护内部Dictionary<char, Trie>.事实上,我已经用这种方式编写了一个,并且它可以工作,但是......这看起来有点过分了.我的印象是trie应该是轻量级的,并且每个节点都有一个单独的Dictionary<char, Trie>对我来说似乎不是很轻量级.

有没有更合适的方法来实现我缺少的这种结构？

更新:好的!基于Jon和leppie的非常有用的输入,这是我到目前为止所提出的:

(1)我有Trie类型,它有一个_nodes类型的私有成员Trie.INodeCollection.

(2)Trie.INodeCollection界面有以下成员:

interface INodeCollection
{
    bool TryGetNode(char key, out Trie node);
    INodeCollection Add(char key, Trie node);
    IEnumerable<Trie> GetNodes();
}

(3)此接口有三种实现方式:

class SingleNode : INodeCollection
{
    internal readonly char _key;
    internal readonly Trie _trie;

    public SingleNode(char key, Trie trie)
    { /*...*/ }

    // Add returns a SmallNodeCollection.
}

class SmallNodeCollection : INodeCollection …

我有一个接口和两个正在实现接口的类.

public interface MyInterface {
    public void firstMethod();  
    public int secondMethod();
}

public class MyClass1 implements MyInterface  {
    public void firstMethod() {}
}

public class MyClass2 implements MyInterface  {
    public void firstMethod() {}
    public int secondMethod() {}
}

这堂课MyClass1告诉我Add unimplemented methods,因为secondMethod没有实施,好的我会这样做.但问题是我不需要这种方法MyClass1.

在您看来,最好的做法是什么？

1. 使用类似的方法添加未实现的方法 return 0
2. 如果我不想实现它,还有另一种方法可以解决这个问题.

我有很多.c文件,即实现文件说

• main.c中
• AC
• 公元前

来自任何文件的函数可以从不同的文件中调用任何函数.我的问题是,我是否需要.h为A和B的每个实现提供一个ie头文件,其中每个头文件都有A或B 中所有函数的定义.

此外,main.c中会有两个A.h,并B.h #included在里面？

如果有人能够最终说清楚,那么我如何在以后编译并运行终端中的多个文件.

谢谢.