我想将一个操纵器列表传递给一个函数,如下所示:
void print(const vector<std::smanip>& manips) {
// ...
for (auto m : manips)
cout << m;
// ...
}
理想情况下,这将通过以下代码调用:
some_object.print({std::fixed, std::setprecision(2)}));
g ++ 4.7.0说:
error: ‘std::smanip’ has not been declared
显然,smanip标准中并没有真正定义,C++ 11编译器不需要为操纵器类型提供显式名称.我尝试通过从一个已知的操纵器中取出来声明一个类型,如下所示:
typedef decltype(std::fixed) manip;
这打开了一系列新的错误消息,包括这一消息:
error: ‘const _Tp* __gnu_cxx::new_allocator< <template-parameter-1-1>
>::address(__gnu_cxx::new_allocator< <template-parameter-1-1> >::const_reference)
const [with _Tp = std::ios_base&(std::ios_base&); __gnu_cxx::new_allocator<
<template-parameter-1-1> >::const_pointer = std::ios_base& (*)(std::ios_base&);
__gnu_cxx::new_allocator< <template-parameter-1-1> >::const_reference =
std::ios_base& (&)(std::ios_base&)]’ cannot be overloaded
我现在应该放弃,还是有办法做到这一点？
我正在寻找一个非常简单的子类化Scala集合的例子.我对这一切是如何以及为何有效的全面解释并不感兴趣; 很多这些都可以在这里和互联网上的其他地方找到.我想知道这样做的简单方法.
下面的类可能是一个尽可能简单的例子.这个想法是,使其子类Set[Int]有一个额外的方法:
class SlightlyCustomizedSet extends Set[Int] {
def findOdd: Option[Int] = find(_ % 2 == 1)
}
显然这是错误的.一个问题是没有构造函数可以将内容放入其中Set.CanBuildFrom必须构建一个对象,最好通过调用一些已知的库代码来知道如何构建它.我已经看到在配对对象中实现几个附加方法的示例,但它们显示了它是如何工作的或如何做更复杂的事情.我想看看如何利用库中已有的东西来解决这几行代码问题.实现这一目标的最简单,最简单的方法是什么？
我有一个MPI程序,由一个主进程组成,将命令交给一堆从进程.收到命令后,slave只需调用system()来执行此操作.当奴隶正在等待命令时,他们正在消耗100%的各自CPU.似乎Probe()坐在一个紧凑的循环中,但这只是猜测.您认为可能导致这种情况,我该怎么做才能解决这个问题？
这是从属进程中等待命令的代码.同时观察日志和top命令表明,当奴隶消耗他们的CPU时,他们就在这个功能中.
MpiMessage
Mpi::BlockingRecv() {
LOG(8, "BlockingRecv");
MpiMessage result;
MPI::Status status;
MPI::COMM_WORLD.Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, status);
result.source = status.Get_source();
result.tag = status.Get_tag();
int num_elems = status.Get_count(MPI_CHAR);
char buf[num_elems + 1];
MPI::COMM_WORLD.Recv(
buf, num_elems, MPI_CHAR, result.source, result.tag
);
result.data = buf;
LOG(7, "BlockingRecv about to return (%d, %d)", result.source, result.tag);
return result;
}
我明白怎么(let ((x v1) (y v2)) e)可以改写成((lambda (x y) e) v1 v2).但我不太熟悉let*.
我们如何(let* ((x v1) (y v2) (z v3)) e)在lambda和函数应用程序方面重写？
user=> (rseq [:a :b])
(:b :a)
user=> (rseq (rseq [:a :b]))
ClassCastException clojure.lang.APersistentVector$RSeq cannot be cast to
clojure.lang.Reversible clojure.core/rseq (core.clj:1532)
为什么不能rseq接受之前通话的结果rseq？
我在docstring中读到参数必须是(实际上,"可以是")一个向量或有序映射,而上面显示它不能是一个RSeq,所以我已经知道了.我想知道的是:有这个限制的充分理由吗？这只是一种疏忽,还是这种限制提供了一些重要的好处？
此外,除了从不调用之外,还有一个方便的解决方法rseq吗？很难知道,当你RSeq从一个函数返回一个函数时,其他某个函数是否会调用rseq它.
我问,因为它是令人沮丧的看到我的代码抛出异常这样令人惊讶的原因小号.如果我知道为什么这是有道理的,我可能不太可能犯这种和类似的错误.
宏的常规,表现良好的方式是什么,表明它已经传递了无效的参数？
(defmacro defthisthing [name & definitions] . . .)
我现在正在写一个宏来接受一大堆定义.如果相同的事情被定义两次,宏应该抱怨.类似地,如果其中一个定义使用的术语未在同一个宏调用中的其他地方定义,则宏应该抱怨,希望使用行号和列号,以便程序员可以准确地看到错误的位置.
我目前认为抛出异常是最有意义的,因为无效的宏参数实际上是编译错误.一切都应该关闭,就像编译器发现不平衡的括号一样.
如果这是正确的,抛出的常规例外是什么？那么如何包含有问题的代码片段的文件名和行号？
如果这不正确,Clojurely的方法是什么？
在这里解读循环继承的好方法是什么？
class Node {
// ...
public:
list<Node*> neighbors() { /* ... */ }
void update() { }
}
template<class NodeType>
class HasImportance : public virtual NodeType {
double m_importance = 0.0;
public:
void receive_importance(double imp) { /* ... */ }
void give_importance() {
for (auto neighbor : this->neighbors())
neighbor->receive_importance(m_importance /* ... */);
}
};
class TrafficLight : public HasImportance<TrafficLight>, virtual Node {
public:
list<TrafficLight*> neighbors() { ... }
void update() { give_importance(); /* ... */ }
};
它失败了(gcc 4.7.0),因为 …
在内部构建集合时Option,每次尝试使集合的下一个成员都可能失败,从而使集合整体失败.在第一次未能成为会员时,我想立即放弃并返回None整个收藏.在Scala中执行此操作的惯用方法是什么？
这是我提出的一种方法:
def findPartByName(name: String): Option[Part] = . . .
def allParts(names: Seq[String]): Option[Seq[Part]] =
names.foldLeft(Some(Seq.empty): Option[Seq[Part]]) {
(result, name) => result match {
case Some(parts) =>
findPartByName(name) flatMap { part => Some(parts :+ part) }
case None => None
}
}
换句话说,如果任何调用findPartByName返回None,则allParts返回None.否则,allParts返回Some包含集合的集合Parts,所有集合都保证有效.空集合是可以的.
以上优点是它findPartByName在第一次失败后停止呼叫.但foldLeft无论如何,仍然会为每个名称迭代一次.
这是一个版本,只要findPartByName返回一个拯救None:
def allParts2(names: Seq[String]): Option[Seq[Part]] = Some(
for (name <- …无论您是this.type从Trait内部还是从创建对象的范围引用,都会产生不同的结果.
import scala.reflect.runtime.universe._
trait Trait {
val ttag = typeOf[this.type]
println(s"Trait constructor: $this")
}
object Instance1 extends Trait
object Instance2 extends Trait
println(typeOf[Instance1.type] =:= typeOf[Instance2.type]) // Should be false
println(Instance1.ttag =:= Instance2.ttag) // Should be false
println(Instance1.ttag =:= typeOf[Instance1.type]) // Should be true
这是输出:
false // As expected: the singleton types of two objects are different.
Trait constructor: $line9.$read$$iw$$iw$$iw$$iw$Instance1$@58c46295
Trait constructor: $line10.$read$$iw$$iw$$iw$$iw$Instance2$@452451ba
true // But the this.type tags are equivalent
false // and the this.type tag is not …以下宏粘贴自http://docs.scala-lang.org/overviews/quasiquotes/usecases.html：
import reflect.macros.Context
import language.experimental.macros
val universe = reflect.runtime.universe; import universe._
import reflect.runtime.currentMirror
import tools.reflect.ToolBox
val toolbox = currentMirror.mkToolBox()
object debug {
def apply[T](x: =>T): T = macro impl
def impl(c: Context)(x: c.Tree) = { import c.universe._
val q"..$stats" = x
val loggedStats = stats.flatMap { stat =>
val msg = "executing " + showCode(stat)
List(q"println($msg)", stat)
}
q"..$loggedStats"
}
}
它在 Scala 2.11.1 中产生此错误消息：
Q.scala:9: error: macro implementation reference has wrong shape. required:
macro [<static object>].<method name>[[<type …