标签: stdmap

我一直以为代码如下

std::map<int, int> test;
std::cout << test[0] << std::endl;

会打印随机值,因为它会在map中创建单位化值.但是,事实证明,创建的int实际上总是初始化为零,并且标准内置类型在某些情况下也是零初始化的.

问题是:当对标准类型(int/char/float/double/size_t)执行零初始化时？我很确定,如果我int i;在不知名的地方宣布,它将包含随机数据.

PS问题是关于C++ 03标准.问题的原因是,现在我不再确定何时必须为内置类型(如int/float/size_t)提供初始化,或者可以安全地省略它.

我有一个boost::ptr_map存储抽象基类(例如VectorWrapperBase)作为值,这允许我将字符串映射到不同类型的向量.

boost::ptr_map<std::string, VectorWrapperBase> memory_map;
//...
memory_map.insert(str_key, new VectorWrapper<T>());

这似乎有效.但是,当我memory_map作为另一个类的成员并尝试将该类存储在一个中时std::map,编译失败.

class AgentMemory {
  //...
  private:
    boost::ptr_map<std::string, VectorWrapperBase> memory_map;
};

std::map<std::string, AgentMemory> agent_map;
//...
agent_map.insert(std::pair<std::string, AgentMemory>(agent_name, AgentMemory()));

最后一行失败了:

/SOMEPATH/boost_1_48_0/boost/ptr_container/clone_allocator.hpp:34
   error: cannot allocate an object of abstract type ‘xyz::VectorWrapperBase’

作为C++的新手,这是令人费解的.

我怀疑错误是由于地图插入复制了AgentMemory涉及克隆的对象ptr_map.由于我的VectorWrapper对象不可复制,因此会引发错误.

我的问题是:

• 为什么我收到错误？(我的怀疑是否接近实际发生的事情？)
• 我该如何解决这个问题？

为了解决编译错误,我考虑了以下内容,但是没有太多C++经验无法确定哪个更合适:

1. 删除纯说明符(= 0),因此VectorWrapperBase不再是抽象的
   • 这感觉就像一个黑客,因为VectorWrapperBase永远不应该被实例化
2. 使VectorWrappers 可以复制
   • 这似乎有效,但在我的用例中,只有空容器被分配给顶层映射,因此内部的VectorWrappers ptr_map永远不会被克隆.因此,克隆性只是为了安抚编译器而不反映实际用法.
3. 忘记ptr_map并使用一个std::map而 …

我有一个名为'Card'的类,我试图将它的一些对象存储在std :: map Card.hpp中:

class Card
{
public:
    enum ValueType { NOVALUE, ACE };
    enum FaceType { NOFACE, CLUBS };

    Card(const ValueType & _value, const FaceType & _face);
    Card(const Card & _card);
private:
    ValueType m_value;
    FaceType m_face;
};

以下是我存储和访问它的方法:Deck.hpp:

#include <map>

class Card;

class Deck
{
    public:
        Deck();

        std::size_t length() const;

        Card get_card(const int & _num);

    private:
        std::map<int, Card> m_deck;
};

Deck.cpp:

#include "Card.hpp"

Deck::Deck()
{
    m_deck.insert(std::pair<int, Card>(0, Card(Card::NOVALUE, Card::NOFACE)));
    m_deck.insert(std::pair<int, Card>(1, Card(Card::ACE, Card::CLUBS)));
}
std::size_t Deck::length() const
{
    return …

const有问题.说我有:

class A{
    friend std::ostream& operator<<(std::ostream& os,const A& myObj);

   private:
    std::map<int,int> someMap;
    int someInteger;
 };
 std::ostream& operator<<(std::ostream& os,const A& myObj){
  os<<myObj.someInteger<<std::endl;
  os<<myObj.someMap[0]<<std::endl;
  }

由于与地图的const冲突,这种代码在编译时会产生错误(如果我注释打印地图值的行一切都很好),如果我摆脱了函数原型中的'const',一切都很好.我真的没有看到问题在哪里..

有什么帮助吗？

我一直在和我一起工作<map>,在那里我宣布了一张地图

map <int, vector<int> > tree;

我正在尝试为它赋值.我的目标是将多个值作为其键的元素.像这样的东西:

0=null
1=>0
2=>1,0
3=>2,1,0
4=>3,2,1,0
5=>0

我试图像这样分配到地图但它不起作用.

tree[3]=vector<int>(2,1,0);

你能弄清楚问题出在哪里,或者我如何创建一个兼容Python字典的函数？

编辑:<map> 以上2种分配工作方式.

编辑2:我没有使用 <map>

我可以访问(不锁定)std :: map条目而另一个线程插入/删除entrys吗？

示例伪C++:

typedef struct {
   int value;
   int stuff;
}some_type_t;

std::map<char,some_type_t*> my_map;   

//thread 1 does:
my_map.at('a')->value = 1;

//thread 2 does:
some_type_t* stuff = my_map.at('b');

//thread 3 does:
my_map.erase('c');

//I'm not modifying any elements T is a pointer to an previously allocated "some_type_t" 

std C++ 11说所有成员都应该是线程安全的(erase()不是const).

我正在寻找一些关于如何实现与a一起使用的自定义分配器的指针std::map.我有兴趣用数百万个条目填充地图而不为容器中的每个元素分配(这是此容器的默认值).这样做的原因是将数据传递给使用地图存储图表样本的第三方库(QCustomPlot),并且在绘制大型时间序列时我感觉性能受到影响.

如果std::map事先已知大小,是否可以通过一次分配来完成此操作？

编辑:节点将按升序输入容器.

我想在其他地图中锁定键/索引,如下所示:

std::map<int, boost::mutex> pointCloudsMutexes_;
pointCloudsMutexes_[index].lock();

但是,我收到以下错误:

/usr/include/c++/4.8/bits/stl_pair.h:113: error: no matching function for call to 'boost::mutex::mutex(const boost::mutex&)'
       : first(__a), second(__b) { }
                               ^

它似乎可以使用std::vector,但不是std::map.我究竟做错了什么？

在linux和Visual Studio 2015中编译后,以下代码的行为有所不同.

#include <map>
#include <iostream>
using namespace std;

int main(void)
{
    map<int, int> map1;
    int keyCount = 2;

    for (int i = 0; i < keyCount; i++)
    {
        map1[i] = map1.size();
    }

for (auto value : map1) 
    {
        cout << "key: " << value.first << " value: " << value.second << endl;
    }
return 0;
}

Visual Studio中的结果:

key: 0 value: 0
key: 1 value: 1

用g ++ -std = c ++ 11 -Wall -pedantic编译linux的结果

key: …

我和一位同事正在讨论成员与非成员职能的相对优点.出现了一个问题:为什么std::map会有find成员函数.

我的回答是,尽管您可以std::find在地图上使用,但您必须搜索键值对,或使用find_if和例如lambda.但是,这是线性的,并且map.find在线性时间内提供了按键搜索.我最后断言,如果它可能是一个非成员,那么它本来就是!(虽然,std :: string表明我的概括可能有些仓促).

我的同事指出,可以采用find与非成员函数相同的方式实现map.lower_bound.

是否有一个理由map.find已经制成的零件？