2.3 基于对象的设计

练习2.5, 2.6, 2.7没看明白。

下面是第一步所支持操作的集合：

1.数组类的实现中有内置的自我意识。首先，它知道自己的大小。
2.数组类支持数组之间的赋值、以及两个数组之间的相等和不相等的比较操作。
3.数组类应该支持对其所含的值进行下列查询操作：
数组中最小值是什么？
最大值是什么？
某个特殊的值是否在数组中？如果存在，它占的第一个位置的索引是什么？
4.数组类支持自排序。为了便于讨论，假定存在一群用户，他们认为数组支持排序的功能很重要。而另外一些人对此却不以为然。

除了支持数组操作，还必须支持数组本身的机制，包括：
5.能够指定长度，以此来创建数组（这个值无需在编译时刻知道）。
6.能够用一组值初始化数组。
7.能够通过一个索引来访问数组中的单个元素。为便于讨论，假设用户强烈要求用数组下标操作符来实现这项功能。

8.能够截获并指出错误的索引值。假设我们认为这很有必要，所以没有询问用户的想法。我们认为这是一个设计良好的数组所必须实现的。

class classname {
public:
	// 公有操作集合
private:
	// 私有实现代码
};

// 单个IntArray 类对象
IntArray myArray;
// 指向IntArray 类对象的指针
IntArray *pArray = new IntArray;

class IntArray {
public:
	// 相等与不相等操作： #2b
	bool operator==( const IntArray& ) const;
	bool operator!=( const IntArray& ) const;
	
	// 赋值操作符 #2a
	IntArray& operator=( const IntArray& );
	
	int size() const; // #1	
	void sort(); // #4
	
	int min() const; // #3a
	int max() const; // #3b
	
	// 如值在数组中找到
	// 返回第一次出现的索引
	// 否则返回-1
	int find( int value ) const; // #3c
private:
	// 私有实现代码
};

int min_val = myArray.min();
int max_val = pArray->max();

	IntArray myArray0, myArray1;
赋值操作符可以这样应用
	// 调用拷贝赋值成员函数
	// myArray0.operator=( myArray1 )
	myArray0 = myArray1;
等于操作符的调用如下所示
	// 调用等于成员函数
	// myArray0.operator==( myArray1 )
	if ( myArray0 == myArray1 )
		cout << "!!our assignment operator works!\n";

class IntArray {
public:
// ...
int size() const { return _size; }
private:
// 内部数据
int _size;
int *ia;
};

由于C++不允许成员函数与数据成员共享同一个名字，所以在这样的情况下，一般的习惯是在数据成员名字前面加一个下划线（_）。

内联函数在它的调用点上被展开。一般来说，内联函数不会引入任何函数调用。
for ( int index = 0; index < array.size(); ++index )
// ...
并没有真的被调用_size 次，而是在编译期间被内联扩展为下面的一般形式：
// array.size()的内联扩展
for ( int index = 0; index < array._size; ++index)

5.能够指定长度，以此来创建数组（这个值无需在编译时刻知道）。
6.能够用一组值初始化数组。
7.能够通过一个索引来访问数组中的单个元素。为便于讨论，假设用户强烈要求用数组下标操作符来实现这项功能。
8.能够截获并指出错误的索引值。假设我们认为这很有必要，所以没有询问用户的想法。我们认为这是一个设计良好的数组所必须实现的。

如果构造函数被定义了，那么在类的每个对象第一次被使用之前，这构造函数就被自动应用在对象上。

class IntArray {
public:
	explicit IntArray( int sz = DefaultArraySize );
	IntArray( int *array, int array_size );
	IntArray( const IntArray &rhs );	// 类的拷贝构造函数（copy constructor）
	// ...
private:
	static const int DefaultArraySize = 12;
	// ...
};

IntArray array1( 1024 );	// explicit IntArray( int sz = DefaultArraySize );
IntArray array2;	// explicit IntArray( int sz = DefaultArraySize );

IntArray::IntArray( int sz )
{
	// 设置数据成员
	_size = sz;
	ia = new int[ _size ];
	// 初始化内存
	for ( int ix=0; ix < _size; ++ix )
		ia[ ix ] = 0;
}

int ia[10] = {0,1,2,3,4,5,6,7,8,9};
IntArray iA3(ia,10);	// IntArray( int *array, int array_size );
IntArray::IntArray( int *array, int sz )
{
	// 设置数据成员
	_size = sz;
	ia = new int[ _size ];
	// 拷贝数据成员
	for ( int ix=0; ix < _size; ++ix )
		iz[ix ] = array[ ix ];
}

IntArray array;
// 等价的初始化方式
IntArray ia1 = array;	// IntArray( const IntArray &rhs );
IntArray ia2( array );

IntArray::IntArray( const IntArray &rhs )
{
	// 拷贝构造函数
	_size = rhs._size;
	ia = new int[ _size ];
	for (int ix = 0; ix < _size; ix++ )
		iz[ ix ] = rhs.ia[ ix ];
}

lhs(left hand side)和 rhs(right hand side), 表示左操作数与右操作数。

引用是一种没有指针语法的指针。（因此，我们写成rhs._size, 而不是rhs->_size。）

class IntArray {
public:
	// ...
private:
	void init( int sz, int *array );
	// ...
};

void IntArray::init( int sz, int *array )
{
	_size = sz;
	ia = new int[ _size ];
	for ( int ix=0; ix < _size; ++ix )
		if ( ! array )
			ia[ ix ] = 0;
		else ia[ ix ] = array[ ix ];
}

IntArray::IntArray( int sz )
{
	init( sz, 0 );
}
IntArray::IntArray( int *array, int sz )
{
	init( sz, array );
}
IntArray::IntArray( const IntArray &rhs )
{
	init( rhs._size, rhs.ia );
}

如果构造函数被定义了，那么在类的每个对象第一次被使用之前，这构造函数就被自动应用在对象上。
每个类对象在被程序最后一次使用之后，它的析构函数就会被自动调用。

class IntArray {
public:
	// 构造函数
	explicit IntArray( int size = DefaultArraySize );
	IntArray( int *array, int array_size );
	IntArray( const IntArray &rhs );
	// 析构函数
	~IntArray() { delete [] ia; }
	// ...
private:
	// ...
};

#include <cassert>

int&IntArray::operator[]( int index )
{
	assert( index >= 0 && index < _size );
	return ia[ index ];
}

class IntArray {
public:
	// 构造函数
	explicit IntArray( int size = DefaultArraySize );
	IntArray( int *array, int array_size );
	IntArray( const IntArray &rhs );
	// 析构函数
	~IntArray() { delete [] ia; }
	// ...
private:
	// ...
};

#include <cassert>

int&IntArray::operator[]( int index )
{
	assert( index >= 0 && index < _size );
	return ia[ index ];
}

类定义以及相关的常数值或typedef 名通常都存储在头文件中，并且头文件以类名来命名。因此，假如我们创建一对头文件：IntArray.h 和Matrix.h，则所有打算使用IntArray 类或Matrix 类的程序就都必须包含相关的头文件。

类似地，不在类定义内部定义的类成员函数都存储在与类名同名的程序文本文件中。例如，我们将创建一对程序文本文件：IntArray.C 和Matrix.C，用来存储相关类的成员函数。

如果class需要一个copy constructor, 一个copy assignment operator, 或是一个destructor, 它大约也就同时需要三者。
如果class内有（至少）一个指向某块heap内存的指针，该内存在class constructor内分配，需由destructor释放，那么该class便需要上述三个函数。