Vous amène à en savoir plus sur la carte (paires clé-valeur) et l'ensemble (collection) en C++

Apprentissage C++ : collection de cartes (paire clé-valeur)

L'ensemble et la carte appartiennent à L'implémentation interne de la classe conteneur à structure non linéaire

est un arbre binaire équilibré

map est un conteneur associatif de STL, qui fournit des capacités de traitement de données individuelles

Le premier peut être appelé un mot-clé, et chaque mot-clé ne peut apparaître une fois dans la carte
La deuxième valeur appelée mot-clé

###set set

begin Syntaxe :

iterator begin();

Renvoie un itérateur pointant vers le premier élément de la collection actuelle.

clear Syntaxe :

void clear();

Effacer tous les éléments de la collection actuelle.

count Syntaxe :

size_type count( const key_type &key );

Renvoie le nombre d'éléments avec une certaine valeur qui apparaissent dans la collection actuelle.

empty Syntaxe :

bool empty();

Si la collection actuelle est vide, renvoie true sinon, renvoie false ;

end Syntaxe :

const_iterator end();

Renvoie un itérateur pointant vers le dernier élément de la collection actuelle.

equal_range Syntaxe :

pair equal_range( const key_type &key );

Renvoie deux itérateurs dans la collection avec des limites supérieure et inférieure égales à la valeur donnée.

effacer Syntaxe :

void erase( iterator i ); 
void erase( iterator start, iterator end ); 
size_type erase( const key_type &key );

Description :
● Supprimer l'élément
● Supprimer les éléments du début à la fin
● Supprimer tout ; éléments égaux à la valeur clé (renvoie le nombre d’éléments supprimés).

syntaxe de recherche :

iterator find( const key_type &key );

Trouver l'élément égal à la valeur clé dans la collection actuelle et renvoyer l'itérateur pointant vers l'élément s'il n'est pas trouvé, renvoyer le dernier ; point de la collection Un itérateur d'éléments.

get_allocator Syntaxe :

allocator_type get_allocator();

Renvoie l'allocateur de la collection actuelle.

insert Syntaxe :

iterator insert( iterator i, const TYPE &val ); 
void insert( input_iterator start, input_iterator end ); 
pair insert( const TYPE &val );

Description :
● Insérer val avant l'itérateur i
● Renvoie l'itérateur du début à la fin L'élément est inséré dans la collection ;
● Insère l'élément val dans la collection actuelle et renvoie un itérateur pointant vers l'élément et une valeur booléenne pour indiquer si val a été inséré avec succès.
(Il est à noter que deux éléments identiques ne peuvent pas être insérés dans des ensembles (Sets).)

lower_bound Syntaxe :

iterator lower_bound( const key_type &key );

Renvoie un pointeur plus grand than ou Un itérateur égal au premier élément de la valeur clé.

key_comp Syntaxe :

key_compare key_comp();

Renvoie un objet fonction utilisé pour la comparaison de valeurs entre les éléments.

max_size Syntaxe :

size_type max_size();

Renvoie la limite maximale d'éléments que la collection actuelle peut contenir.

rbegin Syntaxe :

reverse_iterator rbegin();

Renvoie un itérateur inverse pointant vers le dernier élément de la collection actuelle.

rend Syntaxe :

reverse_iterator rend();

Renvoie un itérateur inversé pointant vers le premier élément de la collection.

size Syntaxe :

size_type size();

Renvoie le nombre d'éléments dans la collection actuelle.

swap Syntaxe :

void swap( set &object );

Échangez des éléments dans la collection actuelle et la collection d'objets.

upper_bound Syntaxe :

iterator upper_bound( const key_type &key );

Renvoie un itérateur pointant vers des éléments supérieurs à la valeur Key dans la collection actuelle.

value_comp Syntaxe :

value_compare value_comp();

Renvoie un objet fonction utilisé pour comparer les valeurs entre les éléments

Exemple de code simple :

/*
 * ===========================================================================
 *
 *       Filename:  setTest.cpp
 *    Description:  
 *        Version:  1.0
 *        Created:  2017年07月01日 22时20分58秒
 *       Revision:  none
 *       Compiler:  gcc
 *         Author:   (), 
 *        Company:  
 *
 * ===========================================================================
 */
#include<iostream>
#include<set>
using namespace::std;


void showSet(const set<int> i_set){
  //通过迭代器的形式输出set集合
  cout<<"===========the show start==========="<<endl;
  set<int>::const_iterator c_iter;
  for(c_iter = i_set.begin(); c_iter !=i_set.end();c_iter++){
    cout<< "i_set:"<<*c_iter << endl;
  }
  cout<<"===========the show end============="<<endl;
}

void showReverseSet(set<int> r_set){
  cout<<"==========the show reverse set start============="<<endl;
  //通过反向迭代器输出
  set<int>::reverse_iterator r_iter;
  for(r_iter = r_set.rbegin();r_iter!=r_set.rend();r_iter++){
    cout<< "r_set:"<< *r_iter <<endl;
  }
  cout<<"==========the show reverse set end==============="<<endl;
}


int main(int argc,char *argv[]){
  //set的常用几种构造函数
  int array[6] = {11,3,25,7,9,6};
  //第一种构造函数
  set<int> first_set;
  //第二种构造函数
  set<int> second_set(array,array+6);
  showSet(second_set);
  //第三种构造函数
  set<int> third_set(second_set.begin(),second_set.end());
  showSet(third_set);

  //set的插入insert函数
  first_set.insert(3);
  first_set.insert(6);
  first_set.insert(5);
  first_set.insert(5);
  showSet(first_set);

  //返回当前集合中出现某个值的数量count
  int count = first_set.count(5);
  cout<< "the count:"<< count << endl;

  //返回当前集合是否是null的  empty函数
  bool setIsEmpty = first_set.empty();
  cout << "the set empty type:"<<setIsEmpty <<endl;

  //删除某个元素  erase
  first_set.erase(3);
  showSet(first_set);

  //set的大小
  cout<<"the set size:"<< first_set.size() << endl;
  
  showReverseSet(first_set);

  //交换集合中的元素
  first_set.swap(second_set);
  showSet(first_set);
  showSet(second_set);
  
  //通过find函数来寻找集合中的元素
  set<int>::iterator iter;
  iter = first_set.find(3);
  first_set.erase(iter);
  showSet(first_set);

  first_set.clear();
  return 0;
}

###Utilisation de paires clé-valeur de carte
Les cartes C++
Les cartes C++ sont utilisées pour stocker des paires "mot-clé/valeur"

begin Syntaxe : la fonction

  iterator begin();

begin() renvoie un itérateur pointant vers le premier élément de la carte.

clear Syntaxe :

void clear();

La fonction clear() supprime tous les éléments de la carte.

count Syntaxe :

  size_type count( const KEY_TYPE &key );

count() La fonction renvoie le nombre d'éléments dans la carte dont la valeur de clé est égale à la clé.

empty Syntaxe :

  bool empty();

empty() la fonction renvoie vrai si la carte est vide, sinon elle renvoie faux.

end Syntaxe : la fonction

  iterator end();

end() renvoie un itérateur pointant vers la fin de la carte.

equal_range Syntaxe :

  pair equal_range( const KEY_TYPE &key );

equal_range() La fonction renvoie deux itérateurs - l'un pointant vers le premier élément avec la valeur clé et l'autre pointant vers le dernier L'élément dont la valeur clé est la clé.

syntaxe d'effacement :

  void erase( iterator pos );
  void erase( iterator start, iterator end );
  size_type erase( const KEY_TYPE &key );

la fonction Erase() supprime l'élément en position pos, ou supprime l'élément entre le début et la fin, ou supprime ceux dont la valeur est la clé de tous les éléments.

find Syntaxe :

  iterator find( const KEY_TYPE &key );

La fonction find() renvoie un itérateur pointant vers l'élément avec la valeur clé. S'il n'est pas trouvé, elle renvoie un itérateur pointant vers l'élément avec la valeur clé. jusqu'à la fin de la carte.

get_allocator Syntaxe :

  allocator_type get_allocator();

la fonction get_allocator() renvoie le configurateur de la carte.

insérer la syntaxe :

  iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val );
  void insert( input_iterator start, input_iterator end );
  pair<iterator, bool> insert( const pair<KEY_TYPE,VALUE_TYPE> &val );

fonction insert() :
Insérer val après pos, puis renvoyer un pointeur vers cet itérateur d'élément .
Insérez des éléments du début à la fin dans la carte.
Insérer val uniquement si val n'existe pas. La valeur de retour est un itérateur pointant vers l'élément inséré et une valeur booléenne décrivant s'il a été inséré.

key_comp Syntaxe :

  key_compare key_comp();

la fonction key_comp() renvoie une fonction qui compare les clés.

syntaxe lower_bound :

  iterator lower_bound( const KEY_TYPE &key );

lower_bound()函数返回一个迭代器，指向map中键值>=key的第一个元素。

max_size 语法:

  size_type max_size();

max_size()函数返回map能够保存的最大元素个数。

rbegin 语法:

  reverse_iterator rbegin();

rbegin()函数返回一个指向map尾部的逆向迭代器。

rend 语法:

  reverse_iterator rend();

rend()函数返回一个指向map头部的逆向迭代器。

size 语法:

  size_type size();

size()函数返回map中保存的元素个数。

swap 语法:

  void swap( map &obj );

swap()交换obj和现map中的元素。

upper_bound 语法:

  iterator upper_bound( const KEY_TYPE &key );

upper_bound()函数返回一个迭代器，指向map中键值>key的第一个元素。

value_comp 语法:

  value_compare value_comp();

value_comp()函数返回一个比较元素value的函数。

map集合的一些简单的使用

#include<iostream>
#include<map>
#include<string>
using namespace::std;
/* *
 *map集合的简单使用
 *
 * */



class Compare{
  public:
    bool operator()(int a,int b){
      return a > b;
    }

};

int main(int argc,char* argv[]){
  //定义一个map的对象
  map<int,string> num_convert_map;
  map<int,string>::iterator m_iter;

  //采用pair来进行键值对的添加
  num_convert_map.insert(pair<int,string>(1,"one"));
  //通过map集合内部的value_type来进行插入键值对
  num_convert_map.insert(map<int,string>::value_type(2,"two"));
  //通过make_pair来进行键值对的插入
  num_convert_map.insert(make_pair(3,"three"));

  //map重载了[],[键] = "值"
  num_convert_map[0] = "zero";


  //输出map中的元素
  for(m_iter =num_convert_map.begin();m_iter != num_convert_map.end() ;m_iter++){
    //第一个元素iter->first  第二个元素 iter->second
    cout << m_iter->first <<":"<< m_iter -> second << endl;
  }

  //通过键来查询值
  cout<<num_convert_map[3]<<endl;
  
  map<string,string> string_map;
  string_map.insert(pair<string,string>("张三","初中"));
  string_map["李四"] = "高中";
  //由此重写后的map对象的[]运算符是支持泛型的
  cout << string_map["张三"]<<endl;
  

  //输出map的大小
  cout<< "map size:" << num_convert_map.size() <<endl;
  
  //通过Compare将map排序,通过赋值拷贝的构造函数
  map<int,string,Compare> num_convert_map2(num_convert_map.begin(),num_convert_map.end());
  num_convert_map2.insert(pair<int,string>(5,"张三"));  
  num_convert_map2.insert(pair<int,string>(3,"李四"));  
  num_convert_map2.insert(pair<int,string>(1,"赵柳"));  
  cout<< "-------------"<<endl;
  for(m_iter = num_convert_map2.begin();m_iter != num_convert_map2.end();m_iter++){
    cout<<m_iter->first <<";"<<m_iter->second<<endl;
  }

  return 0;
}

感谢大家的阅读，希望大家收益多多。

本文转自：  https://blog.csdn.net/qq_29924041/article/details/74080102  

推荐教程：《C语言》                               

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!