小编Gre*_*Cat的帖子

我想在现代C++中实现构建器模式.来自Java背景,这是我想要模仿的东西:

// Usage
FooBuilder builder;
builder.setArg1(a);
builder.setArg2(b);
Foo foo = builder.build();

// Implementation
public class FooBuilder {
    // ...
    public Foo build() {
        return new Foo(a, b);
    }
}

典型的旧教科书只是建议一个人在C++中这样做:

class FooBuilder {
    // ...
    Foo* build() {
        return new Foo(m_a, m_b);
    }
}

这显然不是一个好主意,因为处理原始指针可能容易出错.到目前为止我提出的最好的是std::unique_ptr手动使用:

class FooBuilder {
    // ...
    std::unique_ptr<Foo> build() {
        return std::make_unique<Foo>(m_a, m_b);
    }
}

// Usage
auto fooPtr = builder.build();
Foo& foo = *fooPtr;
foo.someMethod();

它更好,因为它不需要手动delete,这个双线程转换为参考是丑陋的,更重要的是,它使用堆分配,而简单的无构建器版本只需一个简单的堆栈分配就完全没问题:

Foo foo(..., ...); // <= on …

是否有一些简单,探索良好的方法来在包中按名称搜索给定的类,并且递归地在此包的所有子包中进行搜索？

即给出现有的类,例如:

• foo.MyClass
• foo.bar.baz.some.more.MyClass
• foo.bar.baz.some.more.OtherClass

我想运行类似的结果magicMethod("foo.bar.baz", "MyClass")并获得Class foo.bar.baz.some.more.MyClass结果.

显然,手动实现相当容易 - 通过探索加载的包Package.getPackages(),过滤任何合适的东西并在循环中寻找类Class.forName(...)- 但可能在标准Java库或其他广泛的库(如Apache Commons)中有一些东西可以解决这个任务？

Scala以正确的功能方式在Java中执行以下代码的最佳方法是什么？

LinkedList<Item> itemsInRange = new LinkedList<Item>();
for (int y = 0; y < height(); y++) {
    for (int x = 0; x < width(); x++) {
        Item it = myMap.getItemAt(cy + y, cx + x);
        if (it != null)
            itemsInRange.add(it);
    }
}

// iterate over itemsInRange later

当然,它可以通过命令式方式直接转换为Scala:

val itemsInRange = new ListBuffer[Item]
for (y <- 0 until height) {
    for (x <- 0 until width) {
        val it = tileMap.getItemAt(cy + x, cx + x)
        if (!it.isEmpty)
            itemsInRange.append(it.get)
    } …

例如,我有一个这样的函数,它使用基于 C++ 11 范围的循环语法:

void myFunc(const std::vector<char>& bytes) {
    for (char b : bytes) {
        // do something useful to every byte
    }
}

如何改变这个函数的声明,接受每一个合适的序列容器,即不仅std::vector<char>,而且std::array<char>,std::string等？

从我所学到的,基于范围的for循环依赖于 给定的存在begin()和end()方法range_expression.通常,在其他语言中,这意味着所有可迭代容器共享某种通用接口,可用于为此类参数传递任意容器,但看起来C++没有任何类似的容器层次结构.相反,C++似乎有"概念",比如容器,但它只能在编译器内部访问,我猜？

Scala 借用了 Java String方法，例如toUpperCase / toLowerCase。

然而，它这样做的方式并不是很一致：

• JVM 上的 Scala 贴近 Java 语义，因此：
  • toUpperCase() 对语言环境敏感并坚持默认语言环境（给您带来臭名昭著的 i ? ? 土耳其语言环境问题）
  • 为避免这种情况并保持区域设置不敏感（en_US / C-like）过程，您需要专门执行 toUpperCase(Locale.ROOT)
• Scala.JS 没有实现Locale的概念，因此：
  • toUpperCase() 以不区分区域设置的方式工作
  • toUpperCase(Locale locale) 方法在 ScalaJS 中实际上不可用

如何在 JVM/JS 上的 Scala 中实现不区分区域设置的大小写转换？

我可以想到几种方法，它们都很丑陋：

方法一：我自己的实现

toUpperCase为英文字母表的 26 个 ASCII 字符实现我自己的。

方法 1.1：我自己使用 Scala 字符实现

基本相同，但至少重用 Scala toUpper来转换单个字符。

方法二：接口

实现类似的东西

trait CaseChangeOps {
  def toUpperCase(s: String): String
}

object Main {
  var caseChanger: CaseChanger
}

// whenever I want to …