1.模板语法
template关键字告诉编译器，随后的类定义将操作一个或更多未指明的类型。当由这个模板产生实际类代码时，必须指定这些类型以使编译器能够替换它们。
template
class Array { T A[size]; }
template<class T>
class Array {
enum {
size = 100 };
T A[size];
public:
T& operator[](int index) {
require(index >= 0 && index < size,
"Index out of range");
return A[index];
}
};
int main() {
Array<int> ia;
Array<float> fa;
for(int i=0; i < 20; i++) {
ia[i] = i * i;
fa[i] = float(i) * 1.414;
}
for(int j=0; j < 20; j++) {
cout << j << ":" << ia[j] << "," << fa[j] << endl;
}
}
- static静态变量定义，在调用函数内部定义static变量时，目的是保存此次调用结果的值，保证下一次调用能够使用。
int fibonacci(int) {
const int sz = 100;
require(n < sz);
static int f[sz]; //Initialized to zero；注意这里是static静态变量，目的是多次调用fibonacci(),上一次保存的值依然存在
f[0] = f[1] = 1;
int i;
//此处for()循环体的与static配套使用
for (i = 0; i < sz; i++) {
if(f[i] == 0)
break;
}
while (i <= n) {
f[i] = f[i-1] + f[i-2];
i++;
}
return f[n];
}
2.迭代器
1）**int operator++()与int operator++(int)**的区别：
- int operator++()：是 ++index；
- int operator++(int)：是 index++；
class IntStack
{
enum
{
ssize = 100
};
int stack[ssize];
int top;
public:
IntStack() : top(0) {
};
void push(int i) {
require(top < ssize, "Too many push()es");
stack[top++] = i;
}
int pop() {
require(top > 0, "Too many pop()s");
return stack[--top];
}
friend class IntStackIter;
};
class IntStackIter
{
IntStack& s;
int index;
public:
IntStackIter(IntStack& is) : s(is), index(0) {
};
int operator++() {
require(index < s.top, "iterator moved out of range");
return s.stack[++index];
}
int operator++(int) {
require(index < s.top, "iterator moved out of range");
return s.stack[index++];
}
};
int main(int argc, char const *argv[])
{
IntStack is,is2;
for (int i = 0; i < 20; ++i)
{
is.push(fibonacci(i));
is2.push(fibonacci(i));
}
IntStackIter it(is),itt(is2);
for (int i = 0; i < 20; ++i)
{
cout << ++it << endl;
}
for (int i = 0; i < 20; ++i)
{
cout << (itt)++ << endl;
}
return 0;
}
3.类内嵌套iterator类及friend的使用
- 当创建一个嵌套friend类的时候，我们必须经过首先声明这个类的名称，然后声明它是友元，最后定义这个类的过程。否则，编译器将会产生混淆。
class IntStack
{
enum
{
ssize = 100
};
int stack[ssize];
int top;
public:
IntStack() : top(0) {
};
void push(int i) {
require(top < ssize, "Too many push()es");
stack[top++] = i;
}
int pop() {
require(top > 0, "Too many pop()s");
return stack[--top];
}
class iterator;
friend class iterator;
class iterator {
IntStack& s;
int index;
public:
iterator(IntStack& is) : s(is), index(0) {
};
iterator(IntStack& is, bool) : s(is), index(s.top) {
}
int current() const {
return s.stack[index];}
int operator++() {
require(index < s.top, "iterator moved out of range");
return s.stack[++index];
}
int operator++(int) {
require(index < s.top, "iterator moved out of range");
return s.stack[index++];
}
}
};