小编tow*_*owi的帖子

我想编写一个通用的构建器类，它包含任何 java 类并提供特定样式的 setter 函数。我不确定这是否可以称为“动态生成的函数”。

当我有一个豆豆 Pojo 类时，即

class Pojo {
    public void setValue(int value) {...}
    public void setName(String name) {...}
}

我的Maker班级应该可以这样使用：

Pojo p = Builder<Pojo>.create(new Pojo())
             .setName("Funny")
             .setValue(123)
             .build();

如您所见，它所做的工作应该类似于

class PojoBuilder {
    private Pojo pojo;
    PojoBuilder(Pojo pojo) { this.pojo = pojo; }
    public static PojoMaker create(Pojo p) { return new PojoBuilder(p); }
    public PojoBuilder setName(String name) { pojo.setName(name); return this; }
    public PojoBuilder setValue(int val) { pojo.setValue(val); return this; }
    public Pojo make() …

我认为的调用operator<<会生成一个两参数的函数调用。那么，为什么不编译呢？

#include <iostream> // ostream
#include <iomanip> // setw, setfill
using std::ostream; using std::setw; using std::setfill;
struct Clock {
    int h_, m_, s_;
    Clock(int hours, int minutes, int seconds)
    : h_{hours}, m_{minutes}, s_{seconds} {}
    void setClock(int hours, int minutes, int seconds) {
        h_ = hours; m_ = minutes; s_ = seconds;
    }
    friend ostream& operator<<(ostream&os, const Clock& c) {
        auto w2 = [](ostream&os, int f) -> ostream& {
            return os << setw(2) << setfill( '0' ) << f; …

我想用 jq创建 JSON 输出，如下所示：

{
  "records": [
    {
      "id": "1234",
      "song": "Yesterday",
      "artist": "The Beatles"
    }
  ]
}

我认为我必须摆弄 jq 的“过滤器”，在阅读文档后我没有完全理解它的概念。

这是我到目前为止得到的：

$ jq --arg id 1234 \
     --arg song Yesterday \
     --arg artist "The Beatles" \
  '.' \
  <<<'{ "records" : [{ "id":"$id", "song":"$song", "artist":"$artist" }] }'

哪个打印

{
  "records": [
    {
      "id" : "$id",
      "song" : "$song",
      "artist" : "$artist"
    }
  ]
}

我要修改过滤器吗？我要更改输入吗？

我刚注意到,在N3291中标记了一个更改(5.2.1 Subscripting [expr.sub]):

之前,可以operator[]使用新的braced-init-list重载:

struct X {
    Z operator[](std::initializer_list<int>);
};
X x;
x[{1,2,3}] = 7; // OK: meaning x.operator[]({1,2,3})

现在删除并替换为:

braced-init-list不能与内置的下标运算符一起使用.

出了什么问题？

在N2812中是引言中的一个例子,其中a unique_ptr作为值参数给出

void push_back2(
  std::list<std::unique_ptr<int>>& l, std::unique_ptr<int> a)
{
  l.push_back(a); // oops: moves from the lvalue 'a', silently!
  l.push_back(a); // oops: 'a' no longer has its original value
}

本文讨论了RValue/LValue重载分辨率的问题,但这不是我的观点.

我想知道,如果提供参数std::unique_ptr<int> a by-value不会导致编译器错误？它会复制它,对吗？这是不允许的unique_ptr

我知道这篇论文很老了,也许这个定义unique_ptr已经改变了.但也许这只是一个错字,而作者想要写作std::unique_ptr<int> &a呢？

我的gcc 4.7.0与我同意,但那没有证据:-)

void push_back2( std::list<std::unique_ptr<int>>&, std::unique_ptr<int> ) { };
int main() {
  list<unique_ptr<int>> lst;
  unique_ptr<int> num { new int{4} };
  push_back2(lst, num); //ERR: use of deleted function
}

我必须重构并维护一堆看起来很糟糕的Java类.许多人具有以下实施模式

class Machine {
    public int advance(int state) {
        switch(state) {
        case 7:  return step_7();
        case 13: return step_13();
        case 4:  return step_4();
        }
    }
    private int step_7() {
        if(something) return 13; else return 4;
    }
    private int step_13() {
        ...
        return 4;
    }
    private int step_4() {
        if(miep) return 7;
        ...
        return 13;
    }
}

从这里我想生成一个图形(与Graphviz和dot) - 一种"静态调用图",但不完全.

我在这里游戏如何自动执行此操作,除了使用Perl或Python自己解析Java代码.

我真正喜欢的是有一个抽象语法树(AST)或类似我可以浏览的类,同时打印dot-code.

• 如何在这里生成可遍历的AST？我猜测遍历将在Java中完成,但如果输出是任何文本表示,那就没问题(gprof想到这里).
• 还有其他方法,不使用AST吗？也许我只是盲目的,有一种更好,更简单的方法.

在看到 Herb Sutters关于“原子武器”的精彩演讲后，我对放松原子的例子感到有些困惑。

myatomic.load();                          // (1)
myatomic.load(std::memory_order_seq_cst); // (2)

myatomic.load(std::memory_order_acquire);   // (3)