关键词搜索

源码搜索 ×
×

《C++编程思想》中的CStash第一个程序的欣赏

发布2014-11-02浏览8377次

详情内容

        看着《C++编程思想》， 有点意思羡慕， 来欣赏一下其中的CStash程序（有略微的改动）：

 

  1. #include <fstream>
  2. #include <iostream>
  3. #include <string>
  4. using namespace std;
  5.  
  6. // element: 存储元素
  7. // cell   : 存储空间（除了element之外， 可能还有没有利用、但是已经存在的cell空间）
  8.  
  9. const int increment = 100; // 定义每次膨胀的cell的个数
  10.  
  11. typedef struct CStashTag
  12. {
  13.     int size;       //一个cell的字节数
  14.     int quantity;   //cell的总数
  15.     int next;       //element的总数（也可以认为是下一个element的位置）
  16.     unsigned char* storage; // 指向cell堆空间
  17. }CStash;
  18.  
  19. void initiallize(CStash* s, int size);
  20. void cleanup(CStash* s);
  21. int add(CStash* s, const void* element);
  22. void* fetch(CStash* s, int index);
  23. int count(CStash* s);
  24. void inflate(CStash* s, int increase);
  25.  
  26. // 初始化后， 就知道每个cell的大小了， 若element为int, 则一个cell的大小为4
  27. void initialize(CStash* s, int sz)
  28. {
  29.     s->size = sz;
  30.     s->quantity = 0;
  31.     s->storage = NULL;
  32.     s->next = 0;
  33. }
  34.  
  35. int add(CStash* s, const void* element)
  36. {
  37.     if(s->next >= s->quantity) // cell数目不足以容纳更多的element， 则需要膨胀
  38. 	{
  39.         inflate(s, increment); // 每次膨胀100个cell
  40. 	}
  41.  
  42. 	// 增加一个element, 需要这个element中的值拷贝到下一个cell空间
  43.     int startBytes = s->next * s->size;
  44.     unsigned char* e = (unsigned char*)element;
  45.     for(int i = 0; i < s->size; i++) //逐个字节拷贝
  46. 	{
  47.         s->storage[startBytes + i] = e[i];
  48. 	}
  49.  
  50.     s->next++; // element数目自增
  51.  
  52.     return(s->next - 1); //最后一个element的下标 
  53. }
  54.  
  55. void* fetch(CStash* s,int index)
  56. {
  57.     if (index >= s->next)
  58. 	{
  59.         return NULL; 
  60. 	}
  61.  
  62.     // 返回index所对应的地址
  63.     return &(s->storage[index * s->size]); 
  64. }
  65.  
  66. int count(CStash* s)
  67. {
  68.     return s->next; //element的个数（也可以认为是下一个element的位置）
  69. }
  70.  
  71. void inflate(CStash* s, int increase)
  72. {
  73.     int newQuantity = s->quantity + increase; // 膨胀后的cell的总数
  74.     int newBytes = newQuantity * s->size; // 原来cell的总空间
  75.     int oldBytes = s->quantity * s->size; // 膨胀后cell的总空间
  76.     
  77. 	unsigned char* b = new unsigned char[newBytes];
  78.     for(int i = 0; i < oldBytes; i++)
  79. 	{
  80.        b[i] = s->storage[i]; //将旧内容复制到新的空间中， 也是逐字节复制
  81. 	}
  82.  
  83.     delete [](s->storage);//删除旧的存储空间
  84.     
  85. 	s->storage = b; //指向新的堆空间
  86.     s->quantity = newQuantity; // 膨胀后的cell的总数
  87. } 
  88.  
  89. void cleanup(CStash* s) 
  90. {
  91. 	// 我有一点点纳闷， 为什么其他的参数不清零， 而只进行下面的堆空间释放呢？
  92.  
  93.     if(NULL != s->storage) 
  94. 	{
  95.         cout << "freeing storage" << endl;
  96.         delete []s->storage;
  97.     }
  98. }
  99.  
  100.  
  101. int main()
  102. {
  103.  
  104. 	CStash intStash,stringStash;
  105. 	int i = 0;
  106.  
  107. 	// 初始化int对应的cell
  108. 	initialize(&intStash, sizeof(int));
  109.  
  110. 	// 申请cell, 并将element写入cell
  111. 	for(i = 0; i < 10; i++)
  112. 	{
  113. 		add(&intStash, &i);
  114. 	}
  115.  
  116. 	// 打印cell空间中的element
  117. 	for(i = 0; i < count(&intStash); i++)
  118. 	{
  119. 		cout << *(int*)fetch(&intStash, i) << endl;
  120. 	}
  121.  
  122.  
  123. 	// 如下代码功能类似上面， 所以我就不注释了
  124.  
  125.  
  126. 	ifstream in;
  127. 	string line;
  128. 	const int bufsize = 80;
  129. 	in.open("main.cpp");
  130.  
  131. 	initialize(&stringStash, sizeof(char) * bufsize);
  132. 	while(getline(in, line))
  133. 	{
  134. 		add(&stringStash, line.c_str());
  135. 	}
  136.  
  137. 	i = 0;
  138. 	char* cp = NULL;
  139. 	while(NULL != (cp = (char*)fetch(&stringStash, i++)))
  140. 	{
  141. 		cout << cp << endl;
  142. 	}
  143.  
  144. 	cleanup(&intStash);
  145. 	cleanup(&stringStash);
  146.  
  147. 	return 0;
  148. }

       程序的结果为：

 

0
1
2
3
4
5
6
7
8
9
#include <fstream>
#include <iostream>
#include <string>
using namespace std;


// element: 存储元素
// cell   : 存储空间（除了element之外， 可能还有没有利用、但是已经存在的cell空间


const int increment = 100; // 定义每次膨胀的cell的个数


typedef struct CStashTag
{
    int size;       //一个cell的字节数
    int quantity;   //cell的总数
    int next;       //element的总数（也可以认为是下一个element的位置）
    unsigned char* storage; // 指向cell堆空间
}CStash;


void initiallize(CStash* s, int size);
void cleanup(CStash* s);
int add(CStash* s, const void* element);
void* fetch(CStash* s, int index);
int count(CStash* s);
void inflate(CStash* s, int increase);


// 初始化后， 就知道每个cell的大小了， 若element为int, 则一个cell的大小为4
void initialize(CStash* s, int sz)
{
    s->size = sz;
    s->quantity = 0;
    s->storage = NULL;
    s->next = 0;
}


int add(CStash* s, const void* element)
{
    if(s->next >= s->quantity) // cell数目不足以容纳更多的element， 则需要膨胀
        {
        inflate(s, increment); // 每次膨胀100个cell
        }


        // 增加一个element, 需要这个element中的值拷贝到下一个cell空间
    int startBytes = s->next * s->size;
    unsigned char* e = (unsigned char*)element;
    for(int i = 0; i < s->size; i++) //逐个字节拷贝
        {
        s->storage[startBytes + i] = e[i];
        }


    s->next++; // element数目自增


    return(s->next - 1); //最后一个element的下标
}


void* fetch(CStash* s,int index)
{
    if (index >= s->next)
        {
        return NULL;
        }


    // 返回index所对应的地址
    return &(s->storage[index * s->size]);
}


int count(CStash* s)
{
    return s->next; //element的个数（也可以认为是下一个element的位置）
}


void inflate(CStash* s, int increase)
{
    int newQuantity = s->quantity + increase; // 膨胀后的cell的总数
    int newBytes = newQuantity * s->size; // 原来cell的总空间
    int oldBytes = s->quantity * s->size; // 膨胀后cell的总空间


        unsigned char* b = new unsigned char[newBytes];
    for(int i = 0; i < oldBytes; i++)
        {
       b[i] = s->storage[i]; //将旧内容复制到新的空间中， 也是逐字节复制
        }


    delete [](s->storage);//删除旧的存储空间


        s->storage = b; //指向新的堆空间
    s->quantity = newQuantity; // 膨胀后的cell的总数
}


void cleanup(CStash* s)
{
        // 我有一点点纳闷， 为什么其他的参数不清零， 而只进行下面的堆空间释放呢？


    if(NULL != s->storage)
        {
        cout << "freeing storage" << endl;
        delete []s->storage;
    }
}




int main()
{


        CStash intStash,stringStash;
        int i = 0;


        // 初始化int对应的cell
        initialize(&intStash, sizeof(int));


        // 申请cell, 并将element写入cell
        for(i = 0; i < 10; i++)
        {
                add(&intStash, &i);
        }


        // 打印cell空间中的element
        for(i = 0; i < count(&intStash); i++)
        {
                cout << *(int*)fetch(&intStash, i) << endl;
        }




        // 如下代码功能类似上面， 所以我就不注释了




        ifstream in;
        string line;
        const int bufsize = 80;
        in.open("main.cpp");


        initialize(&stringStash, sizeof(char) * bufsize);
        while(getline(in, line))
        {
                add(&stringStash, line.c_str());
        }


        i = 0;
        char* cp = NULL;
        while(NULL != (cp = (char*)fetch(&stringStash, i++)))
        {
                cout << cp << endl;
        }


        cleanup(&intStash);
        cleanup(&stringStash);


        return 0;
}
freeing storage
freeing storage


       其实， 从上面可以看到， CStash结构体显得有点多余， 直接用size, quantity, storage, next也是可以的。 之所以还要用结构体， 完全是为了整体性， 让有点关系的size, quantity, storage, next成为一个有机体， 便于理解， 便于编程， 便于维护， 这就是结构体的最大作用吧微笑

相关技术文章

最新源码

下载排行榜
点击QQ咨询
开通会员
返回顶部
×
微信扫码支付 元
微信扫码支付
确定支付下载
请使用微信描二维码支付
×

提示信息

×

选择支付方式

  • 微信支付
  • 支付宝付款
确定支付下载