标签: c++11

std::shared_ptr<Object> p1 = std::make_shared<Object>("foo");
std::shared_ptr<Object> p2(new Object("foo"));

许多google和stackoverflow帖子就在这里,但我无法理解为什么make_shared比直接使用更有效shared_ptr.

有人可以一步一步解释我创建的对象序列和两者所做的操作,这样我就能理解make_shared效率如何.我在上面给出了一个例子供参考.

我正在尝试存储std::tuple不同数量的值,这些值稍后将用作调用与存储类型匹配的函数指针的参数.

我创建了一个简化的示例,显示了我正在努力解决的问题:

#include <iostream>
#include <tuple>

void f(int a, double b, void* c) {
  std::cout << a << ":" << b << ":" << c << std::endl;
}

template <typename ...Args>
struct save_it_for_later {
  std::tuple<Args...> params;
  void (*func)(Args...);

  void delayed_dispatch() {
     // How can I "unpack" params to call func?
     func(std::get<0>(params), std::get<1>(params), std::get<2>(params));
     // But I *really* don't want to write 20 versions of dispatch so I'd rather 
     // write something like:
     func(params...); // Not legal
  }
}; …

简短的例子:

#include <iostream>

int main()
{
    int n;
    [&](){n = 10;}();             // OK
    [=]() mutable {n = 20;}();    // OK
    // [=](){n = 10;}();          // Error: a by-value capture cannot be modified in a non-mutable lambda
    std::cout << n << "\n";       // "10"
}

问题:为什么我们需要mutable关键字？它与传统参数传递给命名函数有很大不同.背后的理由是什么？

我的印象是,按值捕获的整个点是允许用户更改临时值 - 否则我几乎总是更好地使用按引用捕获,不是吗？

有什么启示吗？

(顺便说一句,我使用的是MSVC2010.这应该是标准的AFAIK)

我开始研究C++ 11的智能指针,我没有看到任何有用的用法std::weak_ptr.有人能告诉我什么时候std::weak_ptr有用/必要吗？

我正在制作一个小词汇记忆程序,其中的单词将随机闪现在我的意思中.我想使用标准的C++库,就像Bjarne Stroustroup告诉我们的那样,但我遇到了一个看似奇怪的问题.

我想将long整数更改std::string为能够将其存储在文件中.我也受雇于to_string()此.问题是,当我使用g ++(版本4.7.0,如其--version标志中所述)编译它时,它说:

PS C:\Users\Anurag\SkyDrive\College\Programs> g++ -std=c++0x ttd.cpp
ttd.cpp: In function 'int main()':
ttd.cpp:11:2: error: 'to_string' is not a member of 'std'

我的程序给出了这个错误:

#include <string>

int main()
{
    std::to_string(0);
    return 0;
}

但是,我知道它不可能是因为msdn库清楚地说它存在并且早先关于Stack Overflow的问题(对于g ++版本4.5)说它可以用-std=c++0x旗标打开.我究竟做错了什么？

我在头文件中有一些代码如下:

#include <memory>

class Thing;

class MyClass
{
    std::unique_ptr< Thing > my_thing;
};

如果我有一个CPP这个头不包含的Thing类型定义,那么这并不在VS2010 SP1的编译:

1> C:\ Program Files(x86)\ Microsoft Visual Studio 10.0\VC\include\memory(2067):错误C2027:使用未定义类型'Thing'

替换std::unique_ptr为std::shared_ptr和编译.

所以,我猜这是当前VS2010 std::unique_ptr的实现,需要完整的定义,而且完全依赖于实现.

或者是吗？它的标准要求中是否有某些东西使得std::unique_ptr实施只能使用前向声明？感觉很奇怪,因为它应该只有一个指针Thing,不应该吗？

当我启用C++ 11时,我在一个小的C++片段中发现了一个有趣的性能回归:

#include <vector>

struct Item
{
  int a;
  int b;
};

int main()
{
  const std::size_t num_items = 10000000;
  std::vector<Item> container;
  container.reserve(num_items);
  for (std::size_t i = 0; i < num_items; ++i) {
    container.push_back(Item());
  }
  return 0;
}

使用g ++(GCC)4.8.2 20131219(预发行版)和C++ 03,我得到:

milian:/tmp$ g++ -O3 main.cpp && perf stat -r 10 ./a.out

Performance counter stats for './a.out' (10 runs):

        35.206824 task-clock                #    0.988 CPUs utilized            ( +-  1.23% )
                4 context-switches          #    0.116 K/sec                    ( +-  4.38% )
                0 cpu-migrations …

可能重复:
#include <filename>和#include"filename"有什么区别？

在C++中包含头文件时,尖括号< >和双引号有什么区别" "？

我的意思是应该使用例如包含#include <QPushButton>哪些文件:以及使用例如包括哪些文件:#include "MyFile.h"???

像许多人一样,我一直在尝试C + 11带来的不同功能.我最喜欢的一个是"基于范围的循环".

我明白那个:

for(Type& v : a) { ... }

相当于:

for(auto iv = begin(a); iv != end(a); ++iv)
{
  Type& v = *iv;
  ...
}

而这begin()只是返回a.begin()标准容器.

但是,如果我想让我的自定义类型"基于范围的循环" - 意识到什么？

如果我只是专注begin()和end()？

如果我的自定义类型属于命名空间xml,我应该定义xml::begin()还是std::begin()？

简而言之,这样做的准则是什么？

在clang的C++ 11状态页面中遇到了一个名为"rvalue reference for*this"的提案.

我已经阅读了很多关于rvalue引用并理解它们的内容,但我认为我不知道这一点.我也无法使用这些条款在网上找到太多资源.

页面上的提案文件有一个链接:N2439(将移动语义扩展到*this),但我也没有从中获得太多的例子.

这个功能是什么？