char CmdStr[200][200];

class TEST
{
    public:
              TEST();
        virtual ~TEST();
    public:
              int SplitBufByChar( char *buf1, char ch, char tc,int stno);
};
#endif
cat  test.cpp
#include "test.h"

TEST::TEST()
{
  for(int i=0;i<200;i++)
  {
    CmdStr[i][0]='\0';
  }
   
}
TEST::~TEST()
{
  for(int i=0;i<200;++i)
  {
    CmdStr[i][0]='\0';
  }
}

int TEST::SplitBufByChar( char *buf1, char ch, char tc,int stno)
{
  char *ss0, *ss1;
  int  i,j;
  char T[200][500];

  ss0 = buf1; i = 0;
  while ( (ss1=strchr( ss0, ch )) != NULL )  {
     *ss1 = 0; strcpy( T[stno+i], ss0 );
     i++; ss0= ss1+1; *ss1= ch;
  }

  if ( tc=='C' ) for (j=stno;j<stno+i;j++) strcpy(CmdStr[j],T[j]);
  return( i );
}
cat makefile
DEST=libtest.a
OBJS=test.o
CC= g++
CPPFLAGS = -O2 -Wall
SHAREFLAGS = -shared -fPIC
INCLUDES = -I.

$(DEST) : $(OBJS)
        $(CC) $(SHAREFLAGS) $(INCLUDES) $(CPPFLAGS) -o $@ $^

test.o : test.cpp test.h
        $(CC) $(INCLUDES) $(CPPFLAGS) -c $< -o $@


二.使用动态库
cat protest.cpp
#include "test.h"
#include <string>
#include <vector>

using namespace std;

typedef struct{
    int id;
    string name;
}STUDENT;

typedef std::vector <STUDENT> STRSET;

//extern char CmdStr[200][200];

int main()
{
 char sc[200];

 TEST test1;
 STUDENT stdt1,stdt2,stdt3;
 

 STRSET settest;
 stdt1.id=200;
 stdt1.name="GPRS100~SMS-03-17~新GPRS100元套餐办理~";
 stdt2.id=100;
 stdt2.name="GPRS200~SMS-03-18~新GPRS100元套餐办理~";
 stdt3.id=300;
 stdt3.name="GPRS300~SMS-03-19~新GPRS100元套餐办理~";

 settest.push_back(stdt1);
 settest.push_back(stdt2);
 settest.push_back(stdt3);

 for(std::vector <STUDENT>::iterator it=settest.begin();it !=settest.end();it++)
 {
  sprintf(sc,"%s",((STUDENT)*it).name.c_str());
   
        
        test1.SplitBufByChar(sc,'~','C',1);

        //test1.~TEST();
  printf("cmdstr[1]:%s\n",CmdStr[1]);
        printf("cmdstr[2]:%s\n",CmdStr[2]);
        printf("cmdstr[3]:%s\n",CmdStr[3]);
 }

 return 0;

}

cat makefile
DEST=protest
OBJS=protest.o
CC= g++
CPPFLAGS = -O2 -Wall
INCLUDES = -I. -I../libtest/
LIBS =-L../libtest/ -ltest

$(DEST) : $(OBJS)
        $(CC) $(INCLUDES) $(LIBS) $(CPPFLAGS) -o $@ $^

protest.o : protest.cpp
        $(CC) $(INCLUDES) $(CPPFLAGS) -c $< -o $@

分为一维数组和多维数组，其存储方式画为表格的话就会一目了然，其实就是把相同类型的变量有序的放在一起。因此，在处理比较多的数据时（这也是大多数的情况）数组的应用范围是非常广的。

具体的实际应用不便举例，而且绝大多数是与指针相结合的，笔者个人认为学习数组在 更大程度上是为学习指针做一个铺垫。作为基础的基础要明白几种基本操作：即数组赋值、打印、排序（冒泡排序法和选择排序法）、查找。这些都不可避免的用到 循环，如果觉得反应不过来，可以先一点点的把循环展开，就会越来越熟悉，以后自己编写一个功能的时候就会先找出内在规律，较好的运用了。另外数组做参数 时，一维的[]里可以是空的，二维的第一个[]里可以是空的但是第二个[]中必须规定大小。

相关常用的算法还有判断回文，求阶乘，Fibanacci数列，任意进制转换，杨辉三角形计算等等。

字符串：

字符串其实就是一个数组（指针），在scanf的输入列中是不需要在前面加 “&”符号的，因为字符数组名本身即代表地址。值得注意的是字符串末尾的‘\0’，如果没有的话，字符串很有可能会不正常的打印。另外就是字符串 的定义和赋值问题了，笔者有一次的比较综合的上机作业就是字符串打印老是乱码，上上下下找了一圈问题，最后发现是因为

而不是

前者没有说明指向哪儿，更没有确定大小，导致了乱码的错误，印象挺深刻的。

另外，字符串的赋值也是需要注意的，如果是用字符指针的话，既可以定义的时候赋初值，即

也可以在赋值语句中赋值，即

但如果是用字符数组的话，就只能在定义时整体赋初值，即char a[5]={"abcd"};而不能在赋值语句中整体赋值。

常用字符串函数列表如下，要会自己实现：

注：对字符串是不允许做==或！=的运算的，只能用字符串比较函数

指针：

指针可以说是C语言中最关键的地方了，其实这个“指针”的名字对于这个概念的理解 是十分形象的。首先要知道，指针变量的值（即指针变量中存放的值）是指针（即地址）。指针变量定义形式中：基本类型 *指针变量名 中的“*”代表的是这是一个指向该基本类型的指针变量，而不是内容的意思。在以后使用的时候，如*ptr=a时，“*”才表示ptr所指向的地址里放的内 容是a。

指针比较典型又简单的一应用例子是两数互换，看下面的程序，

这是不能实现a和b的数值互换的，实际上只是形参在这个函数中换来换去，对实参没什么影响。现在，用指针类型的数据做为参数的话，更改如下：

这样在swap中就把p1,p2 的内容给换了，即把a，b的值互换了。

指针可以执行增、减运算，结合++运算符的法则，我们可以看到:

指针和数组实际上几乎是一样的，数组名可以看成是一个常量指针，一维数组中ptr=&b[0]则下面的表示法是等价的：

a[3]等价于*(a+3)
ptr[3]等价于*(ptr+3)

下面看一个用指针来自己实现atoi（字符串型->整型）函数：

指向多维数组的指针变量也是一个比较广泛的运用。例如数组a[3][4]，a代表的实际是整个二维数组的首地址，即第0行的首地址，也就是一个指针变量。而a+1就不是简单的在数值上加上1了，它代表的不是a[0][1]，而是第1行的首地址，&a[1][0]。

指针变量常用的用途还有把指针作为参数传递给其他函数，即指向函数的指针。
看下面的几行代码：

总之，指针的应用是非常灵活和广泛的，不是三言两语能说完的，上面几个小例子只是个引子，实际编程中，会逐渐发现运用指针所能带来的便利和高效率。

文件：

注：以上用于文本文件的操作，如果是二进制文件就在上述字母后加“b”。

我们用文件最大的目的就是能让数据保存下来。因此在要用文件中数据的时候，就是要 把数据读到一个结构（一般保存数据多用结构，便于管理）中去，再对结构进行操作即可。例如，文件aa.data中存储的是30个学生的成绩等信息，要遍历 这些信息，对其进行成绩输出、排序、查找等工作时，我们就把这些信息先读入到一个结构数组中，再对这个数组进行操作。如下例：

链表：
链表是C语言中另外一个难点。牵扯到结点、动态分配空间等等。用结构作为链表的结点是非常适合的，例如：

其中next是指向自身所在结构类型的指针，这样就可以把一个个结点相连，构成链表。

链表结构的一大优势就是动态分配存储，不会像数组一样必须在定义时确定大小，造成不必要的浪费。用malloc和free函数即可实现开辟和释放存储单元。其中，malloc的参数多用sizeof运算符计算得到。

链表的基本操作有：正、反向建立链表；输出链表；删除链表中结点；在链表中插入结点等等，都是要熟练掌握的，初学者通过画图的方式能比较形象地理解建立、插入等实现的过程。

逆向建立：

用递归实现链表逆序输出：

插入结点（已有升序的链表）：

删除结点：

学习完了STL系列之二，自己写了个程序练手！程序采用的还是系列之二文章的架构。学习了STL之一和之二，对于STL的基本原理算有个个基本的了解。其实关于这几种容器，以前也都接触过，不过是在java上，当时学习时也是囫囵吞枣！现在感觉那真是学习之大忌，还是一步一个脚印为好。速度可以放慢点，那要扎实！

注意：程序在vc6下调试通过，对于不清楚如何在vc下运行STL者，可以读STL系列之一。

//TjuAiLab
//Author:zhangbufeng
//Time:2005.8.23 22:00
#include <string>
#include <list>
#include <iostream>
#include <algorithm>
using namespace std;

PrintString(const string& StringToPrint);
const string NameCode("Bufeng");
class IsBufeng
{
public:
 bool operator()(string &StringName)
 {
  return StringName.substr(0,6)==NameCode;
 }
};
void main(void)
{
 //定义一个list
 list<string>AIStudentName;
 list<string>TargetAIStudentName;
 list<string>::iterator AIStudentNameIterator;
 //使用的list的成员函数push_back和puch_front插入元素到list中,使用成员函数insert任意插入
    AIStudentName.push_back("BufengZhang");
 AIStudentName.push_back("YangZhang");
 AIStudentName.push_back("KunHuang");
 AIStudentName.push_front("ChengLuo");
 AIStudentName.push_front("YonghuoYang");
 AIStudentName.push_front("XiaoyuanCui");
 AIStudentName.insert(AIStudentName.end(),"KefeiGong");
 TargetAIStudentName.push_back("BufengZhang");
 TargetAIStudentName.push_back("YangZhang");
 //使用list的成员函数empty判断list是否为空，size来返回成员个数
 if(AIStudentName.empty())
 {
  cout<<"AIStudentName的成员为空"<<endl;
 }
 else
 {
  cout<<"AIStudentName的成员个数为"<<AIStudentName.size()<<endl;
 }
 //使用for循环和迭代器处理list的元素
 cout<<"AIStudentName的成员如下(使用for循环和迭代器："<<endl;
 for(AIStudentNameIterator=AIStudentName.begin();AIStudentNameIterator!=AIStudentName.end();
     AIStudentNameIterator++)
  {
   cout<<*AIStudentNameIterator<<endl;
  }
    //使用STL的通用算法for_each来处理list中的元素
 cout<<"AIStudentName的成员如下(使用STL的通用算法for_each："<<endl;
 for_each(AIStudentName.begin(),AIStudentName.end(),PrintString);
 //学习使用STL的通用算法count和count_if
 int NumberofStudent=0;
 NumberofStudent=count (AIStudentName.begin(),AIStudentName.end(),"BufengZhang");
 cout<<"TjuAIlab中有"<<NumberofStudent<<"个BufengZhang"<<endl;
 NumberofStudent=count_if(AIStudentName.begin(),AIStudentName.end(),IsBufeng());
 cout<<"TjuAIlab中有"<<NumberofStudent<<"个BufengZhang"<<endl;
    //使用STL通用算法find()在list中查找对象
 AIStudentNameIterator=find(AIStudentName.begin(),AIStudentName.end(),"BufengZhang");
 if(AIStudentNameIterator==AIStudentName.end())
  cout<<"AIStudentName中没有BufengZhang"<<endl;
 else
  cout<<"在AIStudentName中可以找到BufengZhang"<<endl;
 //使用STL通用算法find_if在list中查找对象
 AIStudentNameIterator=find_if(AIStudentName.begin(),AIStudentName.end(),IsBufeng());
 if(AIStudentNameIterator==AIStudentName.end())
  cout<<"AIStudentName中没有BufengZhang"<<endl;
 else
  cout<<"在AIStudentName中可以找到BufengZhang"<<endl;
 //使用STL通用算法search在list中找一个序列
    AIStudentNameIterator = search(AIStudentName.begin(),AIStudentName.end(),TargetAIStudentName.begin(),TargetAIStudentName.end());
    if(AIStudentNameIterator==AIStudentName.end())
  cout<<"AIStudentName中没有找到BufengZhang And YangZhang"<<endl;
 else
  cout<<"在AIStudentName中可以找到BufengZhang And YangZhang"<<endl;
 //使用list的成员函数sort()排序一个list
 AIStudentName.sort();
 cout<<"排序如下："<<endl;
 for_each(AIStudentName.begin(),AIStudentName.end(),PrintString);
 //使用list的成员函数删除元素(pop_front,pop_back,erase(),remove())
    AIStudentName.pop_front();
 AIStudentName.pop_back();
 AIStudentName.erase(AIStudentName.begin());
 AIStudentName.remove("XiaoyuanCui");
 cout<<"剩余成员如下："<<endl;
 for_each(AIStudentName.begin(),AIStudentName.end(),PrintString);
 //使用STL通用算法remove()从list中删除元素
    AIStudentNameIterator=remove(AIStudentName.begin(),AIStudentName.end(),"YangZhang");
 cout<<"remove后剩余成员如下:"<<endl;
 for_each(AIStudentName.begin(),AIStudentNameIterator,PrintString);

}
PrintString(const string& StringToPrint)
{
 cout<<StringToPrint<<endl;
}

STL学习系列之四：STL学习小结（转贴）- -

STL学习小结 原创：桑英硕 2004年6月26日

提供了类型安全、高效而易用特性的STL无疑是最值得C++程序员骄傲的部分。每一个C＋＋程序员都应该好好学习STL：).    STL（Standard Template Library 标准模板库）是C＋＋标准库的一个重要组成部分，它由Stepanov and Lee等人最先开发，它是与C＋＋几乎同时开始开发的；一开始STL选择了Ada作为实现语言，但Ada有点不争气，最后他们选择了C＋＋，一个原因了，C＋＋中已经有了模板。在后来，STL又被添加进了C＋＋库。1996年，惠普公司又免费公开了STL，为STL的推广做了很大的贡献。 STL大体上包括container（容器）、algorithm（算法）和iterator（迭代器），容器和算法通过迭代器可以进行无缝连接。   STL体现了范型编程的思想，它具有高度的可重用性，高性能，高移植性。程序员不用思考具体实现过程，只要能够熟练的应用就OK了。（有兴趣研究具体实现的，可以看侯捷老师编著的《STL源码剖析》）这样他们就可以把精力放在程序开发的别的方面。 我非常佩服创造STL的那些计算机和数学精英。因为他们做了一件非常辛苦的事情―――抽象概念。而STL就是通过把容器抽象为统一的接口，算法利用这个接口，通过迭代器来操纵容器。因为接口不变，实现的容器可以随意更改。这样，就为编程、调试和扩展提供了便利。也许有一天，我们生产软件的时候也可以想DIY一台PC一样简单，只要拿来相应的实现模块，通过简单的拼装和调试就可以创造一个软件。这是多么令人兴奋的一件事^_^.不过，到时候，可能会有很多程序员失业了。呵呵，毕竟编写类库不需要很多的人员。 虽然STL不是面向对象的，但，我想，每个人都会为它的创造力和高性能而感到兴奋和折服。 一、容器  作为STL的最主要组成部分－－容器，分为向量（vector），双端队列(deque)，表(list)，队列（queue），堆栈(stack)，集合(set)，多重集合(multiset)，映射(map)，多重映射(multimap)。 容器     特性 所在头文件 向量vector 可以用常数时间访问和修改任意元素，在序列尾部进行插入和删除时，具有常数时间复杂度，对任意项的插入和删除就有的时间复杂度与到末尾的距离成正比，尤其对向量头的添加和删除的代价是惊人的高的 <vector> 双端队列deque 基本上与向量相同，唯一的不同是，其在序列头部插入和删除操作也具有常量时间复杂度 <deque> 表list 对任意元素的访问与对两端的距离成正比，但对某个位置上插入和删除一个项的花费为常数时间。 <list> 队列queue 插入只可以在尾部进行，删除、检索和修改只允许从头部进行。按照先进先出的原则。 <queue> 堆栈stack 堆栈是项的有限序列，并满足序列中被删除、检索和修改的项只能是最近插入序列的项。即按照后进先出的原则 <stack> 集合set 由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序，具有快速查找的功能。但是它是以牺牲插入车删除操作的效率为代价的 <set> 多重集合multiset 和集合基本相同，但可以支持重复元素具有快速查找能力 <set> 映射map 由{键，值}对组成的集合，以某种作用于键对上的谓词排列。具有快速查找能力 <map> 多重集合multimap 比起映射，一个键可以对应多了值。具有快速查找能力 <map> 考虑到不同的实际需要，更主要的是效率的需要，我们可以选择不同的容器来实现我们的程序，以此达到我们提高性能的目的。这也是用好STL的一个难点，但这也是关键。 二、算法 算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。<algorithm>是所有STL头文件中最大的一个，它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。<functional>中则定义了一些模板类，用以声明函数对象。 STL的算法也是非常优秀的，它们大部分都是类属的，基本上都用到了C＋＋的模板来实现，这样，很多相似的函数就不用自己写了，只要用函数模板就OK了。 我们使用算法的时候，要针对不同的容器，比如：对集合的查找，最好不要用通用函数find（），它对集合使用的时候，性能非常的差，最好用集合自带的find（）函数，它针对了集合进行了优化，性能非常的高。 三、迭代器 它的具体实现在<itertator> 中，我们完全可以不管迭代器类是怎么实现的，大多数的时候，把它理解为指针是没有问题的（指针是迭代器的一个特例，它也属于迭代器），但是，决不能完全这么做。 迭代器功能（Abilities Of Iterator Gategories） 输入迭代器 Input iterator 向前读 Reads forward istream 输出迭代器 Output iterator 向前写 Writes forward ostream,inserter 前向迭代器 Forward iterator 向前读写 Read and Writes forward   双向迭代器 Bidirectional iterator 向前向后读写 Read and Writes forward and backward list,set,multiset,map,mul timap 随机迭代器 Random access iterator 随机读写 Read and Write with random access vector,deque,array,string 由此可见，指针和迭代器还是有很大差别的。和指针最接近的就是随机访问迭代器。下面是一个我编写的小例子：功能是分别对数组，向量，表，多重集合进行插入操作，对每个容器插入100万个随机整数； #include<iostream> #include<iterator> #include<vector> #include<list> #include<set> #include<time.h> #include<conio.h> #include<algorithm> using namespace std; template<typename T> void arrayInsert(T*a,T*s,long size)    //向数组插入数据 {    //for(long i=0;i<10;i++)  // //好像数组支持不到100万，我们就算10万的                                          //最后在把把结果乘以10吧，    //{        for(long k=0;k<size;k++)        {            a[k]=s[k];         }    //} } template<typename T> void vectorInsert( vector<T> *v,T*s,long size)     //向向量插入数据 {    for(int i=0;i<10;i++)    {        for(long k=0;k<size;k++)        {            v->push_back(s[k]);       }    } } template<typename T> void listInsert(list<T>*l,T*s,long size)   //向表插入数据 {    for(int i=0;i<10;i++)    {        for(long k=0;k<size;k++)        {            l->push_back(s[k]);        }      } } template<class T> void multisetInsert(multiset<T>*s1,T*s,long size)   //向多重集合插入数据 {    for(int i=0;i<10;i++)    {        for(long k=0;k<size;k++)        {            s1->insert(s[k]);          }    } } int* genIntData(long size)                  //生成随机数 {    int* data=new int[size];    generate(&data[0],&data[size],rand);    return data; }   int main(void) {    const long size=100000;    int* s_data,array1[size];    double begin,end;    s_data=genIntData(size);    vector<int> vector1;    list<int> list1;    multiset<int> multiset1;    clock();    cout<<"?"<<endl  //开始计算数组插入时间    getch();    begin=(double)clock()/CLK_TCK;    arrayInsert<int>(array1,s_data,size);    end=(double)clock()/CLK_TCK;    cout<<"??"<<(end-begin)<<endl;    //开始计算向量插入时间    getch();    begin=(double)clock()/CLK_TCK;    vectorInsert<int>(&vector1,s_data,size);    end=(double)clock()/CLK_TCK;    cout<<"??"<<(end-begin)<<endl;    //开始计算list插入时间     getch();    begin=(double)clock()/CLK_TCK;    listInsert<int>(&list1,s_data,size);    end=(double)clock()/CLK_TCK;    cout<<"??"<<(end-begin)<<endl;    //开始计算multiset插入时间    getch();    begin=(double)clock()/CLK_TCK;    multisetInsert<int>(&multiset1,s_data,size);    end=(double)clock()/CLK_TCK;    cout<<"??"<<(end-begin)<<endl;    getch();    free(s_data);    return 0;       }   这个程序清晰的表明这几种容器在插入速度之间的差别，当然，每种容器不是万能的，不能一好百好。比如说，多集在查找方面的优势是其他序列容器不可比拟的。  还有，最好不要试图超越STL，因为： 1、STL实现使用的是最佳算法。它是几乎完美的。 2、STL实现的设计者通常是相应领域的专家。 3、各领域的专家致力于提供灵活的、强大和高效的库。这是他们的首要的任务。对于，我们这些其余的人，开发可重用的容器和算法顶多只算第二个目标。我们的首要任务是交付紧扣主题的应用程序。大多数情况下，我们没有时间和专门的技术去和那些专家相比。 但是，超越STL不是不可能的。但是一般情况下，你只能靠牺牲可移植性来提高性能，这对于很多情况来说是很不好的。为了，超越STL，我们要付出非常大的努力。而且，最好我们知道一些STL专家们不知道的东西，尔后我们可以有针对性的进行优化，否则，我们的努力完全有可能白费。 面对这样一个优秀的库，并且它是免费的。我们C++程序员没有理由拒绝它，甚至去自己开发一个库。