容器的多重嵌套

//在刚学结构链表的时候，我就想，应该能把几个链表的首指针放在 一个指针数组里。而这个指针数组

//则又是另一个链表的某个元素。学习完容器之后，发现，C++的容器更容易实现这样的操作。

//可是，当我把含有容器的对象，放进另一个容器的时候，问题出现了。我不知道应该怎么来访问最里

//面 容器的元素。这是我逻辑上的一个误区。 今天解决了，按照老师的指点，彻底明白了问题的关键





我们先要考虑的是，如果把外面的容器扔掉，怎么来访问这个对象的容器元素。



首先发现，这个容器里的对象，不是外部可以访问的，必须在类的定义里，给我加



一个成员函数来操作这个容器，好了，我们先写一个带有容器的类。然后再写一个可以对



容器进行操作的函数 



class temp

{

      protected:

                

                vector <int> subject;      //声明vector容器 

      public:

             

                int vec_return(int);       //操作容器，返回某位置的值。int 为要访问的元素位置 

};



int temp::vec_return (int a)                           //这是函数的实现, 



{

            

                 if ((a <subject.size())&&(a >= 0))      //判断参数是否合理            

                 {

                       return subject[a];

                 }

                 else

                 {

                     cout << "参数不合理"<<endl;

                 }

return -1;

}



好了，我们现在完全可以在外面用vec_return函数来访问类里的vector中的元素;



现在我们把最外面的容器加上。



vector <temp> name_sub;





vector可以用下标来访问元素，这个容器这个特点现在占了优势，让我们可以更



容易的完成对其中的元素访问 。



如果我们要访问，name_sub[4]第5个元素。这就是这个元素了，



这个元素中的容器怎么访问呢 



是 这样的



name_sub[4].vec_return(5);



。。。这好使吗。。我们来试试 

 

#include <iostream>



#include <vector>



using namespace std;





class temp

{

      protected:

                

                vector <int> subject;

      public:

             

                int  vec_return(int);       //操作容器，返回某位置的值。int 为要访问的元素位置 

                

                temp ()                     //构造函数 

                {

                                          

                     for (int i=0;  i<9;   i++)

                     {

                         subject.push_back(i);

                     }

                     

                } 

                

                             

                

};



int temp::vec_return (int a)                           //这是函数的实现, 



{

            

                 if ((a <subject.size())&&(a >= 0))      //判断参数是否合理            

                 {

                       return subject[a];

                 }

                 else

                 {

                     cout << "参数不合理"<<endl;

                 }

return -1;

}



int main()

{

    vector <temp>  name_sub(10);

    

    cout << name_sub[4].vec_return(5)<<endl;

    

    cin.get();

    

    return 0;

}



哈，运行成功！！^_^





顺序容器这么访问真方便，加一点点难度，用list再练习练习,



我们把里面和外面的容器全搞成list的 

 



我们先写一个带有list容器的类



class temp

{

      protected:

                

                list <int> subject;      //声明list容器 

      public:

             

                temp ()                     //构造函数 

                {

                                          

                     for (int i=0;  i<9;   i++)

                     {

                         subject.push_back(i);

                     }

                     

                } 

                

                

                ~temp(){}

                

                int  list_return(int);    //操作容器，返回某位置的值。int

                                         // 为要访问的元素位置 

};



int  list_return(int a)                   //函数的实现 

                                         //这里有点问题，list容器，不能直接用下标访问 

                                         //所以，我们先建一个迭代，然后控制迭代访问 

{

      list <int>::iterator itr=subject.begin();

      

      

      

                      

      if ((a <subject.size()) && (a >= 0))      //判断参数是否合理 

      {

         for (int i=0;  i!=a;  ++i)          //参数合理，就把迭代指向所需元素; 

         {

             itr++;

         }

      }

      else                                   // 不合理退出 

      {

          cout << "参数错误"<<endl;

          return -1;

      }

return *itr;                                 //返回所需要元素值; 

}



现在完成了在类外面怎么访问这个list容器。



现在应该是给这个类外面再套一个容器的时候了。



list <temp>  name_subject;



唉，list不支持下标访问。因为不是顺序容器。。我们必须给它建一个迭代器来访问它





list <temp>::iterator itr=name_subject.begin();





然后对这个迭代指向的元素进行操作;



itr->list_return(6) 



哈哈！代码好像比vector漂亮;



试一试的时间到了！！！

 

#include <iostream>



#include <list>



using namespace std;



class temp

{

      protected:

                

                list <int> subject;      //声明list容器 

      public:

             

                temp ()                     //构造函数 

                {

                                          

                     for (int i=0;  i<9;   i++)

                     {

                         subject.push_back(i);

                     }

                     

                } 

                

                

                ~temp(){}

                

                int  list_return(int);    //操作容器，返回某位置的值。int

                                         // 为要访问的元素位置 

};





int  temp::list_return (int a)            //函数的实现 

                                         //这里有点问题，list容器，不能直接用下标访问 

                                         //所以，我们先建一个迭代，然后控制迭代访问 

{

      list <int>::iterator itr=subject.begin();

      

      

      

                      

      if (a <subject.size() && a >= 0)       //判断参数是否合理 

      {

         for (int i=0;  i!=a;  ++i)          //参数合理，就把迭代指向所需元素; 

         {

             itr++;

         }

      }

      else                                   // 不合理退出 

      {

          cout << "参数错误"<<endl;

          return -1;

      }

      

return *itr;                                 //返回所需要元素值; 

}





int output (list <temp> &name_sub,  int a,  int b)   //为了方便，我建了一个函数来操作整个返回过程

                                                     //name_sub为所要访问的容器引用 

                                                     //int a为外层容器位置， int b为内层容器位置

{



      list <temp>::iterator itr=name_sub.begin();    //建迭代准备访问;  

        

      if (a <name_sub.size() && a >= 0)              //判断参数是否合理 

      {

   

                  

         for (int i=0;  i!=a;  ++i)                  //参数合理，就把迭代指向所需元素; 

         {

             itr++;

         }

      }

      else                                           // 不合理退出 

      {

          cout << "参数错误"<<endl;

          return -1;

      }

      

return itr->list_return(b);



}





int main()



{

    list <temp> name_sub(10);

    

    

    cout << output(name_sub, 6,  4)<<endl;

    

    cin.get();

return 0;

}



运行成功！！happy!





总结经验，无论多么深的容器嵌套，只用把它和外面一层的勾通做好，就一切大吉了！