C++在C的面向过程概念的基础上提供了面向对象和模板（泛型编程）的语法功能。
下面以一个简单实例（动态数组的简单封装，包括下标的值可以是任意正数值，并提供边界检查）来说明C++是如何实现其逐层抽象的。
1 用结构体实现
// array.h
// array库的接口
#ifndef _array_h
#define _array_h
// 可指定下标范围的数组的存储
struct DoubleArray{
int low;
int high;
double *storage;
};
// 根据low和high为数组分配空间。分配成功，返回值为true，否则返回值为false
bool initialize(DoubleArray &arr, int low, int high);
// 设置数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool insert(const DoubleArray &arr, int index, double value);
// 取数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool fatch(const DoubleArray &arr, int index, double &value);
// 回收数组空间
void cleanup(const DoubleArray &arr);
#endif
// array.cpp
// array库的实现
#include "array.h"
#include <IOStream>
using namespace std;
// 根据low和high为数组分配空间。分配成功，返回值为true，否则返回值为false
bool initialize(DoubleArray &arr, int low, int high)
{
arr.low = low;
arr.high = high;
arr.storage = new double [high - low + 1];
if (arr.storage == NULL)
return false;
else
return true;
}
// 设置数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool insert(const DoubleArray &arr, int index, double value)
{
if (index < arr.low || index > arr.high)
return false;
arr.storage[index - arr.low] = value;
return true;
}
// 取数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool fatch(const DoubleArray &arr, int index, double &value)
{
if (index < arr.low || index > arr.high)
return false;
value = arr.storage[index - arr.low] ;
return true;
}
// 回收数组空间
void cleanup(const DoubleArray &arr)
{
if (arr.storage)
delete [] arr.storage;
}
// arrayApp.cpp
// array库的应用示例
#include <iostream>
using namespace std;
#include "array.h"
int main()
{
DoubleArray array; // DoubleArray是array库中定义的结构体类型
double value;
int low, high, i;
//输入数组的下标范围
cout <<"请输入数组的下标范围：";
cin >> low >> high;
//初始化数组array，下标范围为20到30
if (!initialize(array, low, high)) {
cout <<"空间分配失败" ; return 1;
}
for (i = low; i <= high; ++i) { // 数组元素的输入
cout <<"请输入第"<< i <<"个元素：";
cin >> value;
insert(array, i, value); // 将value存入数组array的第i个元素
}
while (true) { // 读取第i个元素
cout <<"请输入要读取的元素序号（0表示结束）：";
cin >> i;
if (i == 0)
break;
if (fatch(array, i, value))
cout << value << endl;
else
cout <<"下标越界n";
}
cleanup(array); //回收存储数组元素的空间
return 0;
}
相关的函数全部有一个结构体函数参数，来操作结构体。通过头文件包括结构体和函数声明来实现模块化并提供接口，实现一个较松散的数据与函数的结合。
而类则不同，类除了提供数据聚合的结构体功能以外，还可以将函数封装进去，通过类名实现名字空间，并为成员函数提供一个隐含的指向类对象的this指针，使其成员函数能够访问并操作数据成员。
2 用一个不完整的类来模拟结构体实现
// array.h
// 改进后的array接口
#ifndef _array_h
#define _array_h
struct DoubleArray{
int low;
int high;
double *storage;
// 根据low和high为数组分配空间。分配成功，返回值为true，否则返回值为false
bool initialize(int lh, int rh);
// 设置数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool insert(int index, double value);
// 取数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool fatch(int index, double &value);
// 回收数组空间
void cleanup();
};
#endif
// array.cpp
// 改进后的array库的实现
#include "array.h"
#include <iostream>
using namespace std;
// 根据low和high为数组分配空间。分配成功，返回值为true，否则返回值为false
bool DoubleArray::initialize(int lh, int rh)
{
low = lh;
high = rh;
storage = new double [high - low + 1];
if (storage == NULL)
return false;
else return true;
}
// 设置数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool DoubleArray::insert(int index, double value)
{
if (index < low || index > high)
return false;
storage[index - low] = value;
return true;
}
// 取数组元素的值
// 返回值为true表示操作正常，返回值为false表示下标越界
bool DoubleArray::fatch(int index, double &value)
{
if (index < low || index > high)
return false;
value = storage[index - low] ;
return true;
}
//回收数组空间
void DoubleArray::cleanup()
{
if (storage)
delete [] storage;
}
// arrayapp.cpp
// 改进后的array库的应用示例
#include <iostream>
using namespace std;
#include "array.h"
int main()
{
DoubleArray array;
double value;
int low, high, i;
//输入数组的下标范围
cout <<"请输入数组的下标范围：";
cin >> low >> high;
if (!array.initialize(low, high)) { // 为array申请存储数组元素的空间
cout <<"空间分配失败" ; return 1;
}
//数组array的初始化
for (i = low; i <= high; ++i) { //数组元素的输入
cout <<"请输入第"<< i <<"个元素:";
cin >> value;
array.insert(i, value);
}
while (true) { //数组元素的访问
cout <<"请输入要访问的元素序号(0表示结束）:";
cin >> i;
if (i == 0)
break;
if (array.fatch(i, value))
cout << value << endl;
else
cout <<"下标越界n";
}
array.cleanup(); //归还存储数组元素的空间
return 0;
}
3 用定义较为完整的类来实现
类还实现了资源获取即初始化(RAII, Resource Acquisition Is Initialization)以及自动实现资源析构的功能，以及对运算符的重载等功能。
// DoubleArray.h
// DoubleArray类的定义
#ifndef _array_h
#define _array_h
#include <iostream.h>
class DoubleArray{
friend ostream &operator<<(ostream &os, const DoubleArray &obj);
friend istream &operator>>(istream &is, DoubleArray &obj);
friend bool operator==(const DoubleArray &obj1, const DoubleArray &obj2);
private:
int low;
int high;
double *storage;
public:
// 构造函数根据low和high为数组分配空间
DoubleArray(int lh = 0, int rh = 0):low(lh), high(rh)
{
storage = new double [high - low + 1];
}
// 复制构造函数
DoubleArray(const DoubleArray &arr);
// 赋值运算符重载函数
DoubleArray &operator=(const DoubleArray &right);
// 下标运算符重载函数
double & operator[](int index); // 作为左值
const double & operator[](int index) const; // 作为右值
// 取数组的一部分形成一个新的数组
DoubleArray operator()(int start, int end, int lh);
// 析构函数
~DoubleArray() {
if (storage)
delete [] storage;
}
};
#endif
// DoubleArray.cpp
// DoubleArray类的实现
#include <cassert>
#include "DoubleArray.h"
DoubleArray::DoubleArray(const DoubleArray &arr)
{
low = arr.low;
high = arr.high;
storage = new double [high - low + 1];
for (int i = 0; i < high -low + 1; ++i)
storage[i] = arr.storage[i];
}
DoubleArray &DoubleArray::operator=(const DoubleArray & a)
{
if (this == &a) // 防止自己复制自己
return *this;
delete [] storage; // 归还空间
low = a.low; high = a.high;
storage = new double[high - low + 1]; // 根据新的数组大小重新申请空间
for (int i=0; i <= high - low; ++i)
storage[i] = a.storage[i]; // 复制数组元素
return *this;
}
double & DoubleArray::operator[](int index)
{
assert(index >= low && index <= high);
return storage[index - low];
}
const double & DoubleArray::operator[](int index) const
{
assert(index >= low && index <= high);
return storage[index - low];
}
ostream &operator<<(ostream &os, const DoubleArray &obj)
{
os <<"数组内容为：n";
for (int i=obj.low; i<=obj.high; ++i)
os << obj[i] << 't';
os << endl;
return os;
}
istream &operator>>(istream &is, DoubleArray &obj)
{
cout <<"请输入数组元素["<< obj.low <<", "<< obj.high <<"]:n";
for (int i=obj.low; i<=obj.high ; ++i)
is >> obj[i] ;
return is;
}
bool operator==(const DoubleArray &obj1, const DoubleArray &obj2)
{
if (obj1.low != obj2.low || obj1.high != obj2.high)
return false;
for (int i = obj1.low; i<=obj1.high; ++i)
if (obj1[i] != obj2[i])
return false;
return true;
}
DoubleArray DoubleArray::operator()(int start, int end, int lh)
{
assert (start <= end && start >= low && end <= high ); // 判断范围是否正确
DoubleArray tmp(lh, lh + end - start); // 为取出的数组准备空间
for (int i = 0; i < end - start + 1; ++i)
tmp.storage[i] = storage[start + i - low];
return tmp;
}
// DoubleArrayApp.cpp
// DoubleArray类的使用
#include "DoubleArray.h"
int main()
{
DoubleArray array1(20,30), array2;
cin >> array1; // 利用流提取运算符重载输入array1
cout <<"array1 "; cout << array1; // 利用流插入运算符重载输出array1
array2 = array1; // 利用赋值运算符重载将array1赋给array2
cout <<"执行 array2 = array1, array2 ";
cout << array2;
// 利用==重载比较array1和array2
cout <<"array1 == array2 是 "<< ((array1 == array2) ? "true" : "false") << endl;
array2[25] = 0; // 利用下标运算符重载为array2的元素赋值
cout <<"执行array[25] = 0后, array1 == array2 是 "
<< ((array1 == array2) ? "true" : "false") << endl;
array2 = array1(22, 25, 2);
cout <<"执行array2 = array1(22, 25, 2)后, array2 的值为： "<< array2;
while(1);
return 0;
}
4 用模板实现泛型
强类型一定程度上实现了类型在编译期的检查功能，而模板却可以让类并不囿于过于具体的类型：
// array.h
#include <iostream.h>
// 类模板的友元：重载输入运算符
template<class T>
class Array; // 类模板Array的声明
template<class T>
ostream &operator<<(ostream &os, const Array<T>&obj); // 输出重载声明
template <class T>
class Array {
friend ostream &operator<<(ostream &os, const Array<T>&obj);
private:
int low;
int high;
T *storage;
public:
// 根据low和high为数组分配空间。分配成功，返回值为true，否则返回值为false
Array(int lh = 0, int rh = 0):low(lh),high(rh)
{
storage = new T [high - low + 1];
}
// 复制构造函数
Array(const Array &arr);
// 赋值运算符重载函数
Array &operator=(const Array & a);
// 下标运算符重载函数
T & operator[](int index);
const T & operator[](int index) const; // 作为右值
// 回收数组空间
~Array(){
if(storage)
delete [] storage;
}
};
template <class T>
T & Array<T>::operator[](int index)
{
if (index < low || index > high)
{
cout <<"下标越界";
return;
}
return storage[index - low];
}
template <class T>
const T & Array<T>::operator[](int index) const
{
if (index < low || index > high)
{
cout <<"下标越界";
return;
}
return storage[index - low];
}
// 类模板的友元：重载输出运算符
template<class T>
ostream &operator<<(ostream &os, const Array<T>&obj)
{
os << endl;
for (int i=0; i < obj.high - obj.low + 1; ++i)
os << obj.storage[i] << 't';
return os;
}
template<class T>
Array<T>::Array(const Array<T> &arr)
{
low = arr.low;
high = arr.high;
storage = new T [high - low + 1];
for (int i = 0; i < high -low + 1; ++i)
storage[i] = arr.storage[i];
}
template<class T>
Array<T> &Array<T>::operator=(const Array<T> & a)
{
if (this == &a) // 防止自己复制自己
return *this;
delete [] storage; // 归还空间
low = a.low; high = a.high;
storage = new T[high - low + 1]; // 根据新的数组大小重新申请空间
for (int i=0; i <= high - low; ++i)
storage[i] = a.storage[i]; // 复制数组元素
return *this;
}
// main.cpp
#include <iostream.h>
#include "array.h"
int main()
{
int start, end;
cout<<"请输入数组的下标和上标，如1 9：";
cin>>start>>end;
Array<double> arr(start,end), arr2;
for(int i = start ; i<= end-start+1 ; i++)
arr[i] = i*0.9;
arr[8] = 8.8;
arr2 = arr;
cout<<arr2<<endl;
while(1);
return 0;
}
－End－
京公网安备 11010802035086号