在无序映射中插入智能指针会调用析构函数
。智能指针是一种封装了指针的对象，它会在不再需要指向的对象时自动释放内存。当将智能指针插入无序映射（例如哈希表）时，如果该指针指向的对象已经存在于映射中，那么插入操作会触发析构函数的调用。
析构函数是类的特殊成员函数，用于在对象被销毁时执行清理操作。当智能指针从无序映射中被移除或者映射本身被销毁时，会触发智能指针的析构函数。析构函数的主要作用是释放智能指针所管理的资源，例如释放动态分配的内存或关闭文件等。
在无序映射中插入智能指针的优势是可以方便地管理资源的生命周期，避免内存泄漏和资源泄漏的问题。智能指针可以自动释放指向的对象，无需手动调用delete或者释放资源的操作，提高了代码的可靠性和安全性。
智能指针在实际应用中的场景非常广泛。例如，在使用C++编写的程序中，当需要动态分配内存并在不再需要时自动释放时，可以使用智能指针来管理内存资源。另外，智能指针还可以用于管理其他资源，如文件句柄、数据库连接等。
腾讯云提供了多种与智能指针相关的产品和服务，例如云服务器、云数据库、云存储等。这些产品可以帮助开发者更好地管理资源，并提供高可用性和可靠性的云计算解决方案。具体产品介绍和相关链接地址可以参考腾讯云官方网站：https://cloud.tencent.com/
相关·内容
我有一个地图声明为
std::map< std::string, std::map<int,std::list<pointers*> > myMap; // in c++.
我想知道要删除此映射中的条目，调用myMap.erase(entryToBeDeleted)是否足够？或者，我是否应该遍历该子映射，首先删除所有内容，然后再删除条目？
此外，内部映射是一个以int为键、以指针列表为值的映射
浏览 2提问于2013-01-23得票数 0
回答已采纳
我有以下代码
#include <bits/stdc++.h>
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(
浏览 3提问于2022-09-03得票数 0
回答已采纳
2回答
用模板和智能指针实现堆栈
、、、、
我试图理解智能指针和模板的概念。为了更好地理解这两个概念，我尝试在Stack上实现这两个概念。我已经创建了一个Stack，它可以保存任何类型的对象。对于动态内存分配，我使用了智能指针。
请建议我如何改进代码。在使用智能指针和模板时，是否遗漏了任何情况？由于我使用的是智能指针，我是否可以确保一旦Stack变量超出作用域，空闲存储(堆)内存就会被删除？
#include "stdafx.h"
#include<iostream>
#include<string>
#include<memory>
using namespace std;
//
浏览 0提问于2017-05-19得票数 10
回答已采纳
我试图使用shared_ptr而不是原始指针来实现链接列表。守则：
#include <memory>
class NodeTest
{
private:
int v;
std::shared_ptr<NodeTest> next;
public:
NodeTest() { v = 0; };
NodeTest(unsigned int i) { v = i; }
~NodeTest() {};
void setNext(std::shared_ptr<NodeTest> & toSet) { next
浏览 1提问于2019-02-21得票数 1
回答已采纳
1回答
RAII与std：：功能
、、、、
在本质上像std::shared_ptr和std::unique_ptr一样聪明吗？我想不是吧？我有一个std::function，它是如下所示的类成员。
class MyClass {
typedef std::function<void(void)> Func;
Func m_func;
public:
MyClass() {
m_func = []() {
std::cout << "Func called" << std::endl;
}
}
浏览 0提问于2020-05-04得票数 1
回答已采纳
是否有可能在C++中自动生成析构函数？
这是一个很大的负担，不能一直靠自己去做。编译器是否很难生成析构函数？它不能检测什么是“资源”并在析构函数中释放它吗？
浏览 9提问于2014-01-09得票数 10
回答已采纳
6回答
我有一个包含指针的结构：
struct foo
{
char* f;
int* d;
wchar* m;
}
我有一个指向这些结构的共享指针的向量：
vector<shared_ptr<foo>> vec;
vec在堆栈上分配。当它在方法末尾传递到作用域之外时，它的析构函数将被调用。(对吧？)这将依次调用向量中每个元素的析构函数。(对吧？)调用delete foo是只删除诸如foo.f之类的指针，还是从堆中实际释放内存？
浏览 1提问于2010-06-09得票数 6
回答已采纳
4回答
我有一个名为SpriteX的类，它基本上是一个泛型sprite。我还有一个名为_Drawables的类，它有一个成员std::vector<SpriteX*>。在main()中，我创建的每个sprite都可以插入到_Drawables容器中，然后可以调用drawAll()方法来绘制std::vector中的所有SpriteX对象。
每个SpriteX对象都知道指向自身的指针所在的索引，并在其析构函数中设置指向NULL的指针。但我想完全销毁指针，而不仅仅是将其设置为NULL。但是删除指针是安全的吗？如果我在析构函数中使用delete，并调用析构函数，会导致循环吗？有没有办法释放内存。
浏览 1提问于2012-04-15得票数 1
回答已采纳
8回答
我正在学习C++中的内存管理，我不明白为什么在离开作用域时只调用一些析构函数。在下面的代码中，只在myfunc结束时调用obj1析构函数，而不是为动态分配的obj2调用。
int myfunc (cl1 *oarg) {
cout << "myfunc called" << std::endl;
cl1 obj1(222,"NY");
cl1 *obj2;
obj2= new cl1;
oarg->disp();
obj2 -> ~cl1 ;
}
下面是我的析构函数：
cl1
浏览 0提问于2011-07-18得票数 2
回答已采纳
2回答
删除指针数组
、、
我正在尝试创建一个AVL树，我正在使用一个动态指针数组来跟踪哪些节点受到insertion.My的影响问题是如果删除动态数组会删除指针的内容，因为well.The代码还没有完成，但我认为它会让你知道我mean.If它不工作，那么我应该如何做?提前谢谢。
treenode *newnode,**roadnodes,*parent ;
int x=(int)log(numberofnodes)+2,l=0 ;
bool *rightorleft,flag=true ;
newnode=new treenode ;
roadnodes=new treenode*[x] ;
rightorleft=n
浏览 2提问于2017-05-11得票数 1
2回答
在双向链表中使用智能指针
、、、、
下面是我所知道的关于智能指针的事情
shared_ptr是一种智能指针，因此多个shared_ptr可以指向堆中的一个对象。即使其中一个shared_ptr被删除，堆中的对象也不会被销毁，只要它的引用计数大于零。a weak_ptr也指向堆中的一个对象，但它不会增加该对象的引用计数我们可以使用weak_ptr来中断循环引用
在双向链表的情况下，我们有两个指针指向前一个节点和下一个节点。我们在实现中使用了shared_ptr和weak_ptr。为什么我们不使用两个weak_ptr呢？
浏览 77提问于2018-09-03得票数 0
3回答
我有一个C++类，MyClass。它包含一个构造函数，一个析构函数和一个整型指针private: int *MyPtr;。
在某个地方，我动态分配了一个MyClass对象：
MyClass *my = new MyClass(); //...
然后我调用delete my;
MyClass应该有一个使用类似delete MyPtr的析构函数吗？或者，当我调用delete my时，MyPtr被销毁了
浏览 2提问于2013-01-15得票数 1
回答已采纳
我有一个小问题：
Foo *myFoo;
myFoo = new Foo(anotherFoo); // some deep copy of another object
myFoo = new Foo(yetAnotherFoo); // another deep copy of yet another object
这是一个内存泄漏吗?如果是，我如何正确地避免它？在我的程序中的情况是，'myFoo‘是一个类成员，我想使用它作为一个“一个也是唯一的”存储对象，用于不时地对其他对象进行深度复制(因为复制的对象是后来修改的，我需要初始对象用于以后的比较)。
我尝试了一种简单的解
浏览 0提问于2011-10-04得票数 0
回答已采纳
6回答
我正在编写一个模板类，它在内部管理给定类型的数组。如下所示：
template<typename T>
class Example {
// ...
private:
T* objects; // allocated in c'tor (array), deleted in d'tor
// ...
};
我想知道当我通过delete[] objects;删除每个对象时，C++是否会调用objects中每个对象的析构函数。
我需要知道这一点，因为我的类中的对象并不总是包含合理的值，所以不应该在不包含合理值的时候调用析构函数。
此外，如果我在E
浏览 2提问于2013-06-27得票数 15
回答已采纳
4回答
我有一个构造函数，它使用new操作符分配几个内存块。
X::X() {
a = new int[100];
b = new char[100];
c = new float[100];
}
我的问题是，如果c的分配失败，构造函数抛出一个异常，那么a和b的内存会自动释放吗？
浏览 6提问于2016-02-25得票数 12
回答已采纳
2回答
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
struct A
{
A(char* p)
: p(p)
{}
~A()
{
delete this->p;
}
char* p;
};
int main()
{
A a(new char);
_CrtDumpMemoryLeaks();
}
在调试模式下运行后，Visual Studio 2012的输出窗口显示：
Detec
浏览 0提问于2012-12-22得票数 0
回答已采纳
4回答
我只是在学习c++，因为我对C和Java都有一定的理解。我不太明白为什么我写的一些代码不会泄漏内存。代码如下：
// Foo.h
class Foo {
private:
std::vector<int> v;
public:
Foo();
virtual ~Foo();
void add_int(int);
}
// Foo.cpp
Foo::Foo(): v () {}
Foo::~Foo() {}
Foo::add_int(int x) {
v.append(x);
}
存储在v中的向量显然在内部存储了一个指向堆分配的内存的指针，该内存需要释放，但我从
浏览 3提问于2013-04-01得票数 2
回答已采纳
当拥有的“父对象”退出作用域时，在类实例成员上使用shared_ptr会正确地清理新的对象吗？就像下面的例子一样？
下面的代码示例-那么当Family实例超出作用域时，它会清除/删除地图中链接的people对象吗？
如果是这样，我如何确认这一点？有没有工具可以用来显示之前和之后-在没有显示person对象之后-如果我把正常的指针放回去，我应该仍然可以看到person对象-谢谢
class Family
{
private:
//std::map<int ,Person*> _people;
std::map<int ,std::tr1::shared_ptr&
浏览 0提问于2012-02-06得票数 0
回答已采纳
3回答
我正在阅读Stroustrup的C++编程书中的一段代码。
class Vector_container : public Container {
Vector v;
public:
// Vector_container implements Container
Vector_container(int s) : v(s) { } // Vector of s elements
~Vector_container() {}
double& operator[](int i) { return v[i]; }
int size(
浏览 0提问于2019-07-10得票数 2
回答已采纳
5回答
这个问题来自于我试图理解在指针周围创建包装类的智能指针的动机，以便您可以添加一个自定义析构函数。做指针(和ints，bools，doubles等)没有破坏者？
浏览 1提问于2020-01-31得票数 5
回答已采纳
2回答
我试着让问题的标题尽可能具有描述性，这样你就不必点击问题来判断你是否有我的问题的答案。
我正在为一个类分配实现一个chaining hash table，并且我已经得出结论，vector最适合我的项目的目的。
考虑下面的代码片段：
struct node
{
public:
node(string key, node * next = NULL)
{
this->key = key;
this->next = next;
}
string key;
node * next;
};
class htable
浏览 3提问于2014-04-07得票数 0
1回答
我创建了一个函数，用于释放指向基类的对象的内存。
对于字段变量，可以将对象类型转换为派生类之一(DerA、DerB、DerC)。
删除对象的最佳实践是什么。
delete object;
delete (DerA*)obj;
delete static_cast<DerA>(object)
或者以上所有的都做同样的工作。
我的代码示例如下
void deal(BaseClass *obj)
{
if(obj)
{
switch(obj->m_id)
{
case DerivedAObj:
{
浏览 0提问于2017-05-24得票数 0
2回答
我有一个很大的程序，有些类使用指针到成员函数.一般的代码结构是：
#include <iostream>
using namespace std;
/**** CLASS FOO ****/
class Foo {
public:
Foo(); //constructor
void F
浏览 3提问于2015-03-18得票数 1
回答已采纳
1回答
因此，对于我的家庭作业，我不允许使用std::smart_ptr，但是我可以自己实现它，并进行我想要的任何更改。
所以这就是我所做的
#ifndef SMART_PTR_H_
#define SMART_PTR_H_
template<class T>
class smart_ptr {
T* data;
public: typedef T element_type;
explicit smart_ptr(T* ptr = NULL)
: data(ptr) {}
~smart_ptr() { delete data; }
T&
浏览 2提问于2021-06-18得票数 0
回答已采纳
12回答
C++规范指出，默认析构函数会删除所有非静态成员。然而，我无法做到这一点。
我有这个：
class N {
public:
~N() {
std::cout << "Destroying object of type N";
}
};
class M {
public:
M() {
n = new N;
}
// ~M() { //this should happen by default
// delete n;
// }
private:
N* n;
};
然后，它应该打印给
浏览 0提问于2010-03-09得票数 29
回答已采纳
下面是我的程序中的new/delete操作符的模式。Valgrind说，记忆“肯定是丢失了”。我不太清楚泄漏在哪里。我的new/delete操作符的用法有问题吗？
class Generic
{
GenericInterface *gInterface; //GenericInterface is abstract class
public:
Generic ()
{
gInterface = NULL;
}
~Generic ()
浏览 2提问于2011-01-29得票数 1
回答已采纳
2回答
class Class {
public:
Class() {std::cout << "Constructor" << '\n';}
~Class() {std::cout << "Destructor" << '\n';}
};
int main() {
std::cout<<"\nNew shared_ptr:\n";
Class C;
std::shared_ptr<Class&
浏览 2提问于2017-06-02得票数 1
2回答
我正在尝试创建一个像这样的系统，其中有一个窗口，该窗口有多个组件，例如标签(文本/图像)、文本框、复选框等等。swing的工作方式是有一个抽象的Component类，它有一个抽象的画图方法，它绘制组件，以及一些其他方法。实际窗口(JFrame)有一个(排序)窗口中所有组件的列表。这些组件的实际类型未知，但它们都扩展了Component类。
我的Window课程：
class Window {
public:
...
template<typename T, typename std::enable_if<std::is_base_of<Component, T
浏览 7提问于2015-06-08得票数 0
回答已采纳
3回答
C++析构函数内存泄漏
、、、
关于正确处理析构函数的相对简单的问题...
首先，我有一个类似这样的类：
class Foo {
public:
ReleaseObjects() {
for (std::map<size_t, Object*>::iterator iter = objects.begin(); iter != objects.end(); iter++) {
delete (*iter).second;
}
objects.clear();
}
private:
std::map<size_t
浏览 1提问于2011-10-19得票数 2
回答已采纳
3回答
我用一个名为cmysqldb的类制作了一个头文件，这个类有很多指针。我现在的问题是：
我如何创建一个析构函数来删除可能导致潜在内存泄漏的指针？
以下是头部代码：
#ifndef CMSYQLDB_H
#define CMSYQLDB_H
#include <QMultiMap>
#include <QStringList>
#include "mysql.h"
class cmysqldb
{
public:
cmysqldb::~cmysqldb()
{
const char *text,
MYSQ
浏览 2提问于2011-05-18得票数 0
回答已采纳
我正在尝试下面的示例：
class base // base class
{
public:
std::list<base*> values;
base(){}
void initialize(base *b) {
values.push_front(b);
}
virtual ~base()
{
values.clear();
cout<<"base called"<<endl;
}
};
class derived : public
浏览 0提问于2012-04-23得票数 4
3回答
我的问题很简单，但我在任何地方都找不到问题。
如果我有一个这样的类
class A {
vector<int> data;
}
当A的实例被销毁时，data也会被销毁吗?或者我应该为A编写一个析构函数来调用data的析构函数吗?基本上我担心当A的实例被销毁时，向量的动态内存是否不会被释放。我怀疑答案是data被正确地释放了，但我不想以一种艰难的方式发现我错了。
此外，如果A是一个结构，当data的本地实例超出作用域时，会调用A的析构函数吗？
浏览 3提问于2012-02-29得票数 15
回答已采纳
6回答
删除指针数组
、、、
delete[] a ( a是动态分配的指针数组)是否对数组中的每个指针执行delete？
我猜想，它对具有用户定义类的数组执行析构函数，但是指针发生了什么情况呢？
浏览 6提问于2014-02-12得票数 16
回答已采纳
我遇到这样一种情况:构造函数分配动态内存，如果构造函数中发生任何异常，它都不会释放动态分配的内存。为了避免这种情况，我使用了unique_ptr，它能够正确地释放内存。 为了展示这种情况，这里是一个用于该情况的虚拟代码。 class ExceptionInConstructor
{
unique_ptr<int> a;
public:
ExceptionInConstructor()
{
a = std::unique_ptr<int>( new int(10));
cout <<"Construc
浏览 18提问于2019-05-26得票数 1
2回答
我有一个没有析构函数的类和如下的构造函数：
class Foo {
public:
Foo(int a) : p(new int(a)) {}
private:
int *p;
};
{
Foo a(4);
}
在这段代码之后，会释放堆上分配的内存吗？还是必须显式提供这样的析构函数：
class Foo {
public:
Foo(int a) : p(new int(a)) {}
~Foo();
private:
int *p;
};
Foo::~Foo() {
delete p;
}
浏览 6提问于2021-11-22得票数 3
回答已采纳
5回答
我有一个关于析构函数的基本问题。
假设我有下面的类
class A
{
public:
int z;
int* ptr;
A(){z=5 ; ptr = new int[3]; } ;
~A() {delete[] ptr;};
}
现在，析构函数被认为是销毁对象的实例化。上面的析构函数正是在释放new分配的动态分配的内存时做到了这一点。
但是变量z又如何呢？如何手动销毁/释放z分配的内存？当类超出作用域时，它会自动销毁吗？
浏览 4提问于2012-01-12得票数 4
回答已采纳
3回答
我有一个对象指针的向量。我希望能够删除这些对象，并释放这些对象占用的内存。
我目前拥有的是这样的：
这是包含对象指针的向量：
std::vector<Ball*> List;
这是删除向量中的元素并释放内存的函数：
void BallManager::DeleteBall(int id)
{
List[id]->~Ball(); //Not sure if this is needed
delete List[id];
List[id] = NULL;
List.erase(List.begin()+id);
}
我的问题是，我是否也需要调用
浏览 3提问于2012-12-22得票数 1
回答已采纳
维基百科在中声称
D-指针是类的唯一私有数据成员，并指向结构的实例(由于其析构函数不可见，因此必须是POD )。
这在PIMPL和维基百科中并不是必需的，它通常是特殊的，不是吗？
我把缺少d指针标记作为我问题的答案，但希望有人能为维基百科做出贡献和/或澄清问题。或者说维基百科糟透了，万不得已等等:)
我问题的重点是，在cpp实现文件中完全声明和定义嵌套类的方法时，它们的可见性如何？其析构函数是否会按预期的方式被调用(包含类将在其析构函数中调用delete )？
_EDIT_固定版本，
浏览 5提问于2011-08-23得票数 0
回答已采纳
4回答
如果我做了
Bat::Bat() : m_member_str(new std::string("Am I freed?"))
{
throw std::runtime_error("oops");
}
是否释放了newly分配的std::string？我在想可能是因为破坏者没有被调用。
我使用的不是std::string，而是我自己的类，只是将它作为一个简单的示例来展示。
浏览 4提问于2011-12-28得票数 5
回答已采纳
如果我有一个std::vector的东西(比如说，std::vector::clear()调用内容的析构函数吗？例如，如果我有一个数据作为向量，下面的代码是否有效？
char * pd;
for(vector<char *>::iterator it = data.begin(); it != data.end(); ++it) {
pd = *it;
delete pd;
}
或者，它是否像data.clear()那样是多余的？我认为不需要，即需要手动重新分配内容。我假设data.clear()不会为内容调用隐式析构函数？这是正确的吗？这是针对pre C++11的。
浏览 12提问于2014-03-28得票数 22
2回答
当我创建一个对象时，我的编译器会自动创建一个构造函数、析构函数和一个赋值操作符。我应该在什么时候自己实现它们？
浏览 12提问于2021-05-04得票数 0
1回答
我正在尝试在双向链表(大学任务)中实现智能指针。在此之前，我已经用纯C语言用原始指针完成了同样的任务。问题是，当我通过addNode()将新节点添加到列表中超过两次时，我会崩溃(我使用CodeLite(g++)，Windows1064位)。我假设问题出在我的内存管理上( Node和List的析构函数)。但我觉得我没有足够的资格来解决这个问题。因此，任何帮助都将不胜感激。
#include <stdlib.h>
#include <iostream>
#include <memory>
using namespace std;
template <t
浏览 16提问于2017-12-20得票数 1
回答已采纳
5回答
我有一个指向一个对象的指针向量(我将它们作为指针，因为我将大量地占据周围的位置，我可以想象只交换指针，而不是交换整个对象会快得多。
不管怎样，我最终需要删除向量，但它所指向的对象仍然需要有效。文档似乎说它将在向量中的每个对象上调用析构函数。当它是一个对象数组时，这是有意义的，但是如果该数组是指向对象的指针数组，那么指针所指向的对象是否也会被删除，或者我是否需要手动删除它们？
如果它们被自动删除，那么保留对象的唯一方法(假设它们在不同的矢量中使用)是不是实际上将对象复制到另一个位置，并使矢量中的指针指向这些对象(而不是原始对象)？
谢谢。
浏览 0提问于2011-01-18得票数 2
回答已采纳
5回答
为什么我可以在免费存储上创建具有私有析构函数的类的对象，但不能在堆栈上创建？
例如，这是非法的：
class Foo
{
public:
explicit Foo( int );
static void delete_foo(Foo* foo ) { delete foo; }
private:
int x;
~Foo();
Foo( const Foo& );
Foo& operator=(const Foo& );
};
int main()
{
Foo * fooptr = new Foo(5); // legal
浏览 0提问于2011-02-07得票数 15
3回答
如果我在对象的构造函数中使用new分配内存，并且在抛出异常之后立即抛出异常，是否会泄漏内存？
对象根本不应该被构造，因此不会调用析构函数，但是内存呢？
例如：
MyObject() {
data = new char[200]; // Will this be leaked?
if(something_is_wrong)
throw exception();
}
浏览 2提问于2014-06-12得票数 4
3回答
这似乎是一个微不足道的问题，或者至少是一个常见的问题，但我在谷歌或其他网站上找不到令人满意的答案。
我不确定什么时候应该为我的类实现析构函数。
一个明显的情况是，当类封装到文件的连接时，我希望确保连接是关闭的，所以我在析构函数中关闭它。
但是我想知道总的来说，我怎么知道我是否应该定义一个析构函数。有什么指导方针，我可以检查，看看我是否应该在这个类中有一个析构函数？
我能想到的一个这样的指导方针是，类是否包含任何成员指针。默认析构函数会在删除时破坏指针，但不会破坏它们所指向的对象。因此，这应该是用户定义的析构函数的工作。例句：(我是C++新手，所以这段代码可能不会编译)。
class MyCon
浏览 7提问于2014-10-07得票数 12
回答已采纳
据我所知，我应该在析构函数中销毁我用new创建的所有内容，并关闭打开的文件流和其他流。但是，我对C++中的其他对象有一些疑问：
std::vector和std::string：它们是自动销毁的吗？
如果我有这样的东西
std::vector<myClass*>
指向课堂的指针。当向量析构函数被调用时会发生什么？
它会自动调用myClass的析构函数吗？或者只有向量被销毁，但是它所包含的所有对象仍然存在于内存中？
如果我有指向类内另一个类的指针，例如：
A类{B*B类；}
A类在代码中的某个点被销毁。B类也会被销毁，还是仅仅是指针和B类仍然存在于内存中的某个地方？
浏览 6提问于2012-08-22得票数 53
回答已采纳
2回答
C++中不必要的破坏
、、、、
我有以下代码：
class A;
typedef map<string, A*> AMap;
AMap _amap;
当我尝试分配一个新的A并将它保存到映射时：
A a = A(str);
_amap[str] = &a;
然后它将在我的程序结束之前调用A的析构函数(我有一个静态成员A来计数对象，当我想检查有多少对象时，它返回零)。
然而，当我尝试：
_amap[str] = new A(str);
一切正常，但破坏者没有被调用。为什么会这样呢？
这两种方法有什么区别？
谢谢。
更新
我之所以使用A*而不是A，是因为我有另一个AList，它是一个向量，将存储相同的对象。我使
浏览 1提问于2014-09-27得票数 2
回答已采纳
在C++编程语言中，有以下示例(3.2.4节)。
unique_ptr<Shape> read_shape(istream& is);
void user()
{
vector<unique_ptr<Shape>> v;
while (cin)
v.push_back(read_shape(cin));
draw_all(v);
// call draw() for each element
rotate_all(v,45);
// call rotate(45) for each e
浏览 9提问于2020-10-13得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
