小编R. *_*des的帖子

如果我通过我的GCC 4.7快照传递以下代码,它会尝试将unique_ptrs 复制到向量中.

#include <vector>
#include <memory>

int main() {
    using move_only = std::unique_ptr<int>;
    std::vector<move_only> v { move_only(), move_only(), move_only() };
}

显然,因为std::unique_ptr不可复制而无法工作:

错误:使用已删除的函数'std :: unique_ptr <_Tp,_Dp> :: unique_ptr(const std :: unique_ptr <_Tp,_Dp>&)[with _Tp = int; _Dp = std :: default_delete; std :: unique_ptr <_Tp,_Dp> = std :: unique_ptr]'

GCC是否正确尝试从初始化列表中复制指针？

灵感来自http://xkcd.com/710/这里是一个高尔夫代码.

挑战

给定大于0的正整数,打印出该数字的冰雹序列.

冰雹序列

有关更多详细信息,请参阅Wikipedia

• 如果数字是偶数,则除以2.
• 如果数字是奇数,则将其加倍并添加一个.

用生成的数字重复此操作,直到达到1.(如果在1之后继续,它将进入无限循环1 -> 4 -> 2 -> 1...)

有时代码是最好的解释方式,所以这里有一些来自维基百科

function collatz(n)
  show n
  if n > 1
    if n is odd
      call collatz(3n + 1)
    else
      call collatz(n / 2)

这段代码有效,但我正在增加额外的挑战.程序不能容易受到堆栈溢出的影响.所以它必须使用迭代或尾递归.

此外,如果它可以计算大数字并且语言尚未实现,则奖励积分.(或者如果使用固定长度的整数重新实现大数字支持)

测试用例

Number: 21
Results: 21 -> 64 -> 32 -> 16 -> 8 -> 4 -> 2 -> 1

Number: 3
Results: 3 -> 10 -> 5 -> 16 -> 8 -> 4 -> 2 …

std::array远远优于C阵列.即使我想与遗留代码进行互操作,我也可以使用std::array::data().有什么理由我想要一个老派阵列吗？

如果我声明一个包装在共享指针中的对象:

std::shared_ptr<myClass> myClassObject(new myClass());

然后我想将它作为参数传递给方法:

DoSomething(myClassObject);

//the called method
void DoSomething(std::shared_ptr<myClass> arg1)
{
   arg1->someField = 4;
}

以上只是增加了shared_pt的引用计数,一切都很酷吗？还是留下一个悬垂的指针？

你还是应该这样做吗？:

DoSomething(myClassObject.Get());

void DoSomething(std::shared_ptr<myClass>* arg1)
{
   (*arg1)->someField = 4;
}

我认为第二种方式可能更有效,因为它只需要复制1个地址(而不是整个智能指针),但第一种方式似乎更具可读性,我不期望推动性能限制.我只是想确保没有危险的东西.

谢谢.

所以,我有这个代码:

constexpr unsigned N = 1000;
void f1(char* sum, char* a, char* b) {
    for(int i = 0; i < N; ++i) {
        sum[i] = a[i] + b[i];
    }
}

void f2(char* sum, char* a, char* b) {
    char* end = sum + N;
    while(sum != end) {
        *sum++ = *a++ + *b++;
    }
}

我想看看GCC 4.7.2会产生的代码.所以我跑了g++ -march=native -O3 -masm=intel -S a.c++ -std=c++11并获得了以下输出:

        .file   "a.c++"
        .intel_syntax noprefix
        .text
        .p2align 4,,15
        .globl  _Z2f1PcS_S_
        .type   _Z2f1PcS_S_, @function
_Z2f1PcS_S_:
.LFB0:
        .cfi_startproc …

在Effective C++第03项中,尽可能使用const.

class Bigint
{
  int _data[MAXLEN];
  //...
public:
  int& operator[](const int index) { return _data[index]; }
  const int operator[](const int index) const { return _data[index]; }
  //...
};

const int operator[]确实有所作为int& operator[].

但是关于:

int foo() { }

和

const int foo() { }

似乎他们是一样的.

我的问题是,为什么我们用const int operator[](const int index) const而不是int operator[](const int index) const？

我偶然每天得到以下10X次.

进入Ex模式.输入"visual"进入正常模式.

如何在Vim中禁用导致它的组合？

[expr.new]C++的5.3.4 2月草案给出了一个例子:

new(2,f) T[5]导致打电话operator new[](sizeof(T)*5+y,2,f).

这里,x和y是非负的未指定值,表示数组分配开销; new-expression的结果将从返回的值中抵消此数量operator new[].这种开销可以应用于所有数组新表达式,包括那些引用库函数operator new[](std::size_t, void*)和其他放置分配函数的表达式.开销的数量可能因新的一次调用而异.- 末端的例子 ]

现在来看以下示例代码:

void* buffer = malloc(sizeof(std::string) * 10);
std::string* p = ::new (buffer) std::string[10];

根据上面的引用,第二行将new (buffer) std::string[10]在内部调用operator new[](sizeof(std::string) * 10 + y, buffer)(在构造单个std::string对象之前).问题是如果y > 0,预分配的缓冲区太小了!

那么我如何知道在使用数组放置时预先分配多少内存？

void* buffer = malloc(sizeof(std::string) * 10 + how_much_additional_space);
std::string* p = ::new (buffer) std::string[10];

或者标准某处是否保证y == 0在这种情况下？报价再次说:

这种开销可以应用于所有数组新表达式,包括那些引用库函数operator …

该std::unique_ptr模板有两个参数:指针对象的类型和删除器的类型.第二个参数有一个默认值,所以你通常只写一些像std::unique_ptr<int>.

该std::shared_ptr模板有虽然只有一个参数:指针对象的类型.但是你也可以使用自定义删除器,即使删除类型不在类模板中.通常的实现使用类型擦除技术来执行此操作.

有没有理由不使用相同的想法std::unique_ptr？

如果我有一个C++ 11程序运行两个线程,其中一个抛出一个未处理的异常,会发生什么？整个程序会死于火热的死亡吗？抛出异常的线程是否会单独死亡(如果是这样,我可以在这种情况下获得异常)吗？还有别的吗？