标签: implementation

有没有人有一个好的和有效的扩展方法来查找一系列项目是否有任何重复？

我猜我可以return subjects.Distinct().Count() == subjects.Count()使用扩展方法,但有点觉得应该有更好的方法.该方法必须对元素进行两次计数并整理所有distict元素.更好的实现应该在它找到的第一个副本上返回true.有什么好建议吗？

我想大纲可能是这样的:

public static bool HasDuplicates<T>(this IEnumerable<T> subjects)
{
    return subjects.HasDuplicates(EqualityComparer<T>.Default);
}

public static bool HasDuplicates<T>(this IEnumerable<T> subjects, IEqualityComparer<T> comparer)
{
    ...
}

但不太确定如何巧妙地实施它......

有人能否澄清主线DHT规范中的陈述？

在将第一节点插入其路由表中并且此后启动时,该节点应该尝试在DHT中找到与其自身最近的节点.它通过向更近和更近的节点发出find_node消息来做到这一点,直到找不到更近的节点.

什么"直到它找不到更近"是什么意思？

当我的程序开始发送find_node消息时,它有空的节点集.对find_node消息的每个响应都返回大约8个dht节点.我的程序在列表中收集它们.

我的程序何时必须停止发送查找节点消息？

我认为它必须停止发送它何时会收到dht节点的集合,其中所有元素都在已经收集的节点列表中？

我对吗？

先感谢您.

我还没有尝试过D,但它似乎是一种非常有趣的语言,它为C++中的问题找到了一些巧妙的解决方案.我很好奇,是否也可以将界面与模板中的实现分开？如果是,那怎么样？

我的目标不是编写C编译器,但我确实需要C编程语言的完整语法.这将允许我编写程序来更轻松地格式化,管理和分析C程序和库.为了达到这个目的,我除了能够掌握语言的整个语法之外别无选择.

语法应清楚地说明什么是有效的和什么是无效的.考虑以下代码行:

int (x) = 0;

看到这个声明的AC程序员可能对它的有效性犹豫不决,直到他试图编译它,他可能不知道它实际上是有效的C.当然,很容易说它等同于int x = 0;并且周围的括号括起来.x是多余的,但对于第一次看到它是否被允许的程序员来说,这是不明确的.

这是关于语言的完整语法我需要的详细程度.实现者必须足以使用它来编写可编译任何C代码的编译器,即使我的目的不是编写编译器,但我的项目需要完整的语法细节.

请耐心等待我,因为我仍然掌握Java.

示例下面的示例从名为Class的类中读取,该类Parent在该main方法上创建自身的实例.然后它使该实例进行各种计算.

接下来,它会激活一个名为Child传递Parent实例的线程作为引用Child.

该Child只是坐在那里监督的事情,有时,激发了公众的方法Parent.

有用.问题是,这种风格很差吗？是否有更多的Java思维方式来做这种工作？

public class Parent {

    // main function that fires up the program
    public static void main() {

        // creates an instance of himself
        // and fires go that does all sorts of fuzzy calculus
        Parent parent = new Parent();
        parent.go();

        // creates a new thread of child and starts it
        Child child = new Child(parent);
        child.start();
    } …

从本质上讲,这是我的源代码.

namespace name {  
    int func (void);  
}

int main (void) {  
    name::int func (void) {  
        //body
    }  
    return 0;  
}

现在,我想在不同的地方编写在命名空间中声明的函数.

我试图找到一种干净的方法来分离大项目中C++头文件中的实现细节,以实现更好的信息隐藏并减少构建时间.C++的问题在于,每次更改私有成员声明时,都必须重建依赖类.

这是我提出的解决方案.这有什么好处吗？我不是C++专家,所以我很有可能完全错过了一些东西,所以请光临我.

基本的想法是 在标题中有条件地包含cpp文件的一部分.此部分包含实现声明,仅在实现文件包含标头时包含.在外部类的情况下,此详细信息将从标题中排除.所以客户端和实现看到两个不同版本的头文件.内部声明更改不会影响客户端(不编译依赖类),标头不会包含私有详细信息.

这是实施:

HEADER

#pragma once

class Dependency
{
public:
    Dependency(void);
    ~Dependency(void);
    void Proc(void);

//PRIVATE Implementaion details stays private
#ifdef Dependency_PRIVATE_IMPELEMENTATION
    #define Dependency_PRIVATE_MODE 1   
        #include "Dependency.cpp"
    #undef Dependency_PRIVATE_MODE
#endif 
};

CPP

#define Dependency_PRIVATE_IMPELEMENTATION
#include "Dependency.h"
#undef Dependency_PRIVATE_IMPELEMENTATION

#ifdef Dependency_PRIVATE_MODE
private:
    int _privateData;
#else

#include <iostream>

Dependency::Dependency(void)
{
//This line causes a runtime exception, see client
    Dependency::_privateData = 0;
}

Dependency::~Dependency(void)
{
}

void Dependency::Proc(void)
{
    std::cout << "Shiny happy functions.";
}

#endif

客户

#include "stdafx.h"
#include …

我有以下类层次结构:

trait Entity {
  type E <: Entity
  type S <: Something[E]
  def in: S
}

trait Something[E <: Entity] {
  def doSomething {
    // something
  }
}

class A extends Entity {
  def in = InA
  object InA extends Something[A]
}
class B extends Entity {
  def in = InB
  object InB extends Something[B]
}
class C extends Entity {
  def in = InC
  object InC extends Something[C]
}

以及我想要的其他地方:

val entities = Seq[Entity]
entities.map(_.in.doSomething)

但是,类型系统不允许我逃避该in方法定义 - …

我想知道如何在FORTRAN中实现内置函数sin(),因为我尝试编写可以接收标量和数组作为其输入变量的函数,其效果可以在sin()中找到,即sin (0)返回0和sin(a),其中数组a =(/ 0,3.14 ...),返回一个数组(0,0).

我希望我要编写的所有数学函数都具有这种灵活性和优势.有人可以帮我一个忙吗？

它是语言翻译吗？还是字节码解释器/ JIT编译器？我在哪里可以了解有关实现的更多信息(除了浏览源代码)？