Comment insérer une paire de std::pair à l'intérieur d'une std::pair?

Je suis la déclaration d'une carte de la chaîne pour une paire de paires comme suit:

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

Et je l'initialiser comme:

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)));

Toutefois, Visual C++ me donne l'erreur "C2664, Aucun constructeur peut prendre le type de source, ou de surcharge du constructeur de résolution a été ambigu".

Je suis nouveau à l'aide de modèles et STL et je ne peux pas dire ce que je fais mal.

Veuillez utiliser typedef et std::make_pair pour le rendre lisible.
J'ai reformaté pour en faire un peu plus facile sur les yeux.
Au lieu de nidification toutes ces std::pair s ne pouvais pas vous passer de l'un à l'aide de std::tr1::tuple? Boost est un n-uplet de mise en œuvre.
Yo yo Dawg. Je vous ai entendu comme std::pair, je l'ai donc mis un std::pair dans votre....
Comme je comprends le tuple n'est pas mis en œuvre par tous les fournisseurs. Je suis en train d'apprendre STL première avant de passer à Boost.

OriginalL'auteur Fábio | 2010-09-28

  1. 17

    La >>> ne peut pas être analysé correctement (sauf si vous avez un compilateur C++0x).

    Changement de > > >

    Ce:

    reference.insert("First",

    Devrait être:

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

    Il y a aussi une fonction d'utilité de faire la construction des paires est plus facile:

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

    Peut être:

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

    Essayez ceci:

    reference[L"First"]
    = std::make_pair(std::make_pair(-1L,-1L),std::make_pair(0L,0L));
    Merci pour l'aide. J'ai édité ma question d'ajouter de la L"" à mon wstring de faire de la question plus facile à "analyser".
    Une meilleure réponse que la mienne, mais note que l'insertion avec reference[key] = value peut donner des comportements différents à reference.insert(make_pair(key,value)); à l'aide de [] va remplacer un élément existant, tout en insert ne sera pas.

    OriginalL'auteur Martin York

  2. 2

    C++ devient confus par l'consécutifs ">" lorsque vous fermez le modèle qu'il considère comme l'opérateur de décalage.

    Ajouter des espaces entre la clôture des modèles, modifier >>> > > >

    Aussi, GMan conseils.

    OriginalL'auteur iniju

  3. 2

    map::insert lui-même ne prend qu'un seul std::pair argument, plutôt que de deux arguments. Vous pouvez ranger le code à l'aide de std::make_pair (qui déduit le modèle des arguments, les arguments de la fonction), pour obtenir quelque chose comme:

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

    OriginalL'auteur Mike Seymour

  4. 0

    Vous pouvez simplifier votre code par la création d'une fonction d'assistance afin de créer des paires de paires, analogue à la std::make_pair fonction d'assistance qui est disponible dans la bibliothèque standard. Également utiliser les cartes operator[] pour une insertion plus facile à lire le code:

    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);

    OriginalL'auteur sth

  5. 0

    Il permet d'utiliser typedefs lors du débogage de ce genre de chose. 

    //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;
}
    Il n'est pas insert() la fonction que l'OP essaie de l'utiliser, même si vous #include <string>. L'exemple de code que vous avez posté fonctionne et il est tout à fait lisible, mais parce que vous avez remplacé le insert(), non pas parce que de l'inclure comme vous semblez le dire...
    Si vous retirez le "vous avez juste besoin <string>", qui, je pense, est quelque peu trompeur, je pense que c' est utile et serait upvote.
    ok, vous l'avez. Je ne sais pas si vous vous rendez compte que vous avez écrit "l'opérateur[] pour une insertion plus facile à lire le code" dans votre réponse. Comme vous le dites, insérer n'existe pas!
    Ouais je me rends compte que et j'ai vu votre réponse après la publication de la mine et de la pensée "qui a downvoted cela, l'opérateur[] est le chemin à parcourir!". Puis je me suis confus par le <string> choses et s'en alla à essayer si peut-être effectivement, il manque des constructeur pour wstring(const char*) ou tel produit un message d'erreur comme dans la question. Je ne pouvais pas reproduire quelque chose comme ça, donc j'ai décidé de faire des commentaires. (+1)

    OriginalL'auteur ttt