小编Hum*_*awi的帖子

我有一个声明如下的抽象类:

class my_type {
public:
    virtual ~my_type() = default;
    virtual void do_something() = 0;
};

使用default关键字声明这样的析构函数是一种良好的做法吗？有没有更好的办法？

另外,是= 0一种现代(C++ 11)指定无默认实现的方式,还是有更好的方法？

std::begin并std::end知道一个container或一个的开始和结束array.

它很容易知道end和begin的vector为例子,因为它是一个类,给出了这样的信息.但是,它如何知道如下结束array呢？

int simple_array[5]{1, 2, 3, 4, 5};
auto beg=std::begin(simple_array);
auto en=std::end(simple_array);

std::begin并不难知道数组的起始位置.但它如何知道它的结束？将常数整数5存储在某处吗？

如果我得到一些低级信息的答案,我将不胜感激.

我知道Java或C#似乎太多了.但是,将我自己的类作为函数的输入有效是否可行/好/明智std::to_string？例:

class my_class{
public:
std::string give_me_a_string_of_you() const{
    return "I am " + std::to_string(i);
}
int i;
};

void main(){
    my_class my_object;
    std::cout<< std::to_string(my_object);
}

如果没有这样的东西(我认为那样),最好的办法是什么？

为什么这段代码无效？

  auto foo=[](){
    return {1,2};     
  };

但是,这是有效的,因为initializer list它仅用于初始化vectornot以返回自身:

auto foo=[]()->std::vector<int>{
  return {1,2};     
};

为什么我不能回来initializer list？它可能很有用.例如,一个lambda可用于初始化a vector或a list或...具有某些默认值.

我有T矢量矢量:

std::vector<std::vector<T>> vector_of_vectors_of_T;

我想将它们全部合并到T的单个向量中:

std::vector<T> vector_of_T;

我目前正在使用这种方法:

size_t total_size{ 0 };
for (auto const& items: vector_of_vectors_of_T){
    total_size += items.size();
}
vector_of_T.reserve(total_size);
for (auto const& items: vector_of_vectors_of_T){
    vector_of_T.insert(end(vector_of_T), begin(items), end(items));
}

有更直接的方法吗？就像一个准备好的std函数？如果没有,是否有更有效的方法手动完成？

使用std::vector::emplace_back和std::move一起有什么好处？或者它只是多余的,因为std::vector::emplace_back会做一个inplace-construction？

案例澄清:

std::vector<std::string> bar;

第一:

bar.emplace_back(std::move(std::string("some_string")));

第二:

std::string str("some_string");
bar.emplace_back(std::move(str));

第三:

bar.emplace_back(std::move("some_string"));

取决于这个问题浮点除法与浮点乘法.由于某些原因,除法比乘法慢.

如果可能的话,编译器通常会用乘法代替除法吗？

例如:

float a;
// During runtime a=5.4f
float b = a/10.f;

那将会:

float a;
// During runtime a=5.4f
float b = a*0.1f;

如果它被认为是编译器可靠的问题,我使用VS2013默认编译器.但是,如果我得到一个通用的答案(这个优化的理论有效性)会很好

我试图通过测量运行具有可预测分支的循环的时间与具有随机分支的循环来充分理解分支预测.

所以我写了一个程序,它采用不同顺序排列的0和1的大数组(即所有0,重复0-1,所有rand),并根据当前索引是0还是1,执行时间迭代数组分支浪费的工作.

我预计难以猜测的阵列需要更长时间才能运行,因为分支预测器会更频繁地猜错,并且两组阵列上的运行之间的时间差值将保持不变,而不管时间量如何 - 浪费工作.

然而,随着浪费时间的工作量的增加,阵列之间的运行时间差异增加了很多.

(X轴是浪费时间的工作量,Y轴是运行时间)

有谁理解这种行为？您可以在以下代码中看到我正在运行的代码:

#include <stdlib.h>
#include <time.h>
#include <chrono>
#include <stdio.h>
#include <iostream>
#include <vector>
using namespace std;
static const int s_iArrayLen = 999999;
static const int s_iMaxPipelineLen = 60;
static const int s_iNumTrials = 10;

int doWorkAndReturnMicrosecondsElapsed(int* vals, int pipelineLen){
        int* zeroNums = new int[pipelineLen];
        int* oneNums = new int[pipelineLen];
        for(int i = 0; i < pipelineLen; ++i)
                zeroNums[i] = oneNums[i] = 0;

        chrono::time_point<chrono::system_clock> start, end;
        start = chrono::system_clock::now();
        for(int i = 0; i …

我有以下情况:

T* get_somthing(){
    std::vector<T> vec; //T is trivally-copyable
    //fill vec
    T* temp = new T[vec.size()];
    memcpy(temp, vec.data(), vec.size() * sizeof(T));
    return temp;
}

我希望通过std::vector::data像这样直接返回来摆脱复制过程:

T* get_somthing(){
    std::vector<T> vec; //T is trivally-copyable
    //fill vec
    return temp.data();
}

但是,这是错误的,因为在vec调用析构函数时将删除数据.

那么,如何防止vec删除其数据呢？换句话说,我想从std::vectorC++原始动态数组中获得某种移动idiiom .

PS改变设计不是一种选择.使用std::vector这是强制性的.返回一个pointer到array也是必须的.Becauese它是两个模块之间的包装.一个需要矢量另一个需要指针.

我有一个std::unique_ptr和另一个原始指针.我希望原始指针指向unique_ptr没有任何所有权的内容.它是只读关系:

auto bar=std::make_unique<foo>();
auto ptr=bar.get();// This may point to another value later

这不好吗？还有其他选择吗？

注意:真实的例子比较复杂.他们不在同一个班级.