小编Jac*_*ack的帖子

也许我只是在一个非常简单的事情中失败,但我正在开发一个用OCaml编写的解释器,使用ocamllex和ocamlyacc等标准工具,我有这种情况:

• iparser.mly包含解析器规范
• ilexer.mll包含lexer规范
• impossible.ml包含执行代码的vm以及所需的所有类型

定义各种指令的指令类型impossible.ml在解析器中是必需的,但impossible.ml它使用定义的解析器,iparser.mly因此它们都需要彼此正确编译.

有没有办法.cmi为我生成文件impossible.ml？通过这种方式,解析器将知道定义的类型,impossible.ml并且它将允许我编译impossible.cmo/.cmi并稍后编译impossible.cmo.然后我可以将所有这些链接在一起.

到目前为止,我的编译脚本是:

ocamlyacc iparser.mly
ocamlc -c iparser.mli
ocamllex ilexer.mll
ocamlc -c ilexer.ml
ocamlc -c iparser.ml
ocamlc -c impossible.ml
ocamlc -o imp.exe ilexer.cmo iparser.cmo impossible.cmo

但这不起作用,因为ocamlc -c iparser.ml至少impossible.cmi需要知道类型.

有什么建议？提前致谢..

在项目中处理多个Flex/Bison解析器的最佳方法是什么？

我写了一个解析器,现在我需要在同一个项目中使用第二个解析器.到目前为止,在parser1.y我插入main(..)方法的第三部分并yyparse从那里调用.

我想获得是一种有两个不同的解析器(什么parser1.y和parser2.y),并能够从外部函数中使用它们(让我们假设main在main.cpp).

我应该使用哪些预防措施来导出文件yyparse外的函数.y以及如何处理两个解析器？

PS.我正在使用g ++编译而不是Flex和Bison的C++版本,我想保持这种方式(因此避免将解析器封装在对象中).

参考链接如何在OCaml中工作？

例如,假设我有3个模块声明为

• A.ml
• B.ml
• C.ml

其中

• A需要B和C
• B 需求 A

我该如何进行编译？

由于订单是相关的,ocamlc或者ocamlopt我如何修复B和之间的交叉参考A？

我想首先他们都汇编成.cmo用ocamlc -c,然后链接所有的人都在一起,但自从与交换参数将刚刚从一个模块移动到另一个问题没有成功.

具体错误是:

错误:链接A.cmo时出错:引用未定义的全局`B'

(或者反之,如果我交换了args的顺序)

我认为这是一个简单的问题,但我无法解决它...提前感谢

我需要存储一对,float,int其中int值存储float我正在开发的工具中使用的模型中出现的值的数量,我想知道这样做是否安全.

在谈论用于直接比较的浮点数(或作为要散列的内容)时,有限精度应该是一个问题所以我认为不鼓励使用类似的方法,我是对的吗？

实际上问题是我没有任何其他信息与这些浮点数相结合所以我根本不能使用其他任何东西作为哈希表的关键,但同时,因为键将很多,具有良好的性能将是不错.

也许最好的解决方案是使用二叉搜索树(或更高级的数据结构)来获得至少O(logn)的平均情况,如果常数因子更好的话.

你有什么建议吗？只是为了让你知道我正在开发OCaml,但我认为这些考虑可以被认为是语言无关的

我很想知道为什么会出现这种错误,哪种方法可以解决它.

我有几个文件types.ml,types.mli它们定义了一个变体类型value,可以有许多不同的内置OCaml类型(float,int,list,map,set等).

由于我必须在这个变体类型上使用std-lib,我需要通过仿函数将Set模块具体化,以便能够value通过定义ValueSet模块来使用类型集.

最终.ml文件类似于:

module rec I :
sig 
  type value =
    Nil
  | Int of int
  | Float of float
  | Complex of Complex.t
  | String of string
  | List of (value list) ref
  | Array of value array
  | Map of (value, value) Hashtbl.t
  | Set of ValueSet.t ref
  | Stack of value Stack.t
  ...

  type t = value 
  val compare : t -> t -> …

我正在研究我的游戏引擎的一小部分,并想知道如何优化一些部分.

情况非常简单,如下:

• 我有一张Tiles 的地图(存储在一个二维数组中)(约260k瓦片,但假设更多)
• 我有一个Items 列表,它总是至少和最多是一个瓷砖
• A Tile逻辑上可以包含无限量的Items
• 在游戏执行期间Item,不断创建许多s并且它们从它们自己开始Tile
• 每一个都Item不断地改变它Tile的邻居之一(向上,向右,向下,向左)

到目前为止,每个人Item都有对它的实际参考Tile,我只保留一个项目列表.每次Item移动到相邻的瓷砖我都会更新item->tile = ..,我很好.这很好但是它是单向的.

在扩展引擎的同时,我意识到我必须多次找到瓷砖中包含的所有物品,这实际上会降低性能(特别是在某些情况下,我必须逐个找到一系列瓷砖的所有物品) .

这意味着我想找到一个适合查找Tile比O(n)更好的特定项目的数据结构,但我想避免在"从一个瓷砖移动到另一个瓷砖"阶段(现在它只是指定一个指针,我想避免在那里做很多操作,因为它很频繁).

我正在考虑一个自定义数据结构,以利用物品总是移动到相邻单元格但我正在黑暗中摸索的事实!任何建议都会受到赞赏,甚至是棘手的或神秘的方法.不幸的是,我不能浪费内存,因此需要进行良好的权衡.

我正在使用STL在C++中开发它但没有Boost.(是的,我知道multimap,它不能让我满意,但如果我找不到更好的东西,我会试试)

我正在尝试向我的网站添加自定义字体。我尝试了很多事情但没有成功。这是我的CSS代码：

@font-face
{
    font-family: myFirstFont;
    src: url('ellis.ttf');
}

body
{
    margin: 0;
    padding: 0;
    width: 100%;
    cursor: default;
    font-size: 11px;
    line-height: 1;
    font-family: myFirstFont,arial,san-serif;
    overflow:auto;
    background:#ecf6f7;
}

我知道这不是跨浏览器的情况，但我首先尝试使工作成为一个简单的情况。

我正在考虑一些我必须在C++中实现的RPC代码,我想知道它是否安全(以及在哪些假设下)通过网络将其发送到相同的二进制代码(假设它完全相同并且它们在同一个二进制代码上运行)建筑).我猜虚拟内存在这里应该有所不同.

我只是出于好奇而问它,因为它在任何情况下都是一个糟糕的设计,但我想知道它是否在理论上是可行的(如果它可以扩展到除了程序可能包含的函数之外的其他类型的静态数据指针).

我想知道这个问题是否存在优雅的解决方案.

假设如下:

class Base {
  private:
    int data;
  protected:
    Base(int data) : data(data) { }
    int getData() const { return data; }
    virtual bool someOp() = 0;
}

class Derived1 : public Base {
  private:
    int data2;
  public:
    Derived1(int data, int data2) : Base(data), data2(data2) { }
    int getData2() const { return data2; }
    bool someOp() override { /* something */ }
}

class Derived2 : public Base {
  private:
    float data2;
  public:
    Derived1(int data, float data2) : Base(data), data2(data2) …

std::unordered_multimap在处理迭代时,我想知道关键对象的唯一性.

我将尝试解释这一点:我需要将一些数据与地图中的密钥类型相关联,这些数据不应该被考虑在内Hash或KeyEqual元素中,但我需要它以避免与它一起存储单独的地图(出于优化目的) .

所以与我的想法相关的代码如下:

struct Key {
  void* data;
  mutable bool attribute;

  Key(void* data) : data(data), attribute(false) { }
  bool operator==(const Key& other) const {
    return data == other.data;
  }
};

struct KeyHash {
  size_t operator()(const Key& key) const {
    return std::hash<void*>()(key.data);
  }
};

class Foo {
public:
  int i;
  Foo(int i) : i(i) { }
};

std::unordered_multimap<Key, Foo, KeyHash> map;

问题产生于这样的事实,尽管这种方法很好,但是不能保证作为std::pair<const Key, Foo>映射到单个元素的第一个元素检索的密钥总是相同的.作为一个pair的const Key这听起来像在地图上的每一个元素都有其通过值的密钥副本,因此,如果我这样做

void* target = new …