我有一个复杂的结构,我希望将其作为std :: map的一个关键字来快速生成所有唯一对象的列表:

union somecomplexstruct {
     struct {
        more_structs val1, val2;
        even_more_structs val3, val4;
        lots_of_more_structs val5;
     };
     unsigned int DATA[3];
};

typedef map<somecomplexstruct, int, greater<somecomplexstruct> > somecomplexstructMap;

但它说错误: error C2784: 'bool std::operator >(const std::vector<_Ty,_Alloc> &,const std::vector<_Ty,_Alloc> &)' : could not deduce template argument for 'const std::vector<_Ty,_Alloc> &' from 'const somecomplexstruct'

我如何使我的结构在那里工作？

编辑:得到它的工作,感谢大家!下面是代码:

inline bool operator>(const somecomplexstruct &v1, const somecomplexstruct &v2){
    if(v1.DATA[0] > v2.DATA[0]) return 1;
    if(v1.DATA[0] < v2.DATA[0]) return 0;
    if(v1.DATA[1] > v2.DATA[1]) return 1;
    if(v1.DATA[1] < v2.DATA[1]) return …

我试图转发一些参数来进行对象的原位构造.我不太了解在关联容器中使用emplace背后的基本原理,或者我可能只是以错误的方式使用/思考.如果有人可以共享代码片段以供使用,那将会很棒.

像map这样的关联容器总是存储一个kind对()的对象,而emplace函数表示它会通过转发参数来调用存储的对象的构造函数(对于map的情况总是成对).那么即使函数具有可变参数签名,我们是否仅限于提供两个参数(键,值)？

当我使用增强容器的emplace之前我可以传递如下的参数:emplace(arg1,arg2,arg3,arg4)//其中arg2,arg3,arg4用于构造对象而arg 1是关键.

当用新的gcc-4.6和c ++ 11编译时,这会打破但现在我必须做类似的事情:emplace(arg1,myobj(arg2,arg3,arg4)); //使相同的代码工作;

所以新的安卓不会像升级那样做任何明智的结构吗？我是否限制只为地图提供2个参数,因为对将始终为其构造函数接受两个参数.

我有一个映射,其中pair作为键,第三个整数作为值.我想知道如何迭代键.示例代码粘贴在下面.

#include <iostream>
#include <map>
#include <algorithm>

using namespace std;

int main ()
{
  map <pair<int, int>, int> my_map;
  pair <int, int> my_pair;

  my_pair = make_pair(1, 2);
  my_map[my_pair] = 3;

  // My attempt on iteration
  for(map<pair<int,int>,int>::iterator it = my_map.begin(); it != my_map.end(); ++it) {
    cout << it->first << "\n";
  }

  return 0;
}

我在一个旧程序中偶然发现了一些奇怪的行为,并弄清楚为什么G ++和CLang ++允许它发生.我在main()之前声明并初始化了一些全局变量.奇怪的是它们是通过静态std :: map初始化的,它使用下标运算符同时填充.一旦main()运行,一切似乎都在正确的位置,地图的大小显示正确的填充项数以及包含main()之前显示的值的变量.

#include <map>
#include <iostream>

static std::map<int, const char*> staticMap;

const char* const a = staticMap[0] = []()->const char* {return "a";}();
const char* const b = staticMap[1] = []()->const char* {return "b";}();
const char* const c = staticMap[2] = []()->const char* {return "c";}();
const char* const d = staticMap[3] = []()->const char* {return "d";}();
const char* const e = staticMap[4] = []()->const char* {return "e";}();

int main() {
    std::cout << "# Items: " << staticMap.size() << …

问题

我有一个std::map<int, std::set<int>>名为misi. 我想知道为什么misi.emplace(2345, {6, 9});并且misi.emplace({2345, {6, 9}});没有按预期工作，如下所示。

编码

#include <set>          // std:set
#include <map>          // std::map
#include <utility>      // std::piecewise_construct, std::pair
#include <tuple>        // std::forward_as_tuple
#include <iostream>     // std::cout, std::endl

int main()
{
    // --- std::set initializer list constructor ---
    std::set<int> si({42, 16});
    std::cout << "si.size(): " << si.size() << std::endl;       // 2
    std::cout << "*si.begin(): " << *si.begin() << std::endl;   // 16

    // --- std::set emplace() ---
    si.emplace(7);
    std::cout << …

给定一个键是整数的 C++ 映射（或多映射），是否可以使用 STL 请求键是给定数字以下最大数字的元素范围？

所以如果我有：

map = {{1,'x'}, {2, 'g'}, {3, 'n'}, {3, 'm'}, {4, 'z'}, {5, 'a'}}

我想在 4 之前找到元素，它会返回：

{{3, 'n'}, {3, 'm'}}

（我更感兴趣，std::map但也保留了一般问题std::multimap）。

我有一个const std :: map <int,std :: string>初始化如下:

const std::map< int, std::string > firstMap = {
    { 1, "First" },
    { 2, "Second"}
};

然后我想制作另一个const std :: map,它使用第一个映射作为其初始值的一部分,并且还扩展了原始数据.所以我想这会是类似的东西:

const std::map< int, std::string > secondMap = {
    { <firstMap>},
    { 3, "Third"}
};

这样第二个映射就有三对.这可能吗？

编辑:这些地图也被宣布为extern.

我观察到std :: map :: const_iterator泄漏了对value_type的非const引用:

#include <map>
#include <stdio.h>

int main (int argc, char *argv[])
{
  std::map<int,int> foo = {{1,1},{4,2}};
  const auto &m = foo;
  const auto &it = foo.find(1);
  printf("%d %d\n", it->first, it->second);
  int &i = it->second;
  i = 3;
  auto &one = foo.at(1);
  printf("%d %d\n", 1, one);
  return 0;
}

输出

$ g++ test.cc && ./a.out 
1 1
1 3

这是预期的吗？为什么？编写std :: map的const-protection的唯一方法是将它包装在另一个类中吗？

我正在尝试将指针对象插入到map通过emplace()但它不起作用.

我在下面创建了一个简单的问题表示.我正在尝试插入newFooList指针对象类型Foo*.

我似乎找不到为FooMap*in 创建类型的方法std::map<int, FooMap*> m_fooMapList.是否应该使用new地图的第二个字段？

#include <iostream>
#include <utility>
#include <stdint.h>
#include <cstdlib>
#include <map>

class Foo
{
    private:
        int m_foobar;
    public:
        Foo(int value)
        {
            m_foobar = value;
        }
        void setfoobar(int value);
        int getfoobar();
};

class FooMap
{
    private:
        std::map<int, Foo*> m_newFoo;

    public:
        FooMap() = default;
};

class FooMapList
{
    private:
        std::map<int, FooMap*> m_fooMapList;
    public:
        FooMapList() = default;
        void insertFoo(Foo* newFooObj);
};

int Foo::getfoobar(void)
{ …

Cppreference 给出std::forward_as_tuple了以下示例（请参见此处）

#include <iostream>
#include <map>
#include <tuple>
#include <string>

int main()
{
     std::map<int, std::string> m;

     m.emplace(std::piecewise_construct,
               std::forward_as_tuple(10),
               std::forward_as_tuple(20, 'a'));
     std::cout << "m[10] = " << m[10] << '\n';

     // The following is an error: it produces a
     // std::tuple<int&&, char&&> holding two dangling references.
     //
     // auto t = std::forward_as_tuple(20, 'a');
     // m.emplace(std::piecewise_construct, std::forward_as_tuple(10), t);
}

简单写有什么好处

 m.emplace(std::make_pair(20,std::string(20,'a')));