C ++: vecteur, chaîne, liste, forward_list, deque, tableau 的 échange

---

1. vecteur d'échange (liste, forward_list, DEQUE De même)

#include <iostream>
#include <vector>
using namespace std;
void show(int i, vector<int> &v1, vector<int> &v2, vector<int>::iterator i1, vector<int>::iterator i2, int &r1, int &r2, int *p1, int *p2);

int main()
{
   vector<int> v1(1, 1);
   vector<int> v2(2, 2);
   // 迭代器
   auto i1 = v1.begin();
   auto i2 = v2.begin();
   //引用
   int &r1 = *v1.begin();
   int &r2 = *v2.begin();
   //指针
   int *p1 = &(*v1.begin());
   int *p2 = &(*v2.begin());
   //输出
   show(0, v1, v2, i1, i2, r1, r2, p1, p2);
   //交换
   swap(v1, v2);
   //输出
   cout << "\n--------------------------------------------------" << endl;
   show(1, v1, v2, i1, i2, r1, r2, p1, p2);
   return 0;
}

void show(int i, vector<int> &v1, vector<int> &v2, vector<int>::iterator i1, vector<int>::iterator i2, int &r1, int &r2, int *p1, int *p2)
{
   if (i)
   {
       cout << "vector after:\n"
            << endl;
   }
   else
   {
       cout << "vector before:\n"
            << endl;
   }

   cout << "v1:";
   for (auto &a : v1)
   {
       cout << a << "(" << &a << ")\t";
   }

   cout << endl;
   cout << "i1->" << *i1 << "(" << &(*i1) << ")"
        << "\tr1->" << r1 << "(" << &r1 << ")"
        << "\tp1->" << *p1 << "(" << &(*p1) << ")" << endl;

   cout << "\nv2:";
   for (auto &a : v2)
   {
       cout << a << "(" << &a << ")\t";
   }
   cout << endl;

   cout << "i2->" << *i2 << "(" << &(*i2) << ")"
        << "\tr2->" << r2 << "(" << &r2 << ")"
        << "\tp2->" << *p2 << "(" << &(*p2) << ")" << endl;
}

analyse:

1. Iterator i1, références r1, pointeur p1 pointe toujours 0x2c0f88, une valeur de 1, restent inchangés; iterator i2, référencé pointeur r2, p2 pointe toujours 0x2c0f98, une valeur de 2, reste inchangé.
2. Lorsque l'échange, v1 et v2 qui est l'adresse des éléments d'échange. v1 premier élément d'adresse et de 0x2c0f88 remplacé 0x2c0f98, première adresse d'élément v2 de 0x2c0f98 remplacé 0x2c0f88.

2. tableau 的 échange

#include <iostream>
#include <array>
using namespace std;
void show(int i, array<int, 2> &a1, array<int, 2> &a2, array<int, 2>::iterator i1, array<int, 2>::iterator i2, int &r1, int &r2, int *p1, int *p2);

int main()
{
    array<int, 2> a1{1, 1};
    array<int, 2> a2{2, 2};
    // 迭代器
    auto i1 = a1.begin();
    auto i2 = a2.begin();
    //引用
    int &r1 = *a1.begin();
    int &r2 = *a2.begin();
    //指针
    int *p1 = &(*a1.begin());
    int *p2 = &(*a2.begin());
    //输出
    show(0, a1, a2, i1, i2, r1, r2, p1, p2);
    //交换
    swap(a1, a2);
    //输出
    cout << "\n--------------------------------------------------" << endl;
    show(1, a1, a2, i1, i2, r1, r2, p1, p2);
    return 0;
}

void show(int i, array<int, 2> &a1, array<int, 2> &a2, array<int, 2>::iterator i1, array<int, 2>::iterator i2, int &r1, int &r2, int *p1, int *p2)
{
    if (i)
    {
        cout << "array after:\n"
             << endl;
    }
    else
    {
        cout << "array before:\n"
             << endl;
    }

    cout << "a1:";
    for (auto &a : a1)
    {
        cout << a << "(" << &a << ")\t";
    }

    cout << endl;
    cout << "i1->" << *i1 << "(" << &(*i1) << ")"
         << "\tr1->" << r1 << "(" << &r1 << ")"
         << "\tp1->" << *p1 << "(" << &(*p1) << ")" << endl;

    cout << "\na2:";
    for (auto &a : a2)
    {
        cout << a << "(" << &a << ")\t";
    }
    cout << endl;

    cout << "i2->" << *i2 << "(" << &(*i2) << ")"
         << "\tr2->" << r2 << "(" << &r2 << ")"
         << "\tp2->" << *p2 << "(" << &(*p2) << ")" << endl;
}

analyse:

1. Iterator i1, références r1, pointeur p1 pointe toujours 0x22feb0, mais sa valeur de 1 à transducteur 2; iterator i2, référencé r2, pointeur p2 pointe toujours 0x22fea8, mais sa valeur est également modifiée de 1 à 2.
2. Lorsque l'échange, a1 et a2 est une valeur de ses éléments d'échange. a1 et première adresse d'élément a2 inchangé.

3. chaîne de permutation

#include <iostream>
#include <vector>
using namespace std;
void show(int i, string &s1, string &s2, string::iterator i1, string::iterator i2, char &r1, char &r2, char *p1, char *p2);

int main()
{
    string s1 = "a";
    string s2 = "bc";
    // 迭代器
    auto i1 = s1.begin();
    auto i2 = s2.begin();
    //引用
    char &r1 = *s1.begin();
    char &r2 = *s2.begin();
    //指针
    char *p1 = &(*s1.begin());
    char *p2 = &(*s2.begin());
    //输出
    show(0, s1, s2, i1, i2, r1, r2, p1, p2);
    //交换
    swap(s1, s2);
    //输出
    cout << "\n--------------------------------------------------" << endl;
    show(1, s1, s2, i1, i2, r1, r2, p1, p2);
    return 0;
}

void show(int i, string &s1, string &s2, string::iterator i1, string::iterator i2, char &r1, char &r2, char *p1, char *p2)
{
    if (i)
    {
        cout << "string after:\n"
             << endl;
    }
    else
    {
        cout << "string before:\n"
             << endl;
    }

    cout << "s1:";
    for (auto &a : s1)
    {
        cout << a << "(" << &a << ")\t";
    }

    cout << endl;
    cout << "i1->" << *i1 << "(" << &(*i1) << ")"
         << "\tr1->" << r1 << "(" << &r1 << ")"
         << "\tp1->" << *p1 << "(" << &(*p1) << ")" << endl;

    cout << "\ns2:";
    for (auto &a : s2)
    {
        cout << a << "(" << &a << ")\t";
    }
    cout << endl;

    cout << "i2->" << *i2 << "(" << &(*i2) << ")"
         << "\tr2->" << r2 << "(" << &r2 << ")"
         << "\tp2->" << *p2 << "(" << &(*p2) << ")" << endl;
}

analyse:

1. string lors de l'exécution swap, similaire au vecteur, à savoir l'échange uniquement la structure de données interne du récipient.
2. Parce que la chaîne est trop courte, trop de gaspillage de mémoire affectée, de sorte qu'il est stocké dans la zone de mémoire temporaire dans laquelle une autre adresse à partir d'autres éléments de conteneur. Lorsque la chaîne exécuter swap, ce sera la mémoire réaffectés pour la chaîne, itérateurs résultants, les pointeurs et les références ne.

4. Résumé

1. Lors de permutation de matrice, ce qui correspond à la véritable échange des valeurs d'éléments , l' échange de conteneur seule autre structure de données interne de son conteneur ( par exemple, adresse d'élément ).
2. Lors de permutation de matrice, il nécessite deux conteneurs de type conteneur, le nombre d'éléments et types d'éléments mêmes, d' autres conteneurs ne nécessite que le type de récipient et les types d'éléments identiques.
3. chaîne après avoir effectué swap, qui pointe vers le itérateurs élément conteneur d' origine, des références et des pointeurs non , d' autres itérateurs contenant d' origine, et un pointeur de référence est toujours valide .