C++编程思想 第1卷 第9章 内联函数 带内联函数的Stash和Stack

最新推荐文章于 2025-04-26 14:48:24 发布
原创 最新推荐文章于 2025-04-26 14:48:24 发布 · 388 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#C 编程思想
本文介绍了一个C++程序中用于管理动态内存的Stash和Stack类。Stash类通过内联函数提高了性能，Stack类则完全由内联函数构成。文章还提供了测试程序，验证了这些类的功能。

引入内联函数，可以把Stash和Stack类变得更有效

 

//: C09:Stash4.h
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
// Inline functions
#ifndef STASH4_H
#define STASH4_H
#include "../require.h"

class Stash {
  int size;      // Size of each space
  int quantity;  // Number of storage spaces
  int next;      // Next empty space
  // Dynamically allocated array of bytes:
  unsigned char* storage;
  void inflate(int increase);
public:
  Stash(int sz) : size(sz), quantity(0),
    next(0), storage(0) {}
  Stash(int sz, int initQuantity) : size(sz), 
    quantity(0), next(0), storage(0) { 
    inflate(initQuantity); 
  }
  Stash::~Stash() {
    if(storage != 0) 
      delete []storage;
  }
  int add(void* element);
  void* fetch(int index) const {
    require(0 <= index, "Stash::fetch (-)index");
    if(index >= next)
      return 0; // To indicate the end
    // Produce pointer to desired element:
    return &(storage[index * size]);
  }
  int count() const { return next; }
};
#endif // STASH4_H ///:~

 

小函数作为内联函数工作是理想的，要注意，两个最大的函数仍旧保留非
内联函数，因为要是把它们作为内联使用的话，很可能性能上得不到改善
 

//: C09:Stash4.cpp {O}
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
#include "Stash4.h"
#include <iostream>
#include <cassert>
using namespace std;
const int increment = 100;

int Stash::add(void* element) {
  if(next >= quantity) // Enough space left?
    inflate(increment);
  // Copy element into storage,
  // starting at next empty space:
  int startBytes = next * size;
  unsigned char* e = (unsigned char*)element;
  for(int i = 0; i < size; i++)
    storage[startBytes + i] = e[i];
  next++;
  return(next - 1); // Index number
}

void Stash::inflate(int increase) {
  assert(increase >= 0);
  if(increase == 0) return;
  int newQuantity = quantity + increase;
  int newBytes = newQuantity * size;
  int oldBytes = quantity * size;
  unsigned char* b = new unsigned char[newBytes];
  for(int i = 0; i < oldBytes; i++)
    b[i] = storage[i]; // Copy old to new
  delete [](storage); // Release old storage
  storage = b; // Point to new memory
  quantity = newQuantity; // Adjust the size
} ///:~

 

测试程序表面可以正常运行

 

//: C09:Stash4Test.cpp
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
//{L} Stash4
#include "Stash4.h"
#include "../require.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
  Stash intStash(sizeof(int));
  for(int i = 0; i < 100; i++)
    intStash.add(&i);
  for(int j = 0; j < intStash.count(); j++)
    cout << "intStash.fetch(" << j << ") = "
         << *(int*)intStash.fetch(j)
         << endl;
  const int bufsize = 80;
  Stash stringStash(sizeof(char) * bufsize, 100);
  ifstream in("Stash4Test.cpp");
  assure(in, "Stash4Test.cpp");
  string line;
  while(getline(in, line))
    stringStash.add((char*)line.c_str());
  int k = 0;
  char* cp;
  while((cp = (char*)stringStash.fetch(k++))!=0)
    cout << "stringStash.fetch(" << k << ") = "
         << cp << endl;
  getchar();
} ///:~

 

把Stash4Test.cpp 放到 工程目录

输出 正序输出
intStash.fetch(0) = 0
intStash.fetch(1) = 1
intStash.fetch(2) = 2
intStash.fetch(3) = 3
intStash.fetch(4) = 4
intStash.fetch(5) = 5
intStash.fetch(6) = 6
intStash.fetch(7) = 7
intStash.fetch(8) = 8
intStash.fetch(9) = 9
intStash.fetch(10) = 10
intStash.fetch(11) = 11
intStash.fetch(12) = 12
intStash.fetch(13) = 13
intStash.fetch(14) = 14
intStash.fetch(15) = 15
intStash.fetch(16) = 16
intStash.fetch(17) = 17
intStash.fetch(18) = 18
intStash.fetch(19) = 19
intStash.fetch(20) = 20
intStash.fetch(21) = 21
intStash.fetch(22) = 22
intStash.fetch(23) = 23
intStash.fetch(24) = 24
intStash.fetch(25) = 25
intStash.fetch(26) = 26
intStash.fetch(27) = 27
intStash.fetch(28) = 28
intStash.fetch(29) = 29
intStash.fetch(30) = 30
intStash.fetch(31) = 31
intStash.fetch(32) = 32
intStash.fetch(33) = 33
intStash.fetch(34) = 34
intStash.fetch(35) = 35
intStash.fetch(36) = 36
intStash.fetch(37) = 37
intStash.fetch(38) = 38
intStash.fetch(39) = 39
intStash.fetch(40) = 40
intStash.fetch(41) = 41
intStash.fetch(42) = 42
intStash.fetch(43) = 43
intStash.fetch(44) = 44
intStash.fetch(45) = 45
intStash.fetch(46) = 46
intStash.fetch(47) = 47
intStash.fetch(48) = 48
intStash.fetch(49) = 49
intStash.fetch(50) = 50
intStash.fetch(51) = 51
intStash.fetch(52) = 52
intStash.fetch(53) = 53
intStash.fetch(54) = 54
intStash.fetch(55) = 55
intStash.fetch(56) = 56
intStash.fetch(57) = 57
intStash.fetch(58) = 58
intStash.fetch(59) = 59
intStash.fetch(60) = 60
intStash.fetch(61) = 61
intStash.fetch(62) = 62
intStash.fetch(63) = 63
intStash.fetch(64) = 64
intStash.fetch(65) = 65
intStash.fetch(66) = 66
intStash.fetch(67) = 67
intStash.fetch(68) = 68
intStash.fetch(69) = 69
intStash.fetch(70) = 70
intStash.fetch(71) = 71
intStash.fetch(72) = 72
intStash.fetch(73) = 73
intStash.fetch(74) = 74
intStash.fetch(75) = 75
intStash.fetch(76) = 76
intStash.fetch(77) = 77
intStash.fetch(78) = 78
intStash.fetch(79) = 79
intStash.fetch(80) = 80
intStash.fetch(81) = 81
intStash.fetch(82) = 82
intStash.fetch(83) = 83
intStash.fetch(84) = 84
intStash.fetch(85) = 85
intStash.fetch(86) = 86
intStash.fetch(87) = 87
intStash.fetch(88) = 88
intStash.fetch(89) = 89
intStash.fetch(90) = 90
intStash.fetch(91) = 91
intStash.fetch(92) = 92
intStash.fetch(93) = 93
intStash.fetch(94) = 94
intStash.fetch(95) = 95
intStash.fetch(96) = 96
intStash.fetch(97) = 97
intStash.fetch(98) = 98
intStash.fetch(99) = 99
stringStash.fetch(1) = //: C09:Stash4Test.cpp
stringStash.fetch(2) = // From Thinking in C++, 2nd Edition
stringStash.fetch(3) = // Available at http://www.BruceEckel.com
stringStash.fetch(4) = // (c) Bruce Eckel 2000
stringStash.fetch(5) = // Copyright notice in Copyright.txt
stringStash.fetch(6) = //{L} Stash4
stringStash.fetch(7) = #include "Stash4.h"
stringStash.fetch(8) = #include "../require.h"
stringStash.fetch(9) = #include <fstream>
stringStash.fetch(10) = #include <iostream>
stringStash.fetch(11) = #include <string>
stringStash.fetch(12) = using namespace std;
stringStash.fetch(13) =
stringStash.fetch(14) = int main() {
stringStash.fetch(15) =   Stash intStash(sizeof(int));
stringStash.fetch(16) =   for(int i = 0; i < 100; i++)
stringStash.fetch(17) =     intStash.add(&i);
stringStash.fetch(18) =   for(int j = 0; j < intStash.count(); j++)
stringStash.fetch(19) =     cout << "intStash.fetch(" << j << ") = "
stringStash.fetch(20) =          << *(int*)intStash.fetch(j)
stringStash.fetch(21) =          << endl;
stringStash.fetch(22) =   const int bufsize = 80;
stringStash.fetch(23) =   Stash stringStash(sizeof(char) * bufsize, 100);
stringStash.fetch(24) =   ifstream in("Stash4Test.cpp");
stringStash.fetch(25) =   assure(in, "Stash4Test.cpp");
stringStash.fetch(26) =   string line;
stringStash.fetch(27) =   while(getline(in, line))
stringStash.fetch(28) =     stringStash.add((char*)line.c_str());
stringStash.fetch(29) =   int k = 0;
stringStash.fetch(30) =   char* cp;
stringStash.fetch(31) =   while((cp = (char*)stringStash.fetch(k++))!=0)
stringStash.fetch(32) =     cout << "stringStash.fetch(" << k << ") = "
stringStash.fetch(33) =          << cp << endl;
stringStash.fetch(34) = } ///:~

Stack类更好地使用了内联函数

//: C09:Stack4.h
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
// With inlines
#ifndef STACK4_H
#define STACK4_H
#include "../require.h"

class Stack {
  struct Link {
    void* data;
    Link* next;
    Link(void* dat, Link* nxt): 
      data(dat), next(nxt) {}
  }* head;
public:
  Stack() : head(0) {}
  ~Stack() {
    require(head == 0, "Stack not empty");
  }
  void push(void* dat) {
    head = new Link(dat, head);
  }
  void* peek() const { 
    return head ? head->data : 0;
  }
  void* pop() {
    if(head == 0) return 0;
    void* result = head->data;
    Link* oldHead = head;
    head = head->next;
    delete oldHead;
    return result;
  }
};
#endif // STACK4_H ///:~

 

Link析构函数在前面的Stack版本是以空的形式出现的，这里删除了

多数内联函数十分精细和明显，特别对于Link如此

如果所有的函数都是内联函数，那么使用库就会变得相当简单，因为不需要
进行库连接，注意没有Stack4.cpp

 

//: C09:Stack4Test.cpp
// From Thinking in C++, 2nd Edition
// Available at http://www.BruceEckel.com
// (c) Bruce Eckel 2000
// Copyright notice in Copyright.txt
//{T} Stack4Test.cpp
#include "Stack4.h"
#include "../require.h"
#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main(int argc, char* argv[]) {
  requireArgs(argc, 1); // File name is argument
  ifstream in(argv[1]);
  assure(in, argv[1]);
  Stack textlines;
  string line;
  // Read file and store lines in the stack:
  while(getline(in, line))
    textlines.push(new string(line));
  // Pop the lines from the stack and print them:
  string* s;
  while((s = (string*)textlines.pop()) != 0) {
    cout << *s << endl;
    delete s; 
  }
  getchar();
} ///:~

 

结果就是按行的逆序输出
有时创建的类都是内联成员函数时，可以把整个类放到头文件中，在程序
开发中，这是有益的，尽管编译时会花费更多的编译时间


输出
命令行参数 Stack4Test.cpp 的绝对路径，字符串要加引号，里面有斜括号
输出
} ///:~
  getchar();
  }
    delete s;
    cout << *s << endl;
  while((s = (string*)textlines.pop()) != 0) {
  string* s;
  // Pop the lines from the stack and print them:
    textlines.push(new string(line));
  while(getline(in, line))
  // Read file and store lines in the stack:
  string line;
  Stack textlines;
  assure(in, argv[1]);
  ifstream in(argv[1]);
  requireArgs(argc, 1); // File name is argument
int main(int argc, char* argv[]) {

using namespace std;
#include <string>
#include <iostream>
#include <fstream>
#include "../require.h"
#include "Stack4.h"
//{T} Stack4Test.cpp
// Copyright notice in Copyright.txt
// (c) Bruce Eckel 2000
// Available at http://www.BruceEckel.com
// From Thinking in C++, 2nd Edition
//: C09:Stack4Test.cpp
 

C++笔记
weixin_47820199的博客
05-12 284
一、C语言转型C++ 1、C—>C++ //C类型 typedef struct STASH { int size; //每个内存块大小 int quantity; //存储空间数 int next; //下一个空的空间 unsigned char *storage; //存储器 }Stash; void InitStash(Stash *s, int size); void CleanStash(Stash *s); int Add(Stash *s, int element);
C++编程思想 第1卷 第9章 内联函数 预处理器的缺陷
eyetired的博客
07-23 184
预处理器宏存在问题的关键是我们可能认为预处理器的行为和编译器的行为 一样。 当宏调用中使用表达式作为参数会出现问题 只要使用一个“普通”参数，宏和真的函数的工作方式非常相似 但只要一松懈并开始相信它是一个真的函数时，问题就出现了   //: C09:MacroSideEffects.cpp // From Thinking in C++, 2nd Edition // Available ...
c++对一个文件同时进行读写的例子代码
03-03 2605
ifstream in("testIn.txt");assure(in, "testIn.txt");//确保文件成功打开ofstream out("testOut.txt");assure(out, "testOut.txt");out<<in.rdbuf();//拷贝文件//以上代码为了确保有一个可读可写的文件作为测试iftream in2("testOut.txt
《C++编程思想》中的CStash第一个程序的欣赏
认知 行动 坚持
11-02 8359
看着看着，
C++ STL Stack 快速入门
Leo的专栏
09-27 1827
STACK 相对来说，STACK是一个比较简单的容器，他的
C++编程思想 第1卷 第16章 模板介绍 作为模板的Stash和Stack 模板化的指针Stash
eyetired的博客
08-06 452
重新组织PStash代码成为模板并不简单，因为一些常用函数不应当内联 除了增量的大小已经被模板化为具有默认值的无类参数以为，所以这个增量 的大小能在实例时修改 //: C16:TPStash.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bruce Eckel 2...
C++编程思想 第1卷 第16章 模板介绍 作为模板的Stash和Stack
eyetired的博客
08-05 246
如果客户程序员不显式地移去所有指向存放在容器中对象的指针，则容器应当 能正确地删除这些指针 容器拥有 不被移走的对象，负责清除它们 对于Stack,所有成员函数都能合理地内联   //: C16:TStack.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bru...
九、内联函数（Inline Functions）
最新发布
xjsj62728的博客
04-26 701
当一个函数代码只有几行，但会被频繁调用时，我们可以使用inline来节省时间并提高效率。内联函数是一个真正的函数，它在调用处被直接展开，就像预处理宏一样，因此可以消除函数调用的开销。内联函数 = 真正的函数 + 具有宏替换的效率。因此，我们在写代码是，应该永远不要使用宏，而是使用内联函数。示例内联函数 = 结合了宏的效率和函数的安全性。类内定义的函数默认使inline大型工程中，最好将inline函数定义写在类外，保持接口整洁。
C++编程思想 第1卷 第5章 隐藏实现 类 用访问控制来修改Stash
eyetired的博客
07-20 160
客户程序员的接口部分已经很清楚地很快 不用担心客户程序员会偶然访问到他们不该访问的内容了 //: C05:Stash.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bruce Eckel 2000 // Copyright notice in Copyright.t...
[C++]assert的加强版——Ensure的简易实现
weixin_33749131的博客
10-26 274
刘未鹏牛最近的一篇文章“C++11和快速迭代开发”中，提到一个小工具Ensure，很有用，但他不方便提供具体代码，这里我给出一个简易实现。   Ensure用法如： ENSURE(0 &lt;= index &amp;&amp; index &lt; v.size())(index)(v.size()); 断言失败时，会打印： Failed: 0 &lt;= index &amp;&am...
c++ 小记1
Tonight_Alive的专栏
06-07 706
1.../表示上一级文件夹 应该要把require.h放在这个工程中代码文件的上一级文件夹中 例如建一个projec工程，代码文件被放在project文件夹中，那就吧require.h放在project文件夹的上一级文件夹中 2.#include "../require.h" 一般这种是你自己写的头文件.一般库文件是用#include这种尖括号的 3.require.h#ifnd
C++编程思想 第1卷 第16章 模板介绍 模板语法 作为模板的Int
eyetired的博客
08-05 295
来自IntStack.cpp的容器和迭代器，作为一般的容器类使用模板来实现的 //: C16:StackTemplate.h // From Thinking in C++, 2nd Edition // Available at http://www.BruceEckel.com // (c) Bruce Eckel 2000 // Copyright notice in Copyright...
C++编程思想 第2卷 第7章 通用容器 关联式容器 多重集合
eyetired的博客
09-09 172
set仅允许插入每个值的唯一一个对象 而multiset看起来比较古怪 因为它允许插入每个值的多个对象 包含一个用于进行比较的元素与另一个不用于进行比较的元素的类 //: C07:MultiSet1.cpp // From "Thinking in C++, Volume 2", by Bruce Eckel &amp; Chuck Allison. // (c) 1995-2004 Min...
用C++写Stash
qq_31248551的博客
04-30 832
class Stash { int size; int quantity; int next; unsigned char* storage; public: void initialize(int size); int add(const void* element); void inflate(int increase); int count(); // 计算Stash里的数
咱们一起学C++ 第一百三十二篇：之内联函数优化Stash和Stack类
wj_rdk的博客
02-12 1490
在C++的学习之路上，我们一同前行，每一次分享都希望助力大家更好地理解这门语言。此次，我们将深入探讨如何使用内联函数优化Stash和Stack类，这有助于提高代码的执行效率，同时也是深入理解内联函数在实际编程中应用的重要途径。希望通过本次讲解，大家能掌握优化类设计的有效方法，一起在C++的知识海洋中继续成长，共同进步。
堆(heap)、栈(stack)、堆栈
weixin_61470035的博客
12-02 541
1.栈（Stack）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值