Cómo insertar un par de std :: pair dentro de otro std :: pair?

Question

Estoy declarando un mapa de cadena a un par de pares de la siguiente manera:

std::map<std::wstring, 
     std::pair<std::pair<long, long>, 
        std::pair<long, long>>> reference; 

Y inicializarlo como:

reference.insert(L"First", 
       std::pair<std::pair<long, long>, 
          std::pair<long, long>>(std::pair<long, long>(-1, -1), 
          std::pair<long, long>(0, 0))); 

Sin embargo, Visual C++ me da el error "C2664, n constructor podría tomar el tipo de fuente, o la resolución de sobrecarga del constructor era ambigua ".

Soy nuevo en el uso de plantillas y STL y no puedo decir lo que estoy haciendo mal.

Answer 1

El >>> no se puede analizar correctamente (a menos que tenga un compilador C++ 0x).

Cambio a > > >

Este:

reference.insert("First", 

debe ser:

reference.insert(L"First", 
       ^^^ 

También hay una función de utilidad para hacer la construcción de pares más fácil: las

std::pair<std::pair<long, long>, std::pair<long, long>>(std::pair<long, long>(-1, -1), std::pair<long, long>(0, 0)) 

puede ser:

std::make_pair(std::make_pair(-1L,-1L),std::make_pair(0L,0L)) 

Prueba esto:

reference[L"First"] 
    = std::make_pair(std::make_pair(-1L,-1L),std::make_pair(0L,0L)); 

Answer 2

C++ se confunde por la consecutiva ">" cuando se cierra la plantilla, ya que interpreta que como el operador de desplazamiento.

añadir espacios entre el cierre de las plantillas, el cambio a >>>>>>

Answer 3

map::insert en sí toma un solo argumento std::pair, en lugar de dos argumentos. Puede poner en orden el código mediante el uso de std::make_pair (que infiere los argumentos de plantilla de los argumentos de la función), para obtener algo como:

reference.insert(std::make_pair("First", 
           std::make_pair(std::make_pair(-1L,-1L), 
               std::make_pair(0L,0L)))); 

Answer 4

Ayuda a utilizar typedefs al depurar este tipo de cosas.

// test1.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 

#include <map> 
#include <string> 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    typedef std::pair<long, long> ElementType; 
    typedef std::pair<ElementType, ElementType> ValueType; 
    typedef std::wstring KeyType; 
    std::map<KeyType, ValueType> reference; 

    KeyType key = L"First"; 
    reference[key] = ValueType(ElementType(-1, -1), ElementType(0, 0)); 

    return 0; 
} 

Answer 5

Se podría simplificar el código mediante la creación de una función de ayuda para crear pares de pares, análogo a la función std::make_pair de ayuda que está disponible en la biblioteca estándar. También el uso de los mapas para operator[] resultados de inserción en el código más fácil de leer:

template<typename T, typename U, typename V, typename W> 
std::pair< std::pair<T,U>, std::pair<V,W> > make_pair_pair(T t, U u, V v, W w) { 
    // using std::make_pair instead of the constructor for better readability 
    return std::make_pair(std::make_pair(t, u), std::make_pair(v, w)); 
} 

reference[L"First"] = make_pair_pair(1,2,3,4);