Tableaux dynamiques new delete
Fermé
Ayoub
-
Modifié le 5 févr. 2021 à 17:47
mamiemando Messages postés 33079 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 23 avril 2024 - 5 févr. 2021 à 18:06
mamiemando Messages postés 33079 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 23 avril 2024 - 5 févr. 2021 à 18:06
A voir également:
- Tableaux dynamiques new delete
- Tableaux croisés dynamiques - Guide
- Just delete me - Guide
- Delete hiberfil.sys - Guide
- Fusionner deux tableaux excel - Guide
- Outlook new - Guide
1 réponse
mamiemando
Messages postés
33079
Date d'inscription
jeudi 12 mai 2005
Statut
Modérateur
Dernière intervention
23 avril 2024
7 749
Modifié le 5 févr. 2021 à 18:26
Modifié le 5 févr. 2021 à 18:26
Bonjour,
Pour moi tu te compliques inutilement là vie. La STL te permet d'avoir des classes permettant de manipuler facilement des containers (chaînes, listes, vecteurs, ensembles, dictionnaires) et des algorithmes pour les manipuler.
En l'occurrence tu peux utiliser :
En terme de code, pour trouver les mots dans
Dans cet exemple, s1 contient des félins et s2 des animaux domestiques.
Résultat :
Remarque :
Les fonctions
Dans la fonction
Cela signifie que dans ton projet, il serait sans doute plus aviser de construire des ensembles de mots
Bonne chance
Pour moi tu te compliques inutilement là vie. La STL te permet d'avoir des classes permettant de manipuler facilement des containers (chaînes, listes, vecteurs, ensembles, dictionnaires) et des algorithmes pour les manipuler.
En l'occurrence tu peux utiliser :
-
std::string
: les chaînes de caractères ; -
std::set<T>
: ensemble ordonné (par défaut selon <) contenant des éléments deux à deux distincts; -
std::set_difference
: la différence ensembliste (note que la STL implémente les autres opérateurs ensemblistes :std::set_intersection
,std::set_union
).
En terme de code, pour trouver les mots dans
s1mais pas
s2voici comment tu peux procéder (en prime je t'ai mis les autres opérations ensemblistes) :
#include <algorithm> // std::set_intersection
#include <iostream> // std::cout
#include <ostream> // std::ostream
#include <string> // std::string
#include <set> // std::set
// Affiche le contenu d'un ensemble
template <typename T>
std::ostream & operator << (
std::ostream & out,
const std::set<T> & s
) {
out << "{";
for (auto x : s) out << " " << x;
out << " }";
return out;
}
template <typename T>
std::set<T> my_set_intersection(
const std::set<T> & s1,
const std::set<T> & s2
) {
std::set<T> s_intersection;
set_intersection(
s1.begin(), s1.end(), s2.begin(), s2.end(),
std::inserter(s_intersection, s_intersection.begin())
);
return s_intersection;
}
template <typename T>
std::set<T> my_set_union(
const std::set<T> & s1,
const std::set<T> & s2
) {
std::set<T> s_union;
set_union(
s1.begin(), s1.end(), s2.begin(), s2.end(),
std::inserter(s_union, s_union.begin())
);
return s_union;
}
template <typename T>
std::set<T> my_set_difference(
const std::set<T> & s1,
const std::set<T> & s2
) {
std::set<T> s_difference;
set_difference(
s1.begin(), s1.end(), s2.begin(), s2.end(),
std::inserter(s_difference, s_difference.begin())
);
return s_difference;
}
int main(){
using namespace std;
const set<string>
s1 = {"chat", "lion", "tigre"},
s2 = {"chat", "chien", "cheval"};
// Intersection
cout << "s1 = " << s1 << endl
<< "s2 = " << s2 << endl
<< "s1 u s2 = " << my_set_union(s1, s2) << endl
<< "s1 n s2 = " << my_set_intersection(s1, s2) << endl
<< "s1 \\ s2 = " << my_set_difference(s1, s2) << endl;
return 0;
}
Dans cet exemple, s1 contient des félins et s2 des animaux domestiques.
- s1 u s2 : ensemble des animaux qu'ils soient félins, domestiques ou les deux
- s1 n s2 : ensemble des animaux félins et domestiques
- s1 \ s2 : ensemble des animaux félins non domestiques
Résultat :
(mando@silk) (~) $ g++ toto.cpp && ./a.out
s1 = { chat lion tigre }
s2 = { chat cheval chien }
s1 u s2 = { chat cheval chien lion tigre }
s1 n s2 = { chat }
s1 \ s2 = { lion tigre }
Remarque :
Les fonctions
my_set_*sont template sur le type T, ce qui signifie que le code reste valide quelque soit le type T. Contrairement à une fonction non template, une fonction template est déclarée et implémentée dans le même fichier (e.g. dans un header). Ici comme mon bout de code est très court, j'ai tout mis dans un même fichier.
Dans la fonction
main, j'utilise des ensembles constants (
const std::set<std::string>). Bien entendu, tu appliquer ces fonctions sur des ensembles non constants (
std::set<std::string>) selon le théorème du qui peut le plus peut le moins.
Cela signifie que dans ton projet, il serait sans doute plus aviser de construire des ensembles de mots
std::set<string>dont tu adapterais le contenu dynamiquement avec les méthodes adéquates (voir la documentation).
Bonne chance
