由于C ++ 11文档不足，我遇到了一个小问题。

我想获取一个自纪元以来的时间，以毫秒，纳秒或秒为单位，然后我必须将该值“强制转换”为另一个分辨率。我可以使用gettimeofday（）做到这一点，但这很容易，所以我尝试使用std :: chrono实现它。

我试过了：

std::chrono::time_point<std::chrono::system_clock> now = 
    std::chrono::system_clock::now();

但是我不知道以这种方式获得的分辨率time_point是什么，而且我不知道如何将这个时间作为一个简单的unsigned long long来获取，而且我也没有任何想法如何将其转换为另一个分辨率。

我具有带有此签名的第三方功能：

std::vector<T> f(T t);

我也有一个现有的潜在无限范围（范围-v3类）T，名称为src。我想创建一个管道，将f映射到该范围的所有元素，并将所有向量及其所有元素展平为一个范围。

本能地，我将写以下内容。

 auto rng = src | view::transform(f) | view::join;

但是，这将不起作用，因为我们无法创建临时容器的视图。

range-v3如何支持这样的范围管道？

忽略编程风格和设计，在堆栈上分配的变量上调用delete是“安全”的吗？

例如：

   int nAmount;
   delete &nAmount;

要么

class sample
{
public:
    sample();
    ~sample() { delete &nAmount;}
    int nAmount;
}

我有一串数字，例如 “ 123456789”，我需要提取它们中的每一个以在计算中使用它们。 我当然可以按索引访问每个char，但是如何将其转换为int？

我已经研究过atoi（），但是它需要一个字符串作为参数。 因此，我必须将每个字符转换为字符串，然后在其上调用atoi。 有没有更好的办法？

根据C ++ 0x最终草案，无法请求终止线程。 也就是说，如果需要，我们需要实施自己动手的解决方案。

另一方面，boost :: thread提供了一种以安全方式中断线程的机制。

您认为最好的解决方案是什么？ 设计自己的协作“中断机制”还是本地化？

在C ++中，要打印十六进制数字，请执行以下操作：

int num = 10;
std::cout << std::hex << num; // => 'a'

我知道我可以创建一个仅向流中添加内容的操纵器，如下所示：

std::ostream& windows_feed(std::ostream& out)
{
    out << "\r\n";
    return out;
}

std::cout << "Hello" << windows_feed; // => "Hello\r\n"

但是，如何创建一个类似于“ hex”的操纵器来修改要出现在流中的项目？ 作为一个简单的示例，我将如何在此处创建plusone机械手？：

int num2 = 1;
std::cout << "1 + 1 = " << plusone << num2; // => "1 + 1 = 2"

// note that the value stored in num2 does not change, just its display above.
std::cout << num2; // => "1"

我已经测试了两种书写配置：

1）Fstream缓冲：

// Initialization
const unsigned int length = 8192;
char buffer[length];
std::ofstream stream;
stream.rdbuf()->pubsetbuf(buffer, length);
stream.open("test.dat", std::ios::binary | std::ios::trunc)

// To write I use :
stream.write(reinterpret_cast<char*>(&x), sizeof(x));

2）手动缓冲：

// Initialization
const unsigned int length = 8192;
char buffer[length];
std::ofstream stream("test.dat", std::ios::binary | std::ios::trunc);

// Then I put manually the data in the buffer

// To write I use :
stream.write(buffer, length);

我希望得到同样的结果...

但是我的手动缓冲将性能提高了10倍，从而可以写入100MB的文件，与正常情况相比，fstream缓冲没有任何变化（无需重新定义缓冲区）。

有人对此情况有解释吗？

编辑：这是新闻：刚刚在超级计算机上完成的基准测试（Linux 64位体系结构，使用了Intel Xeon 8核，Lustre文件系统以及...配置良好的编译器）（并且我不解释1kB手动缓冲器“共振”的原因...）

编辑2：和在1024 B处的共振（如果有人对此有想法，我很感兴趣）：

我在Linux中使用pthread。 我想通过设置参数sched_param.priority来增加线程优先级。但是，我从网上找不到有关我可以设置的线程优先级范围或线程优先级描述的更多信息。

另外，我想了解相对线程优先级，因为我不想将线程优先级设置得太高而导致操作系统停止。 有人可以帮我吗？

Qt5有一个新的JSon解析器，我想使用它。 问题在于，对于函数在外行方面的作用以及如何编写代码尚不清楚。 那或者我可能读错了。

我想知道在Qt5中创建Json文件的代码以及“封装”的含义。

我是.NET开发人员，之前曾与VB6合作。 我对那些环境非常熟悉，并且在垃圾收集语言的上下文中工作。 但是，我现在希望使用本机C ++增强我的技能，并发现自己有点不知所措。 具有讽刺意味的是，这不是我想象的对于初学者来说通常的绊脚石，因为我觉得我已经很好地掌握了指针和内存管理。 对我来说有点令人困惑的是：

• 引用/使用其他库
• 公开我的库供他人使用
• 字符串处理
• 数据类型转换
• 良好的项目结构
• 要使用的数据结构（即，在C＃中，我经常使用List<T>，在类似工作的C ++中，我要使用什么？）

几乎感觉就像是根据所使用的IDE的不同，准则也有所不同，所以我确实在寻找更通用的东西。 或者最糟糕的是，专注于使用Microsoft的编译器/ IDE。 另外，为了清楚起见，我不需要任何有关常规编程实践（设计模式，代码完成等）的信息，因为我对这些主题非常精通。

例如，stdlibc ++具有以下内容：

unique_lock& operator=(unique_lock&& __u)
{
    if(_M_owns)
        unlock();
    unique_lock(std::move(__u)).swap(*this);
    __u._M_device = 0;
    __u._M_owns = false;
    return *this;
}

为什么不直接将两个__u成员直接分配给* this呢？ 交换并不意味着__u被分配了* this成员，只是后来分配了0和false ...在这种情况下，交换正在进行不必要的工作。 我想念什么？（unique_lock :: swap仅对每个成员执行std :: swap）

我想知道自从我在很多地方都遇到过这些术语后，是否有人可以在那里解释这些术语。 我了解一些有关它们的基本理论，但不确定我所知道的是对还是错。

那么任何人都可以解释这些术语吗？

使用GCC 6.3，以下C ++代码：

#include <cmath>
#include <iostream>

void norm(double r, double i)
{
    double n = std::sqrt(r * r + i * i);
    std::cout << "norm = " << n;
}

生成以下x86-64程序集：

norm(double, double):
        mulsd   %xmm1, %xmm1
        subq    $24, %rsp
        mulsd   %xmm0, %xmm0
        addsd   %xmm1, %xmm0
        pxor    %xmm1, %xmm1
        ucomisd %xmm0, %xmm1
        sqrtsd  %xmm0, %xmm2
        movsd   %xmm2, 8(%rsp)
        jbe     .L2
        call    sqrt
.L2:
        movl    std::cout, %edi
        movl    $7, %edx
        movl    $.LC1, %esi
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        movsd   8(%rsp), %xmm0
        movl    std::cout, %edi
        addq    $24, %rsp
        jmp     std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)

对于对xmm0的调用，GCC首先使用sqrt进行处理并将结果保存到堆栈中。 如果溢出，则调用libc sqrt函数。 但是在此之后和第二次调用operator<<之前，它永远不会保存xmm0，它会从堆栈中恢复值（因为xmm0在第一次调用operator<<时丢失了）。

使用更简单的xmm0，就更加明显了：

subq    $24, %rsp
movsd   %xmm1, 8(%rsp)
call    sqrt
movsd   8(%rsp), %xmm1
movl    std::cout, %edi
addq    $24, %rsp
movapd  %xmm1, %xmm0
jmp     std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)

为什么GCC不使用libc sqrt计算的xmm0值？

或者，“俄罗斯人如何抛出异常？”

std :: exception的定义是：

namespace std {
  class exception {
  public:
    exception() throw();
    exception(const exception&) throw();
    exception& operator=(const exception&) throw();
    virtual ~exception() throw();
    virtual const char* what() const throw();
  };
}

一种流行的设计异常层次结构的思想是从std :: exception派生的：

通常，最好扔东西，   不是内置的。 如果可能的话，你应该   抛出派生类的实例   （最终）来自std :: exception   类。 通过设置异常类   从标准继承（最终）   异常基类，您正在   为您的用户带来更轻松的生活（他们拥有   通过以下方式捕获大多数事物的选项   std :: exception），再加上您可能   向他们提供更多信息   （例如，您的特定   例外可能是对   std :: runtime_error或其他）。std:: runtime_error或其他）。

但是面对Unicode，似乎不可能设计一个实现以下两个方面的异常层次结构：

• 最终源自std :: exception，以便在捕获站点上易于使用
• 提供Unicode兼容性，因此诊断不会被切片或乱码

提出一个可以用Unicode字符串构造的异常类非常简单。 但是该标准规定what（）必须返回const char *，因此在某些时候必须将输入字符串转换为ASCII。 无论是在构造时完成操作，还是在调用what（）时完成（如果源字符串使用无法由7位ASCII表示的字符），则在不损失保真度的情况下格式化消息都可能是不可能的。

如何设计将std :: exception派生类的无缝集成与无损Unicode诊断结合在一起的异常层次结构？

通常，在我的内部循环中，我需要以“环绕”方式为数组建立索引，这样，如果数组大小为100，并且我的代码要求输入元素-2，则应为其指定元素98。在许多高级语言中，例如 与Python一样，您可以使用index轻松地做到这一点，但是由于某种原因，C的整数算术（通常）会四舍五入而不是始终四舍五入，因此，当给定第一个负数时，其模运算符将返回负数。

通常，我知道index不会小于-array_size，在这种情况下，我只做my_array[(index + array_size) % array_size]。但是，有时无法保证，对于这些情况，我想知道实现始终为正的模的最快方法 功能。 有几种“智能”方式可以做到而无需分支，例如

inline int positive_modulo(int i, int n) {
    return (n + (i % n)) % n
}

要么

inline int positive_modulo(int i, int n) {
    return (i % n) + (n * (i < 0))
}

当然，我可以对它们进行概要分析，以找出哪个是系统上最快的，但我不禁担心自己可能错过了更好的系统，或者在另一台计算机上计算机运行的速度可能较慢。

那么，有没有一种标准的方法来执行此操作，或者我错过了一些巧妙的技巧，而这可能是最快的方法？

另外，我知道这可能是一厢情愿的想法，但是如果有一种方法可以自动矢量化，那就太了不起了。

我喜欢C ++ 11中的auto x{i}。 太好了 但是它确实有一种不协调感，因为我一直都在不停地跳下去：

int i = 3;       // i is an int with value 3
int i = int{3};  // i is an int with value 3
int i(3);        // i is an int with value 3 (possibly narrowing, not in this case)
int i{3};        // i is an int with value 3

auto i = 3;      // i is an int with value 3
auto i = int{3}; // i is an int with value 3
auto i(3);       // i is an int with value 3
auto i{3};       // wtf, i is a std::initializer_list<int>?!

这种奇怪的行为使新手感到困惑，也使经验丰富的用户感到烦恼-C ++几乎没有什么不一致性和极端情况，因此必须牢记。 谁能解释为什么标准委员会决定在这种情况下引入一个新的标准？

如果声明一个类型为auto x{i}的变量是有用的或经常执行的，则我可以理解，但是以我的经验，这几乎从来不是故意的-在极少数情况下，您确实想这样做

std::initializer_list<int> l{3};
auto l = std::initializer_list<int>{3};
auto l = {3}; // No need to specify the type

会很好。 那么auto x{i}特殊情况背后的原因是什么？

如果我像这样在标题中定义常量变量...

extern const double PI = 3.1415926535;
extern const double PI_under_180 = 180.0f / PI;
extern const double PI_over_180 = PI/180.0f;

我收到以下错误

1>MyDirectX.obj : error LNK2005: "double const PI" (?PI@@3NB) already defined in main.obj
1>MyDirectX.obj : error LNK2005: "double const PI_under_180" (?PI_under_180@@3NB) already defined in main.obj
1>MyDirectX.obj : error LNK2005: "double const PI_over_180" (?PI_over_180@@3NB) already defined in main.obj
1>MyGame.obj : error LNK2005: "double const PI" (?PI@@3NB) already defined in main.obj
1>MyGame.obj : error LNK2005: "double const PI_under_180" (?PI_under_180@@3NB) already defined in main.obj
1>MyGame.obj : error LNK2005: "double const PI_over_180" (?PI_over_180@@3NB) already defined in main.obj

但是如果我从标头中删除这些常量，然后将其放入包含标头的文档中，如下所示...

const double PI = 3.1415926535;
const double PI_under_180 = 180.0f / PI;
const double PI_over_180 = PI/180.0f;

有用

有谁知道我可能做错了什么？

谢谢

我在Ubuntu 12.04中编译并安装了openCV 2.4.2。 在/DisplayImage code.png下，我可以看到目录/usr/local/opencv和/usr/local/opencv2。

这是我写的代码：

#include <cv.h>
#include <highgui.h>
#include <iostream>
using namespace cv;
using namespace std;
int main(int argc,char **argv)
{
   Mat image;
   image = imread(argv[1],1);

   if(argc != 2 || !image.data)
   {
       cout << "No image data\n";
       return -1;
   }

   namedWindow("Display Image",CV_WINDOW_AUTOSIZE);
   imshow("Display Image",image);
   waitKey(0);
   return 0;
}

我使用以下命令行对其进行了编译：

g++ DisplayImage.cpp -o DisplayImage `pkg-config opencv --cflags --libs` 

没有编译时错误，但是当我尝试使用/DisplayImage code.png运行生成的二进制文件时，出现以下错误消息：

./DisplayImage: error while loading shared libraries: libopencv_core.so.2.4: cannot open shared object file: No such file or directory

有区别还是一样？

在C ++中，我需要迭代一定次数，但不需要迭代变量。 例如：

for( int x=0; x<10; ++x ) {
    /* code goes here, i do not reference "x" in this code */
}

我意识到我可以通过用lambda或命名函数代替“代码在这里”来做到这一点，但是这个问题专门针对for循环。

我希望C ++ 11基于范围的for循环会有所帮助：

for( auto x : boost::irange(0,10) ) {
    /* code goes here, i do not reference "x" in this code */
}

但是上面给出了“未引用的局部变量”，因为我从未明确引用x。

我想知道是否有一种更优雅的方法来编写上述for循环，以使代码不会生成“未引用的局部变量”警告。