web-dev-qa-db-fra.com

Équivalent C # de la carte C++ <chaîne, double>

Je veux garder quelques totaux pour différents comptes. En C++, j'utiliserais STL comme ceci:

map<string,double> accounts;

// Add some amounts to some accounts.
accounts["Fred"] += 4.56;
accounts["George"] += 1.00;
accounts["Fred"] += 1.00;

cout << "Fred owes me $" << accounts['Fred'] << endl;

Maintenant, comment pourrais-je faire la même chose en C #?

c#arrayshashmap
55
Adam Pierce

Grossièrement:-

var accounts = new Dictionary<string, double>();

// Initialise to zero...

accounts["Fred"] = 0;
accounts["George"] = 0;
accounts["Fred"] = 0;

// Add cash.
accounts["Fred"] += 4.56;
accounts["George"] += 1.00;
accounts["Fred"] += 1.00;

Console.WriteLine("Fred owes me ${0}", accounts["Fred"]);
79
ljs
Dictionary<string, double> accounts;
16
Daniel A. White

Bien que System.Collections.Generic.Dictionary corresponde à la balise "hashmap" et fonctionne correctement dans votre exemple, ce n'est pas un équivalent exact de std :: map - std :: map de C++ est une collection ordonnée.

Si la commande est importante, vous devez utiliser SortedDictionary .

11
user200783

Vous voulez le Dictionary class.

4
Daniel Pryden

Le dictionnaire est le plus courant, mais vous pouvez utiliser d’autres types de collections, par exemple. System.Collections.Generic.SynchronizedKeyedCollection, System.Collections.Hashtable ou toute autre collection KeyValuePair

2
Jim Schubert

Ce code est tout ce dont vous avez besoin:

   static void Main(string[] args) {
        String xml = @"
            <transactions>
                <transaction name=""Fred"" amount=""5,20"" />
                <transaction name=""John"" amount=""10,00"" />
                <transaction name=""Fred"" amount=""3,00"" />
            </transactions>";

        XDocument xmlDocument = XDocument.Parse(xml);

        var query = from x in xmlDocument.Descendants("transaction")
                    group x by x.Attribute("name").Value into g
                    select new { Name = g.Key, Amount = g.Sum(t => Decimal.Parse(t.Attribute("amount").Value)) };

        foreach (var item in query) {
            Console.WriteLine("Name: {0}; Amount: {1:C};", item.Name, item.Amount);
        }
    }

Et le contenu est:

Nom: Fred; Montant: 8,20 R $;
Nom: John; Montant: 10,00 R $;

C'est la manière de faire cela en C # - de manière déclarative!

J'espère que ça aide, 

Ricardo Lacerda Castelo Branco

2
Ricardo Lacerda Castelo Branco

Alors que nous parlons de STL, de cartes et de dictionnaire, je vous recommande de jeter un coup d’œil à la bibliothèque C5 . Il propose plusieurs types de dictionnaires et de cartes que j'ai souvent trouvés utiles (ainsi que de nombreuses autres structures de données intéressantes et utiles). 

Si vous êtes un programmeur C++ qui passe à C # comme moi, vous trouverez que cette bibliothèque est une excellente ressource (et une structure de données pour ce dictionnaire).

-Paul

1
Paul

L'équivalent le plus proche de C++ std::map<> (une arborescence interne) est C # OrderedDictionary<> (une arborescence interne), alors que C # OrderedDictionary<> manque certaines méthodes très importantes de C++ std::map<>, à savoir: std::map::find, std::map::lower_bound, std::map::upper_bound, std::map::equal_range et std::mapiterators, qui sont essentiellement l'épine dorsale pour les 4 méthodes précédentes.

Pourquoi ces 4 méthodes sont-elles importantes? Parce que cela nous donne la possibilité de localiser la "localisation" d'une clé donnée, en plus de pouvoir uniquement vérifier si une clé existe, ou si l'ordre de SortedDictionary est garanti.

Qu'est-ce qu'une "localisation" d'une clé dans un std::map? La clé ne doit pas nécessairement exister dans la collection, nous voulons connaître l'emplacement de la clé, généralement entre deux itérateurs pointant vers deux clés adjacentes existantes dans la collection, afin que nous puissions agir dans la plagela clé entre dans une complexité O(logN). Sans ces 4 méthodes (avec les itérateurs), il est nécessaire d'effectuer une itération O(N) à travers la collection chaque fois qu'une plage est interrogée sur une clé.

0
Dejavu