小编Hum*_*awi的帖子

我发现了许多关于此错误的帖子,但我可以找到如何克服它.这是触发错误的代码:

void main(){
    float f{1.3};
}

为什么在initialize-list中没有像任何其他变量那样发生转换？例如,这很顺利:

float f = 1.3;

我知道派生类unique_ptr可能发生在unique_ptr多态类型需要基类的地方.例如,从函数返回时

unique_ptr<Base> someFunction()
{
     return make_unique<Derived>(new Derived());
}

或传递给函数作为参数.

// Function taking unique pointer
void someOtherFunction(unique_ptr<Base>&& ptr)
// Code calling this function
someOtherFunction(std::move(ptrToDerived));

我的问题是:这种向上转换是否总是自动的？或者我们需要使用明确执行它dynamic_cast吗？

我有这个向量:

std::vector<my_class> my_vector;

我想用默认构造函数添加新项.所以,我写道:

my_vector.push_back(my_class());

有没有办法直接提到它？例如:

 my_vector.push_back(auto()); // imaginary code

在a上调用insert成员函数时std::vector,它会reserve在"推回"新项目之前吗？我的意思是标准保证与否？

换句话说,我应该这样做:

std::vector<int> a{1,2,3,4,5};
std::vector<int> b{6,7,8,9,10};
a.insert(a.end(),b.begin(),b.end());

或者像这样:

std::vector<int> a{1,2,3,4,5};
std::vector<int> b{6,7,8,9,10};
a.reserve(a.size()+b.size());
a.insert(a.end(),b.begin(),b.end());

还是其他更好的方法？

假设有一个对象A拥有一个对象B via std::unique_ptr<B>.进一步B保持对A的原始指针(弱)引用.然后A的析构函数将调用B的析构函数,因为它拥有它.

在B的析构函数中访问A的安全方法是什么？(因为我们也可能在A的析构函数中).

一种安全的方法是在A的析构函数中明确重置对B的强引用,以便以可预测的方式销毁B,但一般的最佳实践是什么？

我想在两个std::vector人中搜索一个值.如果在其中一个中找到它,我想返回它的迭代器.如果没有,我想返回一些值,表明找不到它.

在只std::vector涉及一个人的正常情况下,我会回来std::vector::end.在这种情况下我该怎么办？

正常情况:

auto find_ten=[](const std::vector<int>& v){
    return std::find(v.cbegin(),v.cend(),10);
}

我的情况:

auto find_ten=[](const std::vector<int>& v1,const std::vector<int>& v2){
    auto it1=std::find(v1.cbegin(),v1.cend(),10);
    if(it1==v1.cend()){
        auto it2=std::find(v2.cbegin(),v2.cend(),10);
        if(it2==v2.cend()){
             //What should I return here??
        }
        return it2;
    }
    return it1;
}

我想返回一些我可以稍后检查的东西,知道其中10任何一个都找不到该号码.

注意:我不是在询问Median Filter.

我有一系列图像让我们说:

std::array<cv::Mat,N> sequence;

我想将所有这些图像合二为一.这一张图片应满足:

新图像的每个像素是来自序列的其对应像素的中值.换一种说法:

Result(i,j)=median(sequence[0](i,j), sequence[1](i,j), ..., sequence[N](i,j));

这样做有内置功能吗？什么是最快的方式？

我到目前为止尝试过:迭代所有序列中的每个像素并排序然后取中位数然后将其存储在结果中.但是,这太过分了.

我有这个案子:

using T = classA; //T could be classA and could be `classB` in other platforms.
T a;
auto x = static_cast<classB>(a);

如果T classA是必须的铸件.在T的情况下,classB铸造是多余的.

按标准,是否会丢弃第二个铸件(不再有可执行代码),因为没有必要？

据我所知,const应尽可能使用.但是,我有一个总是困扰我的案例.

我是否应该将成员函数标记为const不更改任何成员变量值但它在概念上不是const函数？

例如:

class Engine{
public:
    int status;
};

class Car{
public:
   void start() const{
        engine_->status = 1;
    }
private:
    std::unique_ptr<Engine> engine_;
};

编译器将接受const的const,start()因为engine_指针没有改变.然而,至少IMO似乎是不切实际的,在一个被称为start类的函数中调用的函数Car是const一个!

这个例子只是一个快速的例子.通常,Car应该更新类的某些内部状态,使const关键字不可行.然而,迷你的例子只是为了说明我的想法.

我有以下图像掩码:

我想应用类似的东西cv::findContours,但该算法只加入相同组中的连接点.我想用一些公差做这个,即我想在给定的半径公差内添加彼此靠近的像素:这类似于欧几里德距离层次聚类.

这是在OpenCV中实现的吗？或者有没有快速的方法来实现这个？

我想要的是类似的东西,

http://www.pointclouds.org/documentation/tutorials/cluster_extraction.php

应用于此蒙版的白色像素.

谢谢.