小编Ili*_*llo的帖子

我试图了解这个简单的C++ 11程序输出中gcc与clang暴露的不同行为是否是由于clang中的错误(Xcode 5.0.2,OS X 10.8.5).代码如下:

#include <iostream>

int main() {


    int matrix[][3]{{1,2,3}, {4,5,6}, {7,8,9}};
    auto dyn_matrix = new int[3][3]{{1,2,3}, {4,5,6}, {7,8,9}};

    std::cout << matrix[0][1] << std::endl;
    std::cout << dyn_matrix[0][1] << std::endl;

    return 0;   
}

如图所示,我正在尝试使用统一初始化来初始化一个大小的匿名(resp.命名)多维数组3x3.使用MacPorts中的gcc 4.7进行编译时,可以获得预期的输出:

$g++-mp-4.7 -std=c++11 dyn_matrix.cpp -o dyn_matrix 
$ ./dyn_matrix
2
2
$

相反,在使用clang的情况下,输出读取:

$ clang++ -std=c++11 -stdlib=libc++ dyn_matrix.cpp -o dyn_matrix_clang
$ ./dyn_matrix_clang 
2
4
$  

在这种情况下,结果(显然)是错误的.clang --version报告:

Apple LLVM version 5.0 (clang-500.2.75) (based on LLVM 3.3svn)
Target: x86_64-apple-darwin12.5.0
Thread model: posix

谁应该受到责备？我,gcc还是clang？ …

在我目前的C++ 11项目中,我需要执行M模拟.对于每个模拟m = 1, ..., M,我使用一个std::mt19937对象随机生成一个数据集,构造如下:

std::mt19937 generator(m);
DatasetFactory dsf(generator);

根据/sf/answers/1085695971/和/sf/answers/1044704531/,Mersenne Twister PRNG受益于热身阶段,目前我的代码中没有.为方便起见,我提出了建议的代码片段:

#include <random>

std::mt19937 get_prng() {
    std::uint_least32_t seed_data[std::mt19937::state_size];
    std::random_device r;
    std::generate_n(seed_data, std::mt19937::state_size, std::ref(r));
    std::seed_seq q(std::begin(seed_data), std::end(seed_data));
    return std::mt19937{q};
}

在我的情况下的问题是我需要结果的可重复性,即在不同的执行中,对于每个模拟,数据集必须是相同的.这就是为什么在我目前的解决方案中,我使用当前的模拟种子Mersenne Twister PRNG.在我看来,使用std::random_device防止数据是相同的(AFAIK,这是确切的目的std::random_device).

编辑:通过不同的执行我的意思是重新启动可执行文件.

如何在不影响再现性的情况下在代码中引入上述预热阶段？谢谢.

可能的解决方案#1

这是基于@SteveJessop的第二个提案的暂定实现

#include <random>

std::mt19937 get_generator(unsigned int seed) {
        std::minstd_rand0 lc_generator(seed);
        std::uint_least32_t seed_data[std::mt19937::state_size];

        std::generate_n(seed_data, std::mt19937::state_size, std::ref(lc_generator));
        std::seed_seq q(std::begin(seed_data), std::end(seed_data));
        return std::mt19937{q};
    }

可能的解决方案#2

这是基于@SteveJassop和@AndréNeve联合贡献的暂定实施.该sha256功能改编自/sf/answers/744290781/

#include <openssl/sha.h>
#include …

我正在研究一个MATLAB项目,我想用C++和Eigen重新实现计算量最大的部分.我想知道是否有办法执行以下操作(MATLAB语法):

B = A(A < 3);

对于那些不熟悉MATLAB的人,上述命令初始化由A中单元格构成的矩阵B,其值小于3.

我从Eigen论坛的帖子中看到,可以通过以下方式获得感兴趣的指数:

MatrixXi indices = (A.array() < 3).cast<int>();

我想拥有的是:

MatrixXd B = A(A.array() < 3);

谢谢.

我正在使用Struts 1.3 + JPA(Hibernate作为持久性提供程序)开发一个简单的"Book Store"项目.我无法切换到Spring或任何其他更复杂的开发环境(例如,Jboss),我不能使用任何特定于Hibernate的技术(例如,Session类).

鉴于我在JSE环境中,我需要明确管理整个EntityManager的生命周期.

该Book实体定义如下:

@Entity
public class Book {

@Id private String isbn;
private String title;
private Date publishDate;

    // Getters and Setters
}

我定义了三个Action类,分别负责检索所有书籍实例,通过其ISBN检索单个书籍实例并将分离的书籍合并到数据库中.

为了增加业务逻辑代码和数据访问代码之间的关注点分离,我引入了一个简单的BookDAO对象,负责执行CRUD操作.理想情况下,应将所有与数据访问相关的调用委托给持久层.例如,ListBookAction定义如下:

public class ListBookAction extends Action {

    private BookDAO dao = new BookDAO();

    @Override
    public ActionForward execute(ActionMapping mapping, ActionForm form,
            HttpServletRequest request, HttpServletResponse response)
            throws Exception {

        // Retrieve all the books
        List<Book> books = dao.findAll();

        // Save the result set
        request.setAttribute("books", …

让我们假设std::tuple<some_types...>给出了一个.我想创建一个新std::tuple的类型是索引的类型[0, sizeof...(some_types) - 2].例如,让我们假设起始元组是std::tuple<int, double, bool>.我想获得一个定义为的子元组std::tuple<int, double>.

我对可变参数模板很新.作为第一步,我试着写一个struct负责存储不同类型的原始文件std::tuple,目的是创建一个同类的新元组(如std::tuple<decltype(old_tuple)> new_tuple).

template<typename... types>
struct type_list;

template<typename T, typename... types>
struct type_list<T, types...> : public type_list<types...>  {
    typedef T type;
};


template<typename T>
struct type_list<T> {
    typedef T type;
};

我想做的是:

std::tuple<type_list<bool, double, int>::type...> new_tuple // this won't work

下一步是丢弃参数包中的最后一个元素.如何访问type存储的几个type_list？以及如何丢弃其中一些？

谢谢.

我是编程入门课程的助教,我们教C++ 11.特别是,我的部分是关于内存管理的基础知识(值与参考语义,存储持续时间,自动与动态对象等).

可以预见的是,学生们发现这部分非常相似(对于绝大多数人来说,这是他们第一次听到这些内容).他们必须面对的主要问题之一是学习如何区分&符号的不同含义(定义左值引用与获取左值的地址).为此,由于我们使用的是C++ 11,我想知道是否有意义来呈现该std::addressof功能.

这可以帮助消除任何歧义.以下片段:

int b = 10;
int* a = &b;
int& c = b;

可能成为:

int* a = std::addressof(b);
int& c = b;

并且&它将恰好与一个含义相关联:定义左值引用.从一方面来看似乎是合理的,因为:

• 重点不在于培训C++程序员(更高级的课程切换到Java),以及
• 我仍然可以提供运算符的地址std::addressof.

我看到的缺点是教一些不是惯用的东西.鉴于列表中的第一颗子弹,这可能没问题.然而,我最担心的是我目前无法预见的技术缺点(例如,运行时成本).