小编Beg*_*ner的帖子

有谁能请给我一个简短的Java容器列表？我所知道的一些是Array,Arraylist,Hashtable,HashMap,HashSet,Node,NodeList,TreeNode和TreeMap.

我正在处理的应用程序目前有大量的结构,其中包含从各种来源(如数据库和文件)输入的数据.例如这样:

struct A 
{
    float val1;
    std::string val2;
    int val3;

    bool operator < (const A& other) const;
};

对于处理,这些结构存储在STL容器中,例如地图,因此需要比较运算符.这些都是一样的,使用简单的布尔逻辑,它们可以像这样写:

bool A:operator < (const A& o) const {
    return val1 < o.val1 || 
        (val1 == o.val1 && ( val2 < o.val2 || 
            (val2 == o.val2 && ( val3 < o.val3 ) ) );
}

这似乎很有效,但有几个缺点:

1. 如果结构为十几个或更多成员,这些表达式会变得很大.
2. 如果成员改变,编写和维护是很麻烦的.
3. 需要分别对每个结构进行操作.

是否有更可维护的方法来比较像这样的结构？

我需要在离线机器上工作,我无法访问我的存储库.现在我也不想错过完全使用Git.

问题:

• 通过记忆棒将我的存储库复制到离线机器的最佳方法是什么？
• 有没有办法通过文件系统复制补丁？

编辑:我应该说,我将不得不将记忆棒交给管理员,管理员将为我复制,即我不能用我的用户安装棒.

我有一个try catch子句,其中最外层catch(...)从未发生过.经过一些更改后,某个地方会抛出一个我无法处理其他情况的异常.有没有办法获得至少一些关于异常的信息,即使我抓住了它(...)？

catch (const cone::BeginnersLibException& ex) 
{
    // handle the exception
}
catch (const std::exception& ex) 
{
    // handle std exception
} 
catch (...) 
{
    log("Unknown exception caught.");
    // How can I get more information about this exception?
}

编辑:这里有一个适合我的代码片段:

#include <cxxabi.h>

// more code here 
} catch (...) {
    std::string exName(abi::__cxa_current_exception_type()->name());
    std::cout<<"unknown exception: "<< exName <<std::endl;
    throw;
}

在这个关于C++和Java之间性能差异的问题的高度评价的答案中,我了解到JIT编译器有时能够更好地进行优化,因为它可以确定机器的确切细节(处理器,缓存大小等):

通常,C#和Java可以同样快或者更快,因为JIT编译器 - 在第一次执行时编译IL的编译器 - 可以优化C++编译的程序,因为它可以查询机器.它可以确定机器是Intel还是AMD; Pentium 4,Core Solo或Core Duo; 或者如果支持SSE4等

C++程序必须事先通过混合优化进行编译,以便它在所有机器上运行得相当好,但是没有像单个配置(即处理器,指令集,其他硬件)那样进行优化.

问题:有没有办法告诉编译器专门针对我当前的机器进行优化？有没有能够做到这一点的编译器？

我发现这篇关于加快不同查询的帖子:

使用递归CTE的超快速DISTINCT:

USE     tempdb;
GO
DROP    TABLE dbo.Test;
GO
CREATE  TABLE 
        dbo.Test 
        (
        data            INTEGER NOT NULL,
        );
GO
CREATE  CLUSTERED INDEX c ON dbo.Test (data);
GO
-- Lots of duplicated values
INSERT  dbo.Test WITH (TABLOCK)
        (data)
SELECT  TOP (5000000)
        ROW_NUMBER() OVER (ORDER BY (SELECT 0)) / 117329
FROM    master.sys.columns C1,
        master.sys.columns C2,
        master.sys.columns C3;
GO



SET     STATISTICS TIME ON;

-- 1591ms CPU
SELECT  DISTINCT 
        data
FROM    dbo.Test;

- 15ms CPU

WITH    RecursiveCTE
AS      (
        SELECT …

我试图了解jQuery如何设置自己.

在开始时,jQuery会自动调用一个导出模块的函数.

设置如何工作？

这里有一些更详细的子问题可能会回答更一般的问题:

• 什么是使用递归调用的function(w)在module.exports？
• noGlobal变量有什么用？
• factory实际设置在哪里,它的类型是什么？
• 为什么factory参数可以用一个参数和两个参数调用？
• 什么是global应该包含的论点？(我希望有类似c ++的类型...)

(function( global, factory ) {

    if ( typeof module === "object" && typeof module.exports === "object" ) {
        // For CommonJS and CommonJS-like environments where a proper `window`
        // is present, execute the factory and get jQuery.
        // For environments that do not have a `window` with a `document`
        // (such as Node.js), expose a factory as module.exports.
        // This …

C++参考提到了一个名为fancy pointers的概念.我从最近投票严重,后来删除的问题中了解到了他们的存在.

这个定义模糊不清:

当成员类型指针不是原始指针类型时,它通常被称为"花式指针".

他们的用例示例如下:

花式指针的一个示例是与映射地址无关的指针boost :: interprocess :: offset_ptr,这使得可以在共享内存中分配基于节点的数据结构,例如std :: set,以及映射在不同地址中的内存映射文件.每个过程.通过类模板std :: pointer_traits,可以独立于提供它们的分配器使用花式指针.

我不明白这个解释.创建花式指针的语法是什么？为什么我不能在这种情况下使用常规指针？

我的工作,它使用应一个结构库不具有由LIB的用户访问默认的构造函数.

struct Example
{
    Example(int x);

  private:
    Example();
};

在库内部,std :: map需要默认构造函数来创建新条目.库在实际上将值放在使用默认构造函数的任何地方都非常小心.

该库使用映射来存储这些结构,如下所示:

std::map<int, Example> data;

在这里查看ideOne中的完整示例.

我想阻止lib的用户能够使用默认构造函数.我如何与std :: map,std :: pair和/或std :: tuple建立联系以允许std :: map使用这个默认构造函数？

friend class std::map<int, Example>;
friend class std::pair<int, Example>;

不工作,我不知道如何与下面的抱怨beeing无法访问默认构造函数的构造函数交朋友:

// TEMPLATE CONSTRUCTOR pair::pair(tuple, tuple, sequence, sequence)
template<class _Ty1,
class _Ty2>
template<class _Tuple1,
    class _Tuple2,
    size_t... _Indexes1,
    size_t... _Indexes2> inline
    pair<_Ty1, _Ty2>::pair(_Tuple1& _Val1,
        _Tuple2& _Val2,
        integer_sequence<size_t, _Indexes1...>,
        integer_sequence<size_t, _Indexes2...>)
    : first(_STD get<_Indexes1>(_STD move(_Val1))...),
        second(_STD get<_Indexes2>(_STD move(_Val2))...)
    {   // construct …

我有一个带有特化的模板类,在另一个文件中定义.因此,可以生成同一类的两个版本:一次通过替换模板参数,一次使用专门化.我目前的理解是,这可能导致同一类型的两个实例在内存中具有不同的大小,从而导致分段错误.

我创建了一个最小的示例,以下代码用于说明问题:

创建模板类:

// - templateexample.h ---------------
#ifndef TEMPLATEEXAMPLE_H
#define TEMPLATEEXAMPLE_H
template<typename T> class Example
{
    public:
        Example(){}
        int doWork() {return 42;}
};
#endif
// -----------------------------------

另一个文件中的模板特化:

// - templatespecialization.h --------
#ifndef TEMPLATESPECIALIZATION_H
#define TEMPLATESPECIALIZATION_H    
#include "templateexample.h"
template<> class Example<int>
{
    public:
        Example() : a(0), b(1), c(2), d(3) {} 
        int doWork() {return a+b+c+d;}

    private:
        int a; //<== the specialized object will be larger in memory
        int b;
        int c;
        int d;
};
#endif
// --------------------------------

有一个只包含模板类定义的类,但应该包含特化.

// - …