问题列表 - 第32285页

我试图了解现有的代码.

我们什么时候去寻找函数指针？特别喜欢下面的那个.

struct xx

{
  char *a;

  (*func)(char *a, void *b);

  void *b;

}


struct xx ppp[] = { };

然后检查sizeof(ppp)/ sizeof(*ppp);

我们什么时候采用这种方式？

我想测试foldl vs foldr.从我所看到的,你应该使用foldl over foldr,因为尾部递归优化.

这是有道理的.但是,运行此测试后,我很困惑:

foldr(使用时间命令时需要0.057秒):

a::a -> [a] -> [a]
a x = ([x] ++ )

main = putStrLn(show ( sum (foldr a [] [0.. 100000])))

foldl(使用time命令时需要0.089s):

b::[b] -> b -> [b]
b xs = ( ++ xs). (\y->[y])

main = putStrLn(show ( sum (foldl b [] [0.. 100000])))

很明显,这个例子很简单,但我很困惑为什么foldr击败foldl.这不应该是foldl获胜的明显案例吗？

我目前正在研究一些轻量级的SQL抽象模块.我的工作流程是这样的,我通常手动编写SELECT查询,并通过带有哈希的子进行INSERT/UPDATE查询.

这两个模块似乎都很适合我的需求,我很难决定.SQL :: Interp声称SQL :: Abstract无法在SQL中提供完整的表达能力,但没有讨论其他差异.

它有任何缺点吗？如果是这样,哪个？

tuple 在boost和TR1/c ++ 0x中提供了一个方便的(对于函数的编写者)方法从函数返回两个值 - 但它似乎损坏了调用者语言的一个主要特征:简单使用的能力初始化变量的函数:

T happy();
const auto meaningful_name(happy()); // RVO means no excess copies

但对于:

tuple<T,U> sad();

我们要么放弃为返回值选择有意义的名称的能力,要么在get<n>()任何地方使用:

const auto two_unrelated_things(sad());

或临时:

const auto unwanted_named_temporary(sad());
const auto one_name(get<0>(unwanted_named_temporary));
const auto two_name(get<1>(unwanted_named_temporary));

或从初始化切换到赋值,仅在类型可分配时有效,并且中断auto:

tuple_element<0, decltype(sad())>::type one_mutable; // there might be a less
tuple_element<1, decltype(sad())>::type two_mutable; // verbose way
tie(one_mutable,two_mutable) = sad();

或者对当地​​班级做一些不自然的事情:

const struct ugh { 
  ugh( decltype(sad()) rhs ) : one_name(get<0>(rhs)), two_name(get<1>(rhs)) {}
  const tuple_element<0, decltype(sad())>::type one_name;
  const tuple_element<1, decltype(sad())>::type two_name;
} stuff(sad()); …

我试图获得NSString的宽度(例如NSString*myString = @"hello").有没有办法做到这一点？

谢谢.

我是net-java开发人员,实现了一些小项目.我将开始一个新项目,该项目是具有许多典型功能的门户(帖子,评论,消息,用户,目录,新闻,画廊等).

我相信最好的解决方案是使用任何成熟的CMS(joomla,drupal ......)并根据需要进行自定义.问题是我不熟悉PHP(用PHP编写的CMS有更好的功能,插件,社区,我相信的信息)我不打算学习PHP,我想提高我的java-net技能.

所以我的问题是:自己写一些,提高我的编程技巧,并冒着在相对较长的时间内完成我的项目的风险

另一方面

我可以花一些时间学习工具和语言,我认为这些工具和语言在将来我不需要,并且更有可能在更短的时间内完成我的项目

你会建议什么？

如何使用.NET创建或标记隐藏文件？

我对有关此事的规则感到困惑[一个好的URL可能会节省回答的时间].我注意到很多时间转换隐含地起作用,但其他时候它是必需的.

例如,我曾预料到它会起作用:

long long a;
int b;
[..]
a = b * 1000;

但事实证明,'a'溢出并且它是必需的

a = (long long) b * 1000;

这是特殊的,因为'a'是我认为它会打扰的'大'.

无论如何,除了这个例子,您是否知道有关此事的全面信息来源？没有"大部分时间都没事",这让我变得偏执.

编辑:这只是'第二部分首先进行计算并且溢出,遵循该规则'的问题吗？

EDIT2:如果有计算如

long long a;
int b;
short c;
[..]
c = b + a * 3;

,会做的

c = b + (int) a * 3; 

确保正确转换？

还是需要呢？

c = (short) b + (int) a * 3; 

或者,它是否足够

c = (short) b + a * 3; 

我希望获得有关部署到单个Tomcat实例的单服务器Java Web应用程序可以处理的工作负载规模的更多信息.特别是,让我假装我正在开发一个具有类似维基百科的使用模式的Wiki应用程序.如果我将服务器部署在具有以下配置的计算机上,我的服务器可以在内存不足之前可靠地处理多少请求,或者显示压力过大的迹象:

• 4核高端Intel Xeon CPU
• 8GB RAM
• RAID-1中的2个HDD(无SSD,无基于PCIe的固态存储)
• RedHat或Centos Linux(64位)
• Java 6(64位)
• MySQL 5.1/InnoDB

另外,我们假设MySQL数据库与Tomcat安装在同一台机器上,并且所有Wiki数据都存储在数据库中.此外,让我们假装Java应用程序构建在以下堆栈之上:

• SpringMVC为前端
• Hibernate/JPA用于持久化
• DI和安全等的春天

如果您没有使用确切的配置,但有评估类似架构的可扩展性的经验,我也会非常有兴趣听到这个.

提前致谢.

编辑:我想我没有正确地阐述我的问题.我用最多的投票标记答案作为最佳答案,我将在社区维基区重写我的问题.简而言之,我只想了解您在Java应用程序能够在一台物理服务器上处理的工作负载规模的经验,以及有关应用程序本身的类型和体系结构的一些描述.

我的应用程序遇到OutOfMemoryException问题。我的应用程序可以在文本中搜索单词。当我开始长时间运行的过程搜索以搜索大约2000个不同的文本以查找大约2175个不同的单词时，应用程序将以OutOfMemoryException终止（大约经过6个小时），终止于大约50％

我一直在尝试查找内存泄漏。我有一个像这样的对象图：（->是引用）

静态全局应用程序对象（控制器）->算法启动器对象->文本挖掘启动器对象->文本挖掘算法对象（此对象执行搜索）。

文本挖掘启动程序对象将在单独的线程中启动文本挖掘算法对象的run（）方法。

为了尝试解决该问题，我已经编辑了代码，以便文本挖掘入门对象将文本分成几组进行搜索，并依次为每组文本初始化一个文本挖掘算法对象（因此当一个文本挖掘算法对象完成时）将创建一个新的文本来搜索下一组文本）。在这里，我将先前的文本挖掘算法对象设置为null。但这不能解决问题。

当我创建一个新的文本挖掘算法对象时，我必须给它一些参数。这些取自之前的文本挖掘算法对象的属性，然后将该对象设置为null。这样是否可以防止垃圾收集文本挖掘算法对象？

这是文本挖掘算法启动器用于创建新文本挖掘算法对象的代码：

    private void RunSeveralAlgorithmObjects()
    {

        IEnumerable<ILexiconEntry> currentEntries = allLexiconEntries.GetGroup(intCurrentAlgorithmObject, intNumberOfAlgorithmObjectsToUse);

        algorithm.LexiconEntries = currentEntries;
        algorithm.Run();

        intCurrentAlgorithmObject++;

        for (int i = 0; i < intNumberOfAlgorithmObjectsToUse - 1; i++)
        {
            algorithm = CreateNewAlgorithmObject();
            AddAlgorithmListeners();
            algorithm.Run();
            intCurrentAlgorithmObject++;
        }

    }

    private TextMiningAlgorithm CreateNewAlgorithmObject()
    {
        TextMiningAlgorithm newAlg = new TextMiningAlgorithm();

        newAlg.SortedTermStruct = algorithm.SortedTermStruct;
        newAlg.PreprocessedSynonyms = algorithm.PreprocessedSynonyms;
        newAlg.DistanceMeasure = algorithm.DistanceMeasure;
        newAlg.HitComparerMethod = algorithm.HitComparerMethod;
        newAlg.LexiconEntries = allLexiconEntries.GetGroup(intCurrentAlgorithmObject, intNumberOfAlgorithmObjectsToUse);
        newAlg.MaxTermPercentageDeviation = algorithm.MaxTermPercentageDeviation;
        newAlg.MaxWordPercentageDeviation = algorithm.MaxWordPercentageDeviation;
        newAlg.MinWordsPercentageHit = algorithm.MinWordsPercentageHit;
        newAlg.NumberOfThreads = algorithm.NumberOfThreads;
        newAlg.PermutationType = …