小编KCH*_*KCH的帖子

我需要为某些对象实现JSON序列化,并且在与泛型集合集成时遇到了问题.

所有可序列化的类都实现了这个接口(JSONObject来自这个库):

interface JSONSerializable{
    public JSONObject dump() throws JSONException //serializes object
    public void load(JSONObject obj) throws JSONException //deserializes object
}

基于java.util.list的我的集合代码看起来或多或少像这样:

class AwesomeList<T extends JSONSerializable> implements JSONSerializable{
    private LinkedList<T> items = new LinkedList<T>();
    ...
    ...

    public JSONObject dump() throws JSONException {
        JSONObject result = new JSONObject();
        JSONArray a = new JSONArray();
        for(T i : items){
            a.put(i.dump());
        }
        result.put("items", a);
        return result;
    }

    public void load(JSONObject obj) throws JSONException{
        //here is my problem
    }
}

我的问题是:当我从JSONObject加载AwesomeList时,我需要创建它的元素,但这是不可能的,因为java禁止我写

T newItem = …

有没有办法计算从python传递到C++的列表长度？我想做这样的事情,但列表类缺少length(或任何类似的)方法:

class Awesome{
  public:
    void awesomeMethod(const boost::python::list& list_of_something){
      list_of_something.length() // suprisingly there's no such method
    } 
};

我正在为学习德语的人们开发一个Java应用程序,我遇到了这种语言的特殊字符的问题.我想创建一个JTextField的子类,它将ALT + a解释为ä,将ALT + o解释为ö等,同时对所有ASCII字符执行常规操作.

到目前为止我的尝试:

public class GermanTextField extends JTextField implements KeyListener{
  public GermanTextField() {
    init();
  }

  // other constructors ...

  private void init() {
    addKeyListener(this);
  }



  public void keyPressed(KeyEvent arg0) {}


  public void keyReleased(KeyEvent arg0) {}


  public void keyTyped(KeyEvent evt) {
    if(evt.getKeyChar() == 'o' && evt.isAltGraphDown()){
      setText(getText() + "ö");
      evt.consume();
    }
  }


}

上面的代码不起作用(GermanTextField行为类似于标准的JTextField),当我打印evt.getKeyChar()到控制台时,这是我得到的:

?
?
?
?

这可能是由于我自己的语言,因为ALT + o在我的系统上产生ó.当然我可以这样做:

  public void keyTyped(KeyEvent evt) {
    if(evt.getKeyChar() == 'ó'){
      setText(getText() + "ö");
      evt.consume();
    } …

我有一个有向图G作为邻接列表列表给出:

newtype Graph Int = Graph [(Int, [Int])]

G有n个顶点和m个边.我正在尝试在Haskell中实现BFS算法,该算法在O(m)时间内运行(可能是摊销),但是最好的解决方案我能够在O(m*log n)中运行并使用Data.Map模块中的数据结构.

我对线性解决方案的想法如下:从Data.Sequence高效的FIFO队列中使用结构,并像BFS那样做必要的事情,但是我必须将节点标记为已访问.

我的问题是:是否可以在O(m)中运行的Haskell(或任何其他纯功能语言)中实现BFS？如果不是,您可以用什么论证来证明这种说法？

我正在尝试使C++类类似 std::ostream,它将输入并写入std::ostream构造函数中给出的两个s.这里它与适当的operator<<模板一起:

struct SplitStream
{
    SplitStream(std::ostream & a_, std::ostream & b_) : a(a_), b(b_) {}
    std::ostream & a, & b;
};


template<class T>
const SplitStream & operator << (const SplitStream & sp, const T & x)
{
    sp.a << x;
    sp.b << x;
    return sp;
}

这段代码下面有几行,我尝试使用这个类:

void foo(SplitStream & out)
{
    double some_double = 1.23;
    out << "bar" << some_double << std::endl;
}

我得到了这个相当神秘的错误:

... error C2678: binary '<<' : no operator found which …

编译此程序时:

module type Inc =
    sig
        type t
        val inc : t -> t
    end

module type Dec = 
    sig
        type t
        val dec : t -> t
    end

module Merger (I : Inc) (D : Dec with type t = I.t) =
    struct
        let merge x = x |> I.inc |> D.dec
    end

module IntInc : Inc = 
    struct
        type t = int
        let inc x = x + 10
    end

module IntDec : Dec = 
    struct 
        type t …