学步园

很多网上介绍的都是关于STL在控制台的运用，我认为，这总适合与学习理论知识以及其实践，当真正用到项目中去的

恐怕这就不适合了。我也老套一下。分为两种情况。

1）控制台的运用

2）用MFC写一个简单的画图程序（恐怕这个应该是大家更加注意的）

OK，先说控制台：

下面源代码，可以直接运行（VC6 Console）（关于其整个工程文件可以到www.confach.533.net去Download），如果你找不到，可以直接按上面的联系方式与我Mail，我会尽快给你发过去，大家一起学习）

#ifdef _MSC_VER

#endif

#include "stdafx.h"

#pragma warning(disable:4786)

#pragma warning(disable:4514)

#include <vector>

#include <iostream>

#include <deque>

#include <list>

#include <set>

#include <map>

#include <algorithm>

#include <string>

#include <iosfwd>

#include <iterator>

class PrintInt

{

public:

 void operator()(int elem) const

 {

  std::cout< }

};

//define a class

class StudentID

{

public:

 StudentID(int id=0)

 {

  value=id;

  std::cout<<"Assigning student id:"< }

 ~StudentID()

 {

  std::cout<<"Destructing ID:"< }

private:

 int value;

};

class Student

{

public:

 Student(char *pName="noName",int ssID=0):id(ssID)

 {

  std::cout<<"Constructing student:"<   strncpy(name,pName,sizeof(name));

  name[sizeof(name)-1]=0;

  StudentID id(ssID);

 }

private:

 char name[20];

 StudentID id;

};

void TestMMap()

{

 typedef multimap IntStringMap;

 IntStringMap coll;

// coll.insert(std::make_pair(5,"tagged"));

// coll.insert(make_pair(2,"a"));

// coll.insert(make_pair(1,"this"));

// coll.insert(make_pair(4,"of"));

// coll.insert(make_pair(6,"strings"));

// coll.insert(make_pair(1,"is"));

// coll.insert(make_pair(3,"multimap"));

// 

 /* print all element values

 *- iterate over all elements

 *- element member second is the value

 */

 std::cout<<"========================================"<// IntStringMap::iterator pos;

//  for (pos = coll.begin(); pos != coll.end(); ++pos)

// {

//  std::cout << pos->second <<"   ";

// }

 std::cout << endl;

 

}

void TestSet()

{

 typedef std::set >IntSet;

  IntSet set1;

 set1.insert(1);

 set1.insert(3);

 set1.insert(5);

 set1.insert(1);

 set1.insert(4);

 set1.insert(6);

 

 std::cout<<"========================================"< IntSet::const_iterator pos;

 for(pos=set1.begin();pos!=set1.end();++pos)

 {

  std::cout<<*pos<<"  "<< "  set"< }

}

void TestAlgorithm()

{

 vector mVector;

 vector::iterator pos;

 mVector.push_back(1);

 mVector.push_back(2);

 mVector.push_back(5);

 mVector.push_back(76);

 mVector.push_back(4);

  std::cout<<"====================================="< for(pos=mVector.begin();pos!=mVector.end();++pos)

 {

  std::cout<<*pos< }

 pos=min_element(mVector.begin(),mVector.end());

 std::cout<<"min:"<<*pos< pos=max_element(mVector.begin(),mVector.end());

 std::cout<<"Max:"<<*pos< std::cout<<"===================================="< std::cout<<"        Sort                        "< std::cout<<"===================================="< std::sort(mVector.begin(),mVector.end());

 for(pos=mVector.begin();pos!=mVector.end();++pos)

 {

  std::cout<<*pos< }

 std::cout<<"===================================="< std::cout<<"         Reverse                       "< std::cout<<"===================================="< std::reverse(mVector.begin(),mVector.end());

 for(pos=mVector.begin();pos!=mVector.end();++pos)

 {

  std::cout<<*pos< }

 

}

void TestIteratorAdapter()

{

 list coll1;

 

 //insert elements from 1 to 9 into the first collection

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

 {

  coll1.push_back(i);

 }

 

 // copy the elements of coll1 into coll2 by appending

 vector coll2;

 copy (coll1.begin(), coll1.end(), //source

        back_inserter(coll2)); //destination

 

 //copy the elements of coll1 into coll3 by inserting them  front

 // - reverses the order of the elements

 //Remarks:if use front_inserter,the container must provide push_front method

 deque coll3;

 copy (coll1.begin(), coll1.end(), //source

       front_inserter(coll3)); //destination

 

 //copy elements of coll1 into coll4

 

 // - only inserter that works for associative collections

 set coll4;

 copy (coll1.begin(), coll1.end(), //source

       inserter(coll4,coll4.begin())); //destination

 std::cout<<"=====================List=========="< list::iterator pos;

 for(pos=coll1.begin();pos!=coll1.end();++pos)

 {

  std::cout<<*pos< }

 std::cout<<"=====================Vector(List use back_insert)=========="< vector::iterator pos1;

 for(pos1=coll2.begin();pos1!=coll2.end();++pos1)

 {

  std::cout<<*pos1< }

 std::cout<<"=====================Deque(List use front_insert)=========="< deque::iterator pos2;

 for(pos2=coll3.begin();pos2!=coll3.end();++pos2)

 {

  std::cout<<*pos2< }

 std::cout<<"=====================Set(List use inserter)=========="< set::iterator pos3;

 for(pos3=coll4.begin();pos3!=coll4.end();++pos3)

 {

  std::cout<<*pos3< }

}

void TestStreamIterator()

{

 vector coll;

 /*read all words from the standard input

 * - source: all strings until end-of-file (or error)

 * - destination: coll (inserting)

 */

 copy (istream_iterator(cin), //start of source

  istream_iterator(), //end of source

  back_inserter(coll)); //destination

 

 

 //sort elements

 sort (coll.begin(), coll.end());

 /*print all elements without duplicates

 * - source: coll

 * - destination: standard output (with newline between elements)

 */

 unique_copy (coll.begin(), coll.end(), //source

  ostream_iterator (cout, "\n"));

 //destination

}

template
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")

{

typename T::const_iterator pos;

std::cout << optcstr<for (pos=coll.begin(); pos!=coll.end(); ++pos) {

std::cout << *pos << ' '<}

std::cout << std::endl;

}

//void main()

//{

//  const int size=100;

//  int array[size];

//  array[0]=0;

//  array[1]=1;

//  array[1000]=1000;

//

//  cout<// 

//}

typedef struct tagIntegerNode {

  int             iValue;

  tagIntegerNode *pNextIntegerNode;

}INTEGERNODE;

class A {

  public:

    // Made public to simplify tracing

    // Would normally be protected:

   static INTEGERNODE *pFirstIntegerNode;

};

// Static data members must be initialized at file scope, even

// if private.

INTEGERNODE *A::pFirstIntegerNode;

class B:public A {

  public:

    B( void );

};

class C:public A {

  public:

    C( void );

};

B::B( void )

{

  pFirstIntegerNode                   = new INTEGERNODE;

  pFirstIntegerNode->iValue           = 1;

  pFirstIntegerNode->pNextIntegerNode = NULL;

};

C::C( void )

{

  pFirstIntegerNode->pNextIntegerNode                   = new INTEGERNODE;

  pFirstIntegerNode->pNextIntegerNode->iValue           = 2;

  pFirstIntegerNode->pNextIntegerNode->pNextIntegerNode = NULL;

};

//----------------------------------------------------

//-----------------------------------------------------

typedef list ListElement;

typedef list OwningList;

void OutputList(const ListElement& EntireListElement,int listNumber)

{

 ostream_iterator out(cout," ");

 cout<<"List "<  copy(EntireListElement.begin(),EntireListElement.end(),out);

 cout<

}

void TestOwningList()

{

 OwningList ListOfListElements;

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

 {

  ListElement EntireListElement;

  for(int j=0;j<5;++j)

  {

   EntireListElement.push_back (i*4+j);

  }

  OutputList(EntireListElement,i+1);

  ListOfListElements.push_back(EntireListElement);

 }

 cout< OwningList::iterator it=ListOfListElements.begin();

 for(int j=1;it!=ListOfListElements.end();++it,++j)

 {

     const ListElement& EntireListElement1=*it;

  OutputList(EntireListElement1,j);

 }

 

}

typedef vector INTVECTOR;

void TestVectorAttr1()

{

 // Dynamically allocated vector begins with 0 elements.

  INTVECTOR theVector;

   // Add one element to the end of the vector, an int with the value 42.

   theVector.push_back(42) ;

  // Show statistics about vector.

    cout << "theVector's size is: " << theVector.size() << endl;

    cout << "theVector's maximum size is: " << theVector.max_size()

         << endl;

    cout << "theVector's capacity is: " << theVector.capacity() << endl;

    // Ensure there's room for at least 1000 elements.

    theVector.reserve(1000);

    cout << endl << "After reserving storage for 1000 elements:" << endl;

    cout << "theVector's size is: " << theVector.size() << endl;

    cout << "theVector's maximum size is: " << theVector.max_size()

         << endl;

    cout << "theVector's capacity is: " << theVector.capacity() << endl;

    // Ensure there's room for at least 2000 elements.

    theVector.resize(2000);

    cout << endl << "After resizing storage to 2000 elements:" << endl;

    cout << "theVector's size is: " << theVector.size() << endl;

    cout << "theVector's maximum size is: " << theVector.max_size()

         << endl;

    cout << "theVector's capacity is: " << theVector.capacity() << endl;

}

void TestVectorCreate()

{

 cout<<"============================================="< cout<<"====================Test Vector============="< cout<<"============================================="< INTVECTOR c1;

 c1.push_back(1);

 c1.push_back(2);

 c1.push_back(3);

 c1.push_back(4);

 INTVECTOR::iterator it;

 cout<<"---Create a empty vector without any element"< for(it=c1.begin();it!=c1.end();++it)

 { 

  cout<<*it<<",";

 }

 cout< cout<<"--Create a copy vector"< INTVECTOR c2(c1);

    for(it=c2.begin();it!=c2.end();++it)

 { 

  cout<<*it<<",";

 }

 cout< cout<<"---Create a vector with n elements"< INTVECTOR c3(8);

 c3.assign(8,1);

 c3.push_back(10);

 c3.push_back(12);

 c3.push_back(14);

 c3.push_back(16);

 c3.push_back(18);

   for(it=c3.begin();it!=c3.end();++it)

 { 

  cout<<*it< }

   cout<<"---Create a vector with n copies of elements"<   INTVECTOR c4(5,10);

for(it=c4.begin();it!=c4.end();++it)

 { 

  cout<<*it< }

int nArr[]={1,2,3,4,5};

INTVECTOR c5(nArr,nArr+sizeof(nArr)/sizeof(int));

cout<<"---Create a vector with a array"<for(it=c5.begin();it!=c5.end();++it)

 { 

  cout<<*it< }

cout<<"--Test End----------"<}

void TestVectorIterator()

{

 vector ages(15) ;

 ages.push_back(15);

 vector::const_iterator p=ages.begin();

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

 {

  ages.push_back(i);

 }

 cout<<"===========Test Iterator=============="< //p=ages.begin();

 cout<<"The first age is:"<<*p< cout<<"===============End===================="< 

}

class Shape

{

public:

 virtual void Draw()

 {

  cout<<"Draw it in Shape class"< }

 virtual void GetSize()=0;

 

};

class Rectangle:public Shape

{

public :

 virtual void Draw()

 {

  cout<<"Draw it in Rectangle class"< }

   void GetSize()

   

   {

   cout<<"Get size in Rectangle class"<  }

  

};

void TestPointer()

{

 int i=100;

 char c='a';

 float f=i;

 double d=f;

 bool b=true;

 

 int *pI=&i;

 int **ppI=&pI;

 cout<<"Address of i         :0x"<<&i< printf("Address of c         :0x%p\n",&c);

 cout<<"Address of f          :0x"<<&f< cout<<"Address of d          :0x"<<&d<    cout<<"Address of b          :0x"<<&b<

 cout<<"Address of pI          :0x"<<&pI< cout<<"Value of pI          :0x"<  cout<<"Address of ppI          :0x"<<&ppI< cout<<"Value of ppI          :0x"< }

void main()

{

 TestPointer();

 return;

 Shape *pShape=NULL;

 Rectangle a;

 pShape=&a;

 pShape->Draw();

 pShape->GetSize();

 return;

 TestVectorCreate();

 TestVectorAttr1();

 TestVectorIterator();

    return;

 TestOwningList();

 B instanceB;

 C instanceC;

 cout<iValue < cout<pNextIntegerNode->iValue< 

 short int iArray[1000];

 for(int i1=0;i1<1000;i1++)

 {

  iArray[i1]=i1;

 }

 Student s("confach zhang",99471136);

 vectorcol1;

 dequedeq1;

 listlist1;

  

    std::cout<<"=================================================="< std::cout<<"   index      value    Type"< std::cout<<"=================================================="< for(int i=0;i<100;i++)

 {   if(i%2==0)

  col1.push_back(i);

 }

 

 for( i=0;i
 {

 std::cout< }

 std::cout<<"===============Object Function=================="<     for_each(col1.begin(),col1.end(),PrintInt());

 std::cout<<"=================================================="< std::cout<<"   index      value    Type"< std::cout<<"=================================================="< for(i=0;i<100;i++)

 { 

  if(i%2==0)

  {

  deq1.push_front(i);

  }

  else

  {

   deq1.push_back(i);

  }

 }

 for(i=0;i
 {

  std::cout< }

    std::cout<<"=================================================="< std::cout<<"   index      value    Type"< std::cout<<"=================================================="< for(char c='a';c<='z';c++)

 {

  list1.push_back(c);

 }

   while(!list1.empty())

   {

    std::cout<     list1.pop_front();

   }

    std::cout<<"=================================================="< std::cout<<"   index      value    Type"< std::cout<<"=================================================="<    for( c='a';c<='z';c++)

 {

  list1.push_front(c);

 }

 std::cout<<"==============User Define function=========================="< PRINT_ELEMENTS(list1,"confach");

    list::iterator pos;

   //list::const_iterator//for read_only

   //list::iterator//for read/write

   for(pos=list1.begin();pos!=list1.end();++pos)

 //Caution:

// Note that the preincrement operator (prefix ++) is used here. This is because it might have better

//performance than the postincrement operator. The latter involves a temporary object because it

//must return the old position of the iterator. For this reason, it generally is best to prefer ++pos

//over pos++. Thus, you should avoid the following version:

//for (pos = coll.begin(); pos != coll.end(); pos++) {

//                                            ^^^^^ // OK, but slower

//...

//}

//For this reason, I recommend using the preincrement and pre-decrement operators in general.

   {

    std::cout<   }

   TestSet();

   TestMMap();

   TestAlgorithm();

   std::cout<}