C++ c++；对堆对象的引用？

我有以下代码：

map<int,int>& myMap = new map<int,int>();

map&myMap=newmap（）；

但我得到以下编译器错误：

no suitable constructor exists to convert from "std::map<int,int, std::less<int>, std::allocator<std::pair<const int, int>>>*" to "std::map<int,int, std::less<int>, std::allocator<std::pair<const int, int>>>".

不存在合适的构造函数将“std:：map*”转换为“std:：map”。

这是否意味着我必须：

map<int,int>& myMap = *new map<int,int>();

map&myMap=*newmap（）；

我认为对象可以传递到引用而不必首先去引用（与指针相反）？我也知道存在智能指针，但我现在不打算使用它们。

您可以使用

map<int,int>& myMap = *new map<int,int>();

这是低质量的代码，国际海事组织

如果需要动态分配内存，请使用智能指针

std::shared_ptr<map<int,int>> ptr = new map<int,int>();

std:：shared_ptr ptr=new map（）；

如果需要使用引用，可以使用：

map<int,int>& myMap = *ptr;

map&myMap=*ptr；

如果您可以完全避免动态分配对象，并使用自动对象（堆栈内存中的对象），则效果会更好

map-myMap；

---

更新，回应OP的评论 你在评论中说

---

是的，我想保留那个引用，因为我要把它传递给一个递归函数

处理它的C++方法是通过引用传递一个对象。

void recursive_foo(std::map<int, int>& myMap)
{
}

void foo_user()
{
   std::map<int, int> myMap;
   // Fill up myMap
   // ...

   recursive_foo(myMap);
}

void递归函数（std:：map和myMap）
{
}
void foo_user（）
{
std：：map myMap；
//填写我的地图
// ...
递归_-foo（myMap）；
}

如果递归函数不修改对象，则可以按照标准库使用的习惯用法使用迭代器

void recursive_foo(std::map<int, int>::iterator start,
                   std::map<int, int>::iterator end)
{
}

void foo_user()
{
   std::map<int, int> myMap;
   // Fill up myMap
   // ...

   recursive_foo(myMap.begin(), myMap.end());
}

void recursive\u foo（std:：map:：iterator start，
标准：：映射：：迭代器（结束）
{
}
void foo_user（）
{
std：：map myMap；
//填写我的地图
// ...
递归_-foo（myMap.begin（），myMap.end（））；
}

您可以使用

map<int,int>& myMap = *new map<int,int>();

这是低质量的代码，国际海事组织

如果需要动态分配内存，请使用智能指针

std::shared_ptr<map<int,int>> ptr = new map<int,int>();

std:：shared_ptr ptr=new map（）；

如果需要使用引用，可以使用：

map<int,int>& myMap = *ptr;

map&myMap=*ptr；

如果您可以完全避免动态分配对象，并使用自动对象（堆栈内存中的对象），则效果会更好

map-myMap；

---

更新，回应OP的评论 你在评论中说

---

是的，我想保留那个引用，因为我要把它传递给一个递归函数

处理它的C++方法是通过引用传递一个对象。

void recursive_foo(std::map<int, int>& myMap)
{
}

void foo_user()
{
   std::map<int, int> myMap;
   // Fill up myMap
   // ...

   recursive_foo(myMap);
}

void递归函数（std:：map和myMap）
{
}
void foo_user（）
{
std：：map myMap；
//填写我的地图
// ...
递归_-foo（myMap）；
}

如果递归函数不修改对象，则可以按照标准库使用的习惯用法使用迭代器

void recursive_foo(std::map<int, int>::iterator start,
                   std::map<int, int>::iterator end)
{
}

void foo_user()
{
   std::map<int, int> myMap;
   // Fill up myMap
   // ...

   recursive_foo(myMap.begin(), myMap.end());
}

void recursive\u foo（std:：map:：iterator start，
标准：：映射：：迭代器（结束）
{
}
void foo_user（）
{
std：：map myMap；
//填写我的地图
// ...
递归_-foo（myMap.begin（），myMap.end（））；
}

我认为对象可以传递到引用而不必首先去引用（与指针相反）

是的，可以传递对象，但您在这里拥有：

map<int,int>& myMap = new map<int,int>();

这并不意味着您必须将变量声明为引用才能将其传递到此处，您可以传递自动对象：

 sometype auto_object;
 func( auto_object );

或通过动态分配的一个：

 sometype *ptr_to_object = new sometype;
 func( *ptr_to_object );
 delete ptr_to_object; // or better use smart pointer

若您不需要这个对象在您使用它的范围之外生存，那个么最好使用第一个变量

我认为对象可以传递到引用而不必首先去引用（与指针相反）

是的，可以传递对象，但您在这里拥有：

map<int,int>& myMap = new map<int,int>();

这并不意味着您必须将变量声明为引用才能将其传递到此处，您可以传递自动对象：

 sometype auto_object;
 func( auto_object );

或通过动态分配的一个：

 sometype *ptr_to_object = new sometype;
 func( *ptr_to_object );
 delete ptr_to_object; // or better use smart pointer

---

如果您不需要此对象在使用它的范围之外生存，则最好使用第一个变量。

只需使用

map myMap你能解释一下你为什么要这样做吗：
map&myMap=newmap（）；这很奇怪，感觉像是XY问题？@RichardCritten看起来OP有Java背景，并试图修复
map&myMap@Slava我同意，但如果没有OP的澄清，我所能做的就是推荐书单：只需使用
map myMap你能解释一下你为什么要这样做吗：
map&myMap=newmap（）；这很奇怪，感觉像是XY问题？@RichardCritten看起来OP有Java背景，并试图修复
map&myMap
@Slava我同意，但如果没有OP的澄清，我所能做的就是推荐书单：我认为OP根本不需要动态分配内存，我打赌它是来修复
map&myMap；的编译错误的给新手程序员。后来有人会注意到这种丑陋，并用自动对象“修复”它，可能会留下
delete&myMap在代码中。应正确维护数据类型。@Fancypants753，不要按值传递。通过引用传递。我认为OP根本不需要动态分配内存，我打赌它来修复
map&myMap给新手程序员。后来有人会注意到这种丑陋，并用自动对象“修复”它，可能会留下
delete&myMap在代码中。应正确维护数据类型。@Fancypants753，不要按值传递。参照