std :: list <std :: unique_ptr <T >>:传递它
#include <iostream>
#include <list>
#include <memory>
#include <typeinfo>
class T {
public:
// 类T的声明
};
int main() {
// 创建一个std::unique_ptr<T>对象，并把它添加到std::list<std::unique_ptr<T>>中
std::list<std::unique_ptr<T>> lst;
lst.push_back(std::make_unique<T>());
// 遍历std::list<std::unique_ptr<T>>中的元素，并访问它们的T类型
for (const auto& ptr : lst) {
const std::type_info& info = typeid(ptr.get());
std::cout << "Object of type " << info.name() << " found." << std::endl;
}
return 0;
}以上代码首先包含了必要的头文件，然后创建了一个std::list<std::unique_ptr<T>>对象，其中T是一个用户定义的类型。接着，我们使用std::make_unique<T>来创建一个std::unique_ptr<T>对象，并将其添加到std::list<std::unique_ptr<T>>中。最后，我们使用typeid操作符来获取std::unique_ptr<T>对象的类型信息，并将其打印出来。
相关·内容
假设我有一个class T的std::list：
std::list<T> l;
当把它传递给函数时，我会使用一个引用：
someFunction( std::list<T> &l )
传递unique_ptrs的std::list的(元素)的最佳方式是什么？
std::list< std::unique_ptr<T> > l;
如下所示：
someFunction( std::unique_ptr<T> ptr )
或者这样：
someFunction( T* ptr )
或者这样：
someFunction( T &am
浏览 0提问于2010-07-11得票数 11
回答已采纳
为了练习，我使用了一个二进制搜索树和一个带有智能指针的红黑树。 Node如下所示： template <typename T>
struct BSTNode {
T key;
std::unique_ptr<BSTNode<T>> left;
std::unique_ptr<BSTNode<T>> right;
BSTNode<T>* succ;
BSTNode(const T& key) : key {key}, succ {nullptr} {}
}; 在这里，suc
浏览 5提问于2020-07-16得票数 1
回答已采纳
2回答
我正在尝试实现一个模板双链接列表，遵循Stroustrup的“使用C++的原则和实践”一书，第20.4章。我想使用唯一的指针，而不是原始指针。守则的组织方式如下：
实现结构Node的报头Node.h :下一个节点使用unique_pointer，前一个节点使用原始节点
实现Iterator的报头Iterator.h
实现类List的头清单.h
测试方法的main.cpp
我看到还有其他类似的问题，比如这一个，但是我不知道插入方法的设计：iterator insert(iterator p, const T& x)是否还好。特别是，如果我调用auto it3 = insert(--p,4
浏览 0提问于2020-12-25得票数 6
我正在为一个游戏开发一个模板组件系统。它保存向量中的项，并有两个部分的专门化:一个用于POD类型，另一个使用std::unique_ptr。对于std::unique_ptr向量的模板化专门化并不编译，但是在非模板代码中使用std：：unique_ptr的向量工作得很好。我已经找到了解决这个问题的方法，但不幸的是，我对C++11/C++14的认识还不够完善；我做错了什么？
最小的示例(剥离到问题区域)：
#include <vector>
#include <memory>
template<typename T>
class component
{
浏览 29提问于2015-09-08得票数 1
回答已采纳
1回答
我正在使用malloc编写自己的向量类。特别是，为了向提供一个最小的示例，我只显示构造函数和订阅操作符[]。
#include <iostream>
#include <algorithm>
#include <utility>
#include <cstdlib>
template<typename T>
class Vector{
std::unique_ptr<T,decltype(&free)> elem{nullptr,free};
std::size_t _size{};
std::si
浏览 2提问于2020-12-06得票数 0
我正在为一个结构创建一个unique_ptr (这很好)：
std::unique_ptr<w9::Product> product (new w9::Product(desc[i].desc, price[j].price));
然后，我将把这个unique_ptr附加到一个向量成员函数中。
object += product;
它重载+=，如下所示：
void operator+=(std::unique_ptr<Product> const &p) {
object.push_back(&p);
}
问题是最后一点。什么是正确的方法push
浏览 0提问于2014-12-04得票数 1
回答已采纳
目前我有类A，带有派生类型，B和C。
class A {};
class B : public A {};
class C : public A {};
然后，我有一个类型为A的向量，它附加了一个类型为B和C的对象。就像这样：
std::vector<A*> list = new std::vector<A*>;
list->push_back(new B);
list->push_back(new C);
我的主要问题是:如何从这个向量中获得特定类型的对象(从A继承)？
我尝试使用模板，尽管这会产生未解决的外部符号错误。
template <clas
浏览 0提问于2019-06-20得票数 0
回答已采纳
我正在尝试为我们的项目实现智能指针。我们使用的是用casts编写的FreeRTOS，因此实现在周围发送智能指针是一个相当大的挑战，但不知怎么的，我将转换和新调用结合在一起(不太喜欢这种方式)。移动语义和其他一些技巧。
表面上，它的行为与预期一样，但我希望确保没有任何内存泄漏。此外，是否有一种将make_unique与new结合使用的方法？我还没有真正找到办法。
下面是代码，它应该与在线C++编译器一起工作(或者使用这个链接)。如果专家能看一看，那就太好了。也许有些东西是可以优化的，或者这段代码根本没有保存，我只是没有看到它。
// Example program
#include <io
浏览 0提问于2020-05-07得票数 0
我有这样一门课 template <typename T>
class Store {
private:
struct pointNode {
T data;
std::unique_ptr<pointNode> next;
pointNode():data(std::move(T{})),next(std::move(std::unique_ptr<pointNode>{})){}
pointNode(T n_data, std::unique_ptr<pointNode&
浏览 9提问于2021-02-12得票数 0
回答已采纳
1回答
我编写了一个通用的Collection类，它允许我从封装的std::list中添加和删除项。集合将在添加或删除项时引发事件。
通常，我会从std::list派生这个类，但出于各种原因，强烈建议我不要这样做。但是，我仍然需要能够遍历集合，其中一种方法是公开begin和end方法，返回一个普通的STL迭代器：
template <typename T>
class Collection
{
public:
typename std::list<T*>::iterator begin()
{
return _items.begin();
浏览 0提问于2012-07-28得票数 2
回答已采纳
使用std::unique_ptr<T>&而不是std::unique_ptr<T>有什么好处吗？例如，函数参数？
浏览 2提问于2018-07-18得票数 5
回答已采纳
我几乎没有使用C++移动功能，所以我不确定我所做的是正确的。我希望任何人查看我的代码并指出我所犯的任何错误。
这样做的目的是创建一个由key存储的资源映射。资源可能是不可复制和不可移动的。
另外，我的类需要构造函数和析构函数定义吗？
谢谢。
#define TYPE(x) std::identity<decltype(x)>::type
namespace General
{
template<class T>
std::string ToString(const T& x)
{
std::ostringstream s
浏览 2提问于2013-09-01得票数 3
回答已采纳
我正在尝试将数据嵌入到std::map中。下面是我尝试过的内容(从原始源中删除，但确实给出了想法)：
template<typename T> class trie {
private:
std::map<typename T::value_type, std::unique_ptr<trie<T>>> children;
std::unique_ptr<trie<T>> parent;
// Later
public:
trie(const trie<T>& other, trie<T>
浏览 2提问于2013-10-13得票数 2
回答已采纳
我在向模板类成员函数传递1.唯一ptr时遇到编译错误2.指向模板类成员函数的唯一指针的内容
我正在尝试将数据推送到一个向量中。数据为模板型。这里的唯一指针用于在每次数据到来时在堆上创建内存，然后将数据存储到向量中。即使复制指向新位置的指针，也可以将其推入向量中。我都试过了1.使用T item捕获数据；//下面提到的代码2.使用std::unique_ptr &item捕获引用的唯一指针；示例代码是一段很长的代码
#include <stdio.h>
#include<iostream>
#include<vector>
#include <mu
浏览 0提问于2019-04-12得票数 0
我需要初始化一个实现树状结构的类型。
Tree t1 = 1;
Tree t2 = {{"a",t1},{"b",{{"x",2},{"y",4}}},{"c",5}};
因此，我定义了继承自std::unordered_map的结构。我不得不将循环的Tree封装在智能指针中。
//tree.h
using std;
struct Tree : unordered_map<string, unique_ptr<Tree>>{
int simple;
浏览 5提问于2022-08-05得票数 0
回答已采纳
为了向我的函数f提供更好的接口，我使用了一个模板：
#include <iostream>
#include <memory>
using namespace std;
using UPSTR = unique_ptr<char[]>;
void f(const initializer_list<UPSTR>& list){
// process strings, concatenate, excluding certain patterns..
for(auto& x:list) cout << x.ge
浏览 8提问于2022-09-09得票数 0
4回答
让我们考虑以下代码：
template<typename T>
void f(std::unique_ptr<T>&& uptr) { /*...*/ }
在另一个职能中：
void g()
{
std::unique_ptr<ANY_TYPE> u_ptr = std::make_unique<ANY_TYPE>();
f(std::move(u_ptr));
X: u_ptr->do_sth(); // it works, I don't understand why. Details belo
浏览 11提问于2016-03-09得票数 0
回答已采纳
我在Qt工作，我没有提到，因为我认为这只是C++问题。
我用共享的指针解决了这个问题，所以不要给我解决方案。但这是理解的问题，我想了解为什么它不起作用。
我尝试了以下几点：
测试。h：
#include <QObject>
#include "response.h"
#include <memory>
class Test : public QObject
{
Q_OBJECT
public:
explicit Test(QObject *parent = nullptr);
signals:
void signal(std:
浏览 3提问于2019-11-15得票数 0
回答已采纳
我正在尝试创建部分专门化的模板，如果通过了一个std::unique_ptr，我将进一步专门化。
template <typename T, typename = void>
struct Foo;
// A
template <typename T>
struct Foo<std::unique_ptr<T>, typename std::enable_if<std::is_class<T>::value>::type> {...};
// B
template <typename T>
struct F
浏览 12提问于2017-06-18得票数 7
回答已采纳
有人能告诉我这段代码有什么问题吗？它抛出一个错误：
不能将参数1从“_Ty”转换为“ConstDay18：：BaseInstruction&”
enum Command { snd, set, add, mul, mod, rcv, jgz };
struct BaseInstruction {
Command cmd;
char reg;
BaseInstruction(Command cmd, char reg)
:cmd{cmd}, reg{reg}
{}
};
浏览 17提问于2022-05-15得票数 -4
回答已采纳
我试图为一个哈希表创建一个类，以包含唯一的指针，但是每当我试图向该表添加一个指针时，我都会得到一个错误，它指向与我使用的库不同的文件。
我尝试过使用.insert()而不是.emplace()。我试着传递一对钥匙和指针。
这两种方法都导致了与原始错误不同的错误。
下面是Hash_Table类：
///<summary>
/// A struct for a hash table
///</summary>
template <typename T>
struct Hash_Table
{
public:
///<summary>
浏览 0提问于2019-09-09得票数 1
我在想这件事。考虑到这一点：
#include <iostream>
#include <map>
#include <memory>
int main() {
std::map< int, std::unique_ptr<int> > m =
{ { 1, std::unique_ptr<int>(new int(3)) } };
return(0);
}
这是C++11，它无法编译GCC的大量错误消息，包括一条错误消息。
/usr/include/c++/4.9/ext/new_allocator
浏览 7提问于2016-07-18得票数 3
回答已采纳
2回答
我需要一个集合，可以在其中存储具有虚拟函数的堆分配对象。
我知道boost::shared_ptr、std::unique_ptr (C++11)和boost::ptr_(vector|list|map)，但它们不能解决重复指针问题。
为了描述一个问题，我有一个函数，它接受堆分配的指针，并将它存储起来供将来使用：
void SomeClass::add(T* ptr)
{
_list.push_back(ptr);
}
但是，如果我用相同的参数两次调用add，ptr - _list将包含指向同一个对象的两个指针，并且当_list被破坏时，将发生对同一个对象的多次删除。
如果_list会在删
浏览 2提问于2012-01-08得票数 2
回答已采纳
这不太可能，但是我正在尝试推断一些T的std::list<T>类型的通用引用。
我有这样的东西：
// Is the type A the same as B, regardless of const and references
template <typename A, typename B>
struct is_same_kind {
static constexpr auto value = std::is_same_v<std::remove_cv_t<std::remove_reference_t<A>>,
浏览 4提问于2018-08-17得票数 3
回答已采纳
作为我提供给这里的示例代码，我觉得std::shared_ptr的使用是错误的，应该使用std::unique_ptr替换，因为除了临时需要之外，没有真正的共享所有权语义。
如何正确地重构代码，例如使用std::unique_ptr？
#include <memory>
#include <iostream>
template<typename T>
class LinkedList {
private:
template<typename U = T>
struct Node {
U data;
浏览 0提问于2017-01-20得票数 -1
回答已采纳
我有一个std::unique_ptr<T>对象和一个以T&作为参数的库函数。此函数将更改T对象数据。
将std::unique_ptr<T>传递给该函数的更好方法是什么？以上代码正确吗？有没有更好的方法？
#include <iostream>
#include <string>
#include <memory>
class Test {
public:
std::string message = "Hi";
};
void doSomething(Test& item)
浏览 10提问于2015-12-03得票数 3
回答已采纳
现在，我只是在学习smart_ptr (unique_ptr / shared_ptr)。我编写了这样的测试代码，用于检查unique_ptr是否可以用作参数。
typedef struct __T_TEST
{
char cT1;
char cT2;
} T_TEST;
int main(...)
{
...
char szB[2] = {0x61, 0x62};
auto pTest = std::make_unique<T_TEST>();
std::memcpy(pTest, szB, 2);
printf("T1 = [%02x]\n", pTest-
浏览 5提问于2015-07-29得票数 0
回答已采纳
1回答
我想使用助推：：变体有效地保持几个不同类型的联合，如下所示。
using VariantType = boost::variant<
std::shared_ptr<StructA>,
std::shared_ptr<StructB>
>;
我在上组装了一个原型，它至少在那里编译。
VariantType variant = std::make_shared<StructA>(1, 'a', 3);
boost::apply_visitor(output{}, variant);
std::cout &l
浏览 5提问于2016-08-22得票数 1
我需要在模板化的单例类中使用std::call_once，但目前以下示例代码无法编译：
std::once_flag flag;
class LifeTrackerHelper
{
public:
template<class T>
inline static int SetLongevity(std::unique_ptr<T>& pobj,unsigned int longevity = 0)
{
return 0;
}
};
template<class T>
class Singleton
{
public:
in
浏览 0提问于2017-05-17得票数 3
1回答
我正在学习设计原则课程，当我试图在自己身上实现一个开放的关闭原则时，我们定义了不同的规范，然后发送到filter类来检查给定实体是否有效。
这是我的虚拟课程
template <typename T>
struct Specification {
virtual ~Specification() {}
virtual bool is_satisfied(T* item) = 0;
};
template <typename T>
struct Filter {
virtual std::vector<T*> filter(std:
浏览 9提问于2022-10-29得票数 0
1回答
我一直在使用std::unique_ptr和std::for_each算法来学习它们，然后当我试图将一些变量从一个容器(std::map)移动到另一个容器时，我收到了“试图引用已删除的函数”的错误。
此代码当前在成员函数中执行。Foo只是一个泛型类。
std::for_each(m_list1.begin(), m_list1.end(),
[&](std::pair<std::size_t,std::unique_ptr<Foo>> data_pair)
{
m_list2
浏览 4提问于2014-06-08得票数 0
回答已采纳
以下代码不会编译并在注释中生成错误：
#include <memory>
#include <initializer_list>
template <typename T, typename E>
std::unique_ptr<T> make_unique_arr(const std::initializer_list<E>& il)
{
//std::unique_ptr<T> p{new int[il.size()]{1,2,3,4,5}}; //works
// gcc error: c
浏览 4提问于2017-01-13得票数 2
回答已采纳
如果我直接调用类构造函数，但在std::unique_ptr和std::make_unique中没有得到类构造函数，为什么要自动进行模板参数推断？下面是一个示例：
#include <memory>
template <class T>
class C
{
public:
C(const T * const t_) : t(t_) {}
~C(void) { delete t; }
private:
const T * const t;
};
例1(工程)：
int main(void)
{
const int * const t = new int;
aut
浏览 10提问于2021-12-14得票数 1
回答已采纳
嗨，我有个问题，我找不到解决办法。我正在创建一个具有智能指针的实体组件系统。
我得到的错误是：
不能用std::unique_ptr<PrimaryComponent, std::default_delete<PrimaryComponent>> &类型的值( std::unique_ptr<PlayerGraphics, std::default_delete<PlayerGraphics>>类型)初始化类型为std::unique_ptr<PlayerGraphics, std::default_delete<Playe
浏览 1提问于2015-11-18得票数 2
回答已采纳
我正在尝试用unique_ptr来实现BST。我有一个shared_ptr的工作程序。如何使用unique_ptr来执行BinarySearchTree的单一所有权语义？
当我用shared_ptr替换unique_ptr时，我会得到超出我理解的编译错误。
#include <iostream>
#include <memory>
template<class T>
class BinarySearchTree{
struct TreeNode;
typedef std::shared_ptr<TreeNode> spTreeN
浏览 3提问于2014-07-06得票数 5
回答已采纳
2回答
我试图将多态类型作为地图中的一个键。
我提出了以下两种结构：
注意，Game是一个抽象类，我使用的数据结构是：
std::unordered_map<gamePtr,int> _allGames;
而gamePtr是一个typedef，用于：
unique_ptr<Game>
template<>
struct std::hash<std::unique_ptr<Game>> {
size_t operator()(std::unique_ptr<Game> game) const {
return (std
浏览 5提问于2014-01-07得票数 4
回答已采纳
我不清楚这些好处是什么。
如果我有：
Foo* foo = nullptr;
std::unique_ptr<Foo> unique_foo(foo);
在这种情况下是否调用nullptr_t构造函数？或者只有当你这样做的时候：
std::unique_ptr<Foo> unique_foo(nullptr);
谢谢!
有一些讨论，它允许您传递nullptr_t，否则它将不会编译，因为它不会强制转换为类型指针。所以我的问题可能是为什么它不投？
浏览 2提问于2014-08-26得票数 7
回答已采纳
1回答
具有唯一指针的二进制搜索树实现
、、、、
我使用模板和unique_ptr在C++ 11中实现了一个二进制搜索树，目前只实现了插入和删除。请提供您对改进的反馈意见。
#include <iostream>
#include <memory>
template<typename T>
class Btree {
public:
void insert(T data)
{
_insert(root, data);
}
void traverse(void (*func)(T data))
{
_traverse(root, fu
浏览 0提问于2019-03-07得票数 0
回答已采纳
以下代码将不编译：
bool ptrLess(unique_ptr<int> ptr1, unique_ptr<int> ptr2)
{
return *ptr1 < *ptr2;
}
int main()
{
unique_ptr<int> ptr1(new int(3));
unique_ptr<int> ptr2(new int(2));
unique_ptr<int> ptr3(new int(5));
list<unique_ptr<int>> list;
浏览 0提问于2018-05-20得票数 2
回答已采纳
当我意识到以下代码编译并成功运行时，我正在尝试通过重新创建一个基本的std::unique_ptr来进行模板的专门化：
namespace not_std {
template<typename T>
class unique_ptr
{
public:
unique_ptr(T *pointer)
: pointer_(pointer)
{ }
~unique_ptr()
{
delete pointer_;
}
private:
T *pointer_;
};
template<typ
浏览 5提问于2020-12-19得票数 0
回答已采纳
4回答
对于期望std::unique_ptr的构造函数，如何有效地防止客户端传递nullptr？
class Foo{
Foo(std::unique_ptr<Bar> bar) :
myBar(std::move(bar))
{}
}
我是否可以用nullptr_t参数重载构造函数，然后将其设置为已删除，以便在编译时检测某些nullptr？
Foo(nullptr_t) = delete;
当我已经在初始化列表中移动构造函数时，我能安全地检查构造函数正文中的nullptr吗？(有件事告诉我我不能)
Foo(std::unique_ptr<Bar&g
浏览 7提问于2014-06-06得票数 6
回答已采纳
2回答
假设我有某个类T的std::list。
管理这些元素的最佳方法是什么？考虑到只有管理者(我的意思是--一个所有者)可以在列表中添加或删除项目。
1)
std::list < T* > myList;
//adding the new element
myList.push_back( new T(..) );
//deleting the one element
...roaming through the list...got it...
delete *iterator;
myList.erase(iterator);
2)
std::list < std::uniq
浏览 0提问于2013-07-19得票数 5
回答已采纳
1回答
请考虑以下代码。在list1中，我将保存在堆中的元素添加到向量中并进行打印。它如预期的那样工作。在list2中，我从一个函数将元素添加到向量中，该函数还分配堆上的元素。
我知道我必须在堆上分配Node，因为如果函数返回，它就会被释放。但是，通过最后的print语句，我可以看到堆上的节点仍然被分配，但是它们没有出现在我的向量中。
#include <iostream>
#include <vector>
using namespace std;
/*
Simple node class for demo
*/
class Node
{
public:
stri
浏览 2提问于2021-09-14得票数 0
回答已采纳
1回答
我有一个Holder类，它应该只公开其映射的值。我使用了一个转换迭代器来完成这个任务。如果我使用指向类型(ClassA*)的普通指针(ClassA*)，但不使用unique_ptr，它就能工作。我基于以下代码示例：
我得到了以下错误(起源于begin()函数)，这让我认为有人试图复制这对而不是使用引用。
提前感谢
错误C2248：
'std::unique_ptr<ClassA,std::default_delete<_Ty>>::unique_ptr‘：
无法访问类中声明的私有成员
'std::unique_ptr<ClassA,std::de
浏览 3提问于2013-06-04得票数 0
回答已采纳
我有以下情况：
Base是一个基类。T是一个模板，可以假定Base的任何派生类。
底层提供了来自Base类的数据，需要将这些数据转换为上面层(编写代码的那一层)上的特定类，以便在用户级别上工作。
以下是代码：
template <class T> class Access {
std::vector<std::unique_ptr<T> getData();
}
template <class T>
std::vector<std::unique_ptr<T> getData()
{
///
浏览 2提问于2015-05-27得票数 0
回答已采纳
我正在尝试用pybind11在C++应用程序中嵌入python。 我正在创建一个具有以下函数的array_t： template<class T>
py::array_t<T> create_matrix(size_t width, size_t height, T* data_ptr = nullptr)
{
auto b = py::buffer_info(
data_ptr,
sizeof(T), //itemsize
py::format_descriptor<T>::format(),
浏览 54提问于2019-05-18得票数 1
在一个名为Tasks.h的文件中，我有以下函数：
void source_thread_func(BlockingQueue<Task> &bq, int num_ints)
{
std::cout<<"On source thread func"<<std::endl; // Debug
for (int i = 1; i <= num_ints; i++)
{
//Valgrind does not like this
std::unique_ptr<Task> t
浏览 2提问于2019-03-05得票数 0
回答已采纳
移动std::unique_ptr<...>()的语法让我有些不知所措，我也找不到一个明确的答案(至少对我来说是这样)，我不知道该如何移动unique_ptr。
我有一些堆分配的节点，并希望创建新的节点，其中有两个已经存在的节点作为子节点。它又应该被插入到向量中。
#include <memory>
#include <vector>
template <typename T>
struct Node{
std::unique_ptr<Node<T>> left, right;
Node(std::un
浏览 1提问于2019-01-24得票数 1
回答已采纳
我希望有一个在编译时生成的多态类型数组。对数组的访问是在运行时指定的(否则我将只使用元组)。我希望数组通过unique_ptr拥有它的元素。目前我正在使用可变模板来创建数组。我正在尝试做的事情的简化版本(MSVC 2012年11月CTP)：
#include "stdafx.h"
#include <array>
#include <memory>
#include <tuple>
#include <initializer_list>
#include <iostream>
using namespace std;
浏览 4提问于2013-01-02得票数 0
使用唯一的指针，我们可以编写
class A{};
class B: public A{};
class C: public A{};
std::vector<std::unique_ptr<A>> myArray;
//
f()
{
std::unique_ptr<B> pB {new B()};
std::unique_ptr<C> pC {new C()};
myArray.push_back(std::move(pB));
myArray.push_back(std::move(pC));
// n
浏览 5提问于2014-07-17得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
