template<typename T>
class CConstraint
{
public:
CConstraint()
{
}
virtual ~CConstraint()
{
}
template <typename TL>
void Verify(int position, int constraints[])
{
}
template <>
void Verify<int>(int, int[])
{
}
};
在g ++下编译它会产生以下错误:
非命名空间范围'类CConstraint'中的显式特化
在VC中,它编译得很好.任何人都可以让我知道解决方法吗？
我对scala数据结构序列化选项的意见感兴趣.我想找到一些开发得足以允许(如果可能的话)Scala集合类型的高效二进制序列化(即不使用通用Java反射 - 我不想序列化集合类的所有部分,包括内部记录数据)但也允许我为我自己的目的/类扩展功能:我很高兴必须为我们自己的每个类编写序列化代码,但不希望为Scala的集合编写代码.标准库.在C++中,我从Boost序列化库中获得了很多这样的功能.
我过去使用过SBinary,它可以完成我想要的一些操作,但是没有明显的主动维护,并且似乎(afaik)跟踪已经序列化的对象(例如,对于DAG或循环数据结构).
是否有其他Scala特定的解决方案,或者如果没有,您对高效二进制序列化的建议是什么？
在sbt 0.12中,您可以指定一个任务依赖于另一个任务而不实际使用输入任务的输出.所以你纯粹指定了任务的顺序:
unitTask <<= Seq(stringTask, sampleTask).dependOn
sbt 0.13的Tasks文档中没有这样的示例.指定所述依赖项的新语法是什么？
我有以下代码片段,虽然完全无关紧要,但它说明了我试图在更通用的代码中使用的模式.
template<typename InT, typename ResT>
ResT unary_apply( InT val, std::function<ResT(InT)> fn )
{
return fn(val);
}
我希望能够使用函数指针,函子,lambdas等来调用unary_apply:因此使用它std::function来抽象所有.
当我尝试以下列方式使用上述内容时,C++(g ++ 4.7)无法执行相关的类型推断:
double blah = unary_apply( 2, []( int v ) { return 3.0 * v; } );
失败了
src/fun.cpp:147:75: error: no matching function for call to ‘unary_apply(int, test()::<lambda(int)>)’
src/fun.cpp:147:75: note: candidate is:
src/fun.cpp:137:6: note: template<class InT, class ResT> ResT unary_apply(InT, std::function<ResT(InT)>)
src/fun.cpp:137:6: note: template argument deduction/substitution failed:
src/fun.cpp:147:75: note: ‘test()::<lambda(int)>’ is not derived from ‘std::function<ResT(double)>’
而且我发现我必须明确指定模板参数(实际上我认为它只是不可推断的返回类型):
double blah = …我现在正在试验Haskell并且非常享受这种体验,但我正在评估它是否具有一些相当严格的性能要求的真实项目.我的任务的第一步是处理维基百科的完整(无历史)转储(bzip) - 总共约6Gb压缩.在python中,每个原始页面(总共大约1000万)的完整提取的脚本在我的盒子上大约需要30分钟(对于参考,使用pull解析器的scala实现大约需要40分钟).我一直试图使用Haskell和ghc复制这个性能,并且一直在努力匹配这个.
我一直在使用Codec.Compression.BZip进行解压缩,使用hexpat进行解析.我使用lazy bytestrings作为hexpat的输入,使用严格的字节串作为元素文本类型.为了提取每个页面的文本,我正在构建一个指向文本元素的指针的Dlist,然后迭代它以将其转储到stdout.我刚刚描述的代码已经通过了许多分析/重构迭代(我很快从字符串转换到字节串,然后从字符串连接转移到指向文本的指针列表 - 然后转到指向文本的指针列表).我认为我从原始代码中获得了大约2个数量级的加速,但它仍需要一个半小时来解析(尽管它有一个可爱的小内存占用).所以我正在寻找社区的一些灵感,让我更加努力.代码如下(为了从分析器中获取更多细节,我将其分解为许多子功能).请原谅我的Haskell - 我只编写了几天(与Real World Haskell共度了一个星期).并提前感谢!
import System.Exit
import Data.Maybe
import Data.List
import Data.DList (DList)
import qualified Data.DList as DList
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy as LazyByteString
import qualified Codec.Compression.BZip as BZip
import Text.XML.Expat.Proc
import Text.XML.Expat.Tree
import Text.XML.Expat.Format
testFile = "../data/enwiki-latest-pages-articles.xml.bz2"
validPage pageData = case pageData of
(Just _, Just _) -> True
(_, _) -> False
scanChildren :: [UNode ByteString] -> DList ByteString
scanChildren c = case c …在为sbt 0.13构建插件时,重要的是scala 2.10的哪个版本的库依赖项(插件的)是针对什么构建的？
目前我的插件依赖于针对scala 2.10.2构建的库.这适用于单个构建,但是当构建(A)依赖于另一个构建(B)时,通过ProjectRef,我发现项目B中构建指令的sbt编译失败.似乎sbt正在使用2.10.2来构建指令文件,但是scala-reflect-2.10.0.jar正在加载(从sbt调试回溯,在Calling Scala compiler with arguments (CompilerInterface)打印到屏幕之后).
如果我自己构建引用的项目(B),指令文件的构建成功,但再次查看正在加载的jar,我看到它scala-2.10.2/lib/scala-reflect.jar被引用.
失败时的错误消息是:
[error] error while loading MacroValue, Missing dependency 'bad symbolic reference. A signature in MacroValue.class refers to term annotations
[error] in package scala.reflect.internal which is not available.
[error] It may be completely missing from the current classpath, or the version on
[error] the classpath might be incompatible with the version used when compiling MacroValue.class.', required by /home/alex.wilson/.ivy2/cache/org.scala-sbt/main-settings/jars/main-settings-0.13.0.jar(sbt/std/MacroValue.class)
[error] error while loading InputEvaluated, Missing …由于我昨天发布了一个关于Scala中元组的问题的一些有用的答案,我一直在寻找Scala HLists.我想从这个问题重新散列一个C++示例来问另一个:
在C++中,可以使用模板特化实现编译时递归.我经常对boost元组进行操作,像Scala/Haskell一样,HLists是通过多次组合泛型'cons'类型构建的,每个相关类型一次并以null_type结束.所以这:
boost::tuple<int, std::string, float>
在引擎盖下实施:
cons<int, cons<std::string, cons<float, null_type> > >
然后,我们可以编写一对在编译时通过此结构递归的函数,当第二个更专用的函数与最终的cons类型匹配时终止.一个简单的例子,计算元素的数量如下所示:
template<typename T1, typename T2>
void countTupleElements( boost::tuples::cons<T1, T2>& tupleRec, int index, const std::vector<std::string>& vals )
{
return 1 + countTupleElements( tupleRec.tail );
}
template<typename T>
void countTupleElements( boost::tuples::cons<T, boost::tuples::null_type>& tupleRec, int index, const std::vector<std::string>& vals )
{
return 1;
}
至关重要的是,这种模式通常用于你想为每种元组元素类型做一些不同的事情(在我的例子中未说明):在C++编译时递归是必不可少的,因为一旦代码运行,类型信息就会丢失用于所有有用的目的.
我的问题是,与Scala HList类似的东西,例如
val example = 1 :: 2.0 :: "Hello" :: "World" :: HNil
我知道在JVM上运行的Scala具有反射功能 - 因此可以使用运行时递归和使用清单和模式匹配的函数来实现.但我有兴趣知道是否可以使用编译时递归来做类似于C++示例的操作？
我在Scala中开发了两个相关的应用程序.一个是使用SBT构建的服务器端处理引擎,无头地执行一些数字运算(在cron作业上).另一个是用Scala编写并在play框架上运行的网站.
我希望能够在两者之间共享代码,但是因为每个代码(SBT和Play)都有自己关于目录结构和如何构建事物的想法,所以我很清楚我应该如何做到这一点.我不想复制和粘贴.scala文件 - 但我也不热衷于使用sym链接并让它们都使用相同的文件构建.
如果有可能,我会接受让Play脚本运行SBT来根据需要构建库.如果这是唯一的方法,那么我也可以使用SBT为Play构建jar,然后将它们复制到位.但我经常同时开发它们(它们是更大的应用程序的一部分),如果它们一起更新,它们将更加顺畅.这是否可能,或者是否还有另一种更简单的技术？
谢谢,亚历克斯
以下Scala代码(在2.9.2上):
var a = ( 0 until 100000 ).toStream
for ( i <- 0 until 100000 )
{
val memTot = Runtime.getRuntime().totalMemory().toDouble / ( 1024.0 * 1024.0 )
println( i, a.size, memTot )
a = a.map(identity)
}
在循环的每次迭代中使用不断增加的内存量.如果a定义为( 0 until 100000 ).toList,则内存使用量稳定(给予或采用GC).
我理解流可以懒惰地评估,但一旦生成就保留元素.但似乎在上面的代码中,每个新流(由最后一行代码生成)以某种方式保留对先前流的引用.有人可以解释一下吗？
Scala的新手,但是在C++方面经验丰富我试图在sqlite4java库之上实现(可能被误导)一个小型库,允许我从查询行(列类型各自与之兼容的行)中自动填充abritrary类型的元组相应的元组元素类型).
在C++中,我通常使用boost :: tuples和编译时模板递归来实现它(使用模板特化终止,如下所示).Boost元组的实现与Haskell HLists非常相似.模式将是(假设为简单起见,查询作为字符串向量返回):
template<typename T1, typename T2>
void populateTuple( boost::tuples::cons<T1, T2>& tupleRec, int index, const std::vector<std::string>& vals )
{
tupleRec.head = boost::lexical_cast<T1>( vals[index] );
populateTuple( tupleRec.tail, index+1, vals );
}
template<typename T>
void populateTuple( boost::tuples::cons<T, boost::tuples::null_type>& tupleRec, int index, const std::vector<std::string>& vals )
{
tupleRec.head = boost::lexical_cast<T>( vals[index] );
}
(道歉 - 我没有通过编译器运行上面的内容,但我希望它显示我的意思)
我希望能够用Scala做类似的事情.我可以通过Product trait递归一般的Tuple类型 - 并使用模式匹配(对于我支持的少量列类型)在运行时获取每个元素的类型.但是我还没有找到通过产品特性分配元组元素的方法.说实话,我不相信这是一种特别好的或惯用的方式来做我需要的.
但是像这样:
val returnedFromQuery = List[String]( "Hello", "4", "6.0" )
val rowAsTuples = interpretListAsTuple[(String, Int, Float)]( returnedFromQuery )
其中rowAsTuples具有类型(String,Int,Float).再次请原谅任何语法错误.
有人有什么想法？还是另类建议？事先 - 我对任何更高级别的SQL查询库都不感兴趣.我对sqlite4java很满意,但想用一个简单的更抽象的界面来包装它.
我有一个我希望分发的系统，其中有许多我希望以分布式方式处理的非常大的不可拆分的二进制文件。这些是几百 Gb 的数量级。由于各种固定的、特定于实现的原因，这些文件不能并行处理，而必须由同一进程顺序处理直到结束。
该应用程序是用 C++ 开发的，所以我会考虑使用 Hadoop 管道来传入和传出数据。每个实例都需要按 100Gb 到 200Gb 的顺序处理自己的数据（当前存储在一个文件中），并且应用程序当前（可能）IO 受限，因此每个作业完全在本地运行很重要。
我非常热衷于用 HDFS 来托管这些数据——自动维护冗余副本并在添加新节点时重新平衡的能力将非常有用。我也热衷于 map reduce，因为它计算简单，并且要求尽可能接近数据托管计算。但是，我想知道 Hadoop 对这个特定应用程序有多合适。
我知道为了表示我的数据，可以生成不可拆分的文件，或者生成巨大的序列文件（在我的情况下，单个文件的大小约为 10Tb - 我是否应该将所有数据打包到一）。因此可以使用 Hadoop 处理我的数据。但是，我的模型似乎不太适合 Hadoop：社区是否同意？或者有关于以最佳方式布置这些数据的建议？或者甚至对于可能更适合该模型的其他集群计算系统？
这个问题可能是关于 hadoop 的现有问题的重复，但除了我的系统需要每个单独文件一个或两个数量级的数据（以前我已经看到有关几个 Gb 大小的单个文件的问题） . 因此，如果之前已经回答过这个问题，请原谅我 - 即使对于这种大小的数据。
谢谢，
亚历克斯
我有一个关于在C++中实例化对象的简单问题:如果我们假设我的类有一个默认构造函数,那么我创建这样的新对象:
PfAlgorithm object = new PfAlgorithm();
但是当我跑步时我得到这个错误:
conversion from ‘PfAlgorithm*’ to non-scalar type ‘ns3::PfAlgorithm’ requested
有人可以向我解释这个错误的原因吗？非常感谢你.