看完后timdays回答到这个问题,我很好奇的区别boost::ptr_container和std::vector<shared_ptr>.我的印象是,下一个boost::ptr_container在给它的指针有所有权,并在释放将召开它包含指针的析构函数,无论其居民其他参考资料.这与a的目的相反,std::vector<shared_ptr>如果ref计数为0,那么在释放之后它只会释放指针本身？
如果是这种情况(我假设不是这样),那么为什么甚至Boost文档示例都会比较两者,就好像它们的目的相似,为什么timday的答案会提出一个boost::ptr_container与a的目的非常不同的答案std::vector<shared_ptr>.
将嵌套std::vector的std::vectors 转换为最优雅有效的方法是cv::Mat什么？嵌套结构保持一个数组,即所有内部std::vectors具有相同的大小并表示矩阵行.我不介意将数据从一个复制到另一个.
我知道单个非嵌套std::vector很容易,有一个构造函数:
std::vector <double> myvec;
cv::Mat mymat;
// fill myvec
bool copy = true;
myMat = cv::Mat(myvec, copy);
嵌套向量怎么样？
所以我有一个这样的矢量:
std::vector<std::unique_ptr<SomeClass>> myVector;
然后我有另一个包含原始指针的向量SomeClass:
std::vector<SomeClass*> myOtherVector;
如果里面有一个元素,myOtherVector它也会在里面myVector,所以我想遍历每个元素myOtherVector并从中删除相同的元素myVector.然后清除矢量.这就是我想出的:
for(size_t i = 0; i < myOtherVector.size(); i++)
{
myVector.erase(std::remove(myVector.begin(), myVector.end(), myOtherVector[i]), myVector.end());
}
myOtherVector.clear();
这会产生编译时错误,因为它myVector保存了唯一的指针,但我给remove()函数一个原始指针.这是我需要帮助的地方,因为我不知道解决这个问题的正确方法是什么.我把线改为:
myVector.erase(std::remove(myVector.begin(), myVector.end(), std::unique_ptr<SomeClass>(myOtherVector[i])), myVector.end());
所有这一切都是不正确的,因为现在我有两个std::unique_ptr引用相同的对象.里面的元素myVector包含一个引用,上面一行中唯一指针的构造是另一个引用.我甚至不知道构造一个新的指针来获得相同类型在概念上是否正确的方法去做这件事.然后我将唯一指针更改为共享指针:
std::vector<std::shared_ptr<SomeClass>> myVector;
std::vector<SomeClass*> myOtherVector;
for(size_t i = 0; i < myOtherVector.size(); i++)
{
myVector.erase(std::remove(myVector.begin(), myVector.end(), std::shared_ptr<SomeClass>(myOtherVector[i])), myVector.end());
}
myOtherVector.clear();
当我运行应用程序时,该myVector.erase()行导致运行时错误,表示"ApplicationName.exe已触发断点".点击继续,我得到一个调试断言失败.
显然我做错了什么,但我不知道是什么.使用原始指针从矢量中擦除智能指针的正确方法是什么？
我正在开发一个多线程应用程序,每个线程将从一组地图和向量中读取(不会修改结构).任何人都可以建议,因为线程只是从这些结构中读取,是否有必要在读取这些结构的代码块周围实现可共享的互斥锁？
看看这段代码.
#include <vector>
template<class ...Args>
using other_vector = std::vector<Args...>;
template<class T>
void f(std::vector<T>& ) {}
template<class T>
void f(other_vector<T>& ) {}
int main()
{
other_vector<int> b;
f(b);
return 0;
}
它没有编译,因为f正在重新声明.我完全理解错误.但是,我需要一个行为类似的第二个类std::vector<T>,但将被视为一个不同的类型,因此重载,如上例所示,是合法的.
我能做什么？
std::vector<T>作为基类.这可能有效,但不应该从std容器继承.有更好的选择吗？允许使用C++ 11或C++ 14.
我对矢量push_back行为的方式有点困惑,使用下面的代码片段我预计复制构造函数只能被调用两次,但输出建议不然.是矢量内部重组导致这种行为.
输出:
Run Code Online (Sandbox Code Playgroud)Inside default Inside copy with my_int = 0 Inside copy with my_int = 0 Inside copy with my_int = 1
class Myint
{
private:
int my_int;
public:
Myint() : my_int(0)
{
cout << "Inside default " << endl;
}
Myint(const Myint& x) : my_int(x.my_int)
{
cout << "Inside copy with my_int = " << x.my_int << endl;
}
void set(const int &x)
{
my_int = x;
}
}
vector<Myint> myints;
Myint x;
myints.push_back(x);
x.set(1);
myints.push_back(x);
在过去,我们接受了培训,使用通过引用传递的结果参数,以避免不必要地复制数据.
但是对于更聪明的编译器 - 特别是C++ 11的扩展仍然需要吗？
具体来说,2018年是否有任何理由使用现代C++ 11/C++ 14编译器
void Filter(vector<CObject*> &elements, vector<CObject*> &outElements);
而不是简单地返回矢量,即
vector<CObject*> Filter(vector<CObject*> &elements);
提前感谢您的所有见解!
鉴于a std::vector,其大小和容量可以是任意的,将其大小更改为0并将容量更改为至少N(给定数量)的最佳做法是什么？
我的直接想法是:
void f(vector<int> &t, int N)
{
t.clear();
t.reserve(N);
}
但我注意到了
不能保证重新分配,并且不保证向量容量会改变(当调用std :: vector :: clear时).
所以我想知道当原始容量大于给定的N时,如何避免重新分配？
我想编写一个带有一个参数的C++函数,以便可以传入以下任何一种类型:
std::vector<int>
std::array<int>
int array[numElements]
int *ptr = new int[numElements]
etc
模板是实现这一目标的最佳方式吗？
我想先制作一个没有大小（vector<int> times）的向量，然后再在类（）的构造函数中定义其大小times(size)。
我可以通过使用初始化器列表来做到这一点，如下所示
class A (int size): times(size) {};
但是我的问题是，为什么不能在类似于以下代码的类的构造函数中执行此操作？
我的意思是为什么下面的代码是错误的？
class A
{
public:
A(int size);
private:
std::vector<int> line;
};
A::A(int size)
{
line(size);// here I got the error
}
line(size) 犯错误